source: trip-planner-front/node_modules/@angular/cdk/esm2015/testing/testbed/task-state-zone-interceptor.js

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { BehaviorSubject } from 'rxjs';
/** Unique symbol that is used to patch a property to a proxy zone. */
const stateObservableSymbol = Symbol('ProxyZone_PATCHED#stateObservable');
/**
 * Interceptor that can be set up in a `ProxyZone` instance. The interceptor
 * will keep track of the task state and emit whenever the state changes.
 *
 * This serves as a workaround for https://github.com/angular/angular/issues/32896.
 */
export class TaskStateZoneInterceptor {
    constructor(_lastState) {
        this._lastState = _lastState;
        /** Subject that can be used to emit a new state change. */
        this._stateSubject = new BehaviorSubject(this._lastState ? this._getTaskStateFromInternalZoneState(this._lastState) : { stable: true });
        /** Public observable that emits whenever the task state changes. */
        this.state = this._stateSubject;
    }
    /** This will be called whenever the task state changes in the intercepted zone. */
    onHasTask(delegate, current, target, hasTaskState) {
        if (current === target) {
            this._stateSubject.next(this._getTaskStateFromInternalZoneState(hasTaskState));
        }
    }
    /** Gets the task state from the internal ZoneJS task state. */
    _getTaskStateFromInternalZoneState(state) {
        return { stable: !state.macroTask && !state.microTask };
    }
    /**
     * Sets up the custom task state Zone interceptor in the  `ProxyZone`. Throws if
     * no `ProxyZone` could be found.
     * @returns an observable that emits whenever the task state changes.
     */
    static setup() {
        if (Zone === undefined) {
            throw Error('Could not find ZoneJS. For test harnesses running in TestBed, ' +
                'ZoneJS needs to be installed.');
        }
        // tslint:disable-next-line:variable-name
        const ProxyZoneSpec = Zone['ProxyZoneSpec'];
        // If there is no "ProxyZoneSpec" installed, we throw an error and recommend
        // setting up the proxy zone by pulling in the testing bundle.
        if (!ProxyZoneSpec) {
            throw Error('ProxyZoneSpec is needed for the test harnesses but could not be found. ' +
                'Please make sure that your environment includes zone.js/dist/zone-testing.js');
        }
        // Ensure that there is a proxy zone instance set up, and get
        // a reference to the instance if present.
        const zoneSpec = ProxyZoneSpec.assertPresent();
        // If there already is a delegate registered in the proxy zone, and it
        // is type of the custom task state interceptor, we just use that state
        // observable. This allows us to only intercept Zone once per test
        // (similar to how `fakeAsync` or `async` work).
        if (zoneSpec[stateObservableSymbol]) {
            return zoneSpec[stateObservableSymbol];
        }
        // Since we intercept on environment creation and the fixture has been
        // created before, we might have missed tasks scheduled before. Fortunately
        // the proxy zone keeps track of the previous task state, so we can just pass
        // this as initial state to the task zone interceptor.
        const interceptor = new TaskStateZoneInterceptor(zoneSpec.lastTaskState);
        const zoneSpecOnHasTask = zoneSpec.onHasTask.bind(zoneSpec);
        // We setup the task state interceptor in the `ProxyZone`. Note that we cannot register
        // the interceptor as a new proxy zone delegate because it would mean that other zone
        // delegates (e.g. `FakeAsyncTestZone` or `AsyncTestZone`) can accidentally overwrite/disable
        // our interceptor. Since we just intend to monitor the task state of the proxy zone, it is
        // sufficient to just patch the proxy zone. This also avoids that we interfere with the task
        // queue scheduling logic.
        zoneSpec.onHasTask = function (...args) {
            zoneSpecOnHasTask(...args);
            interceptor.onHasTask(...args);
        };
        return zoneSpec[stateObservableSymbol] = interceptor.state;
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-state-zone-interceptor.js","sourceRoot":"","sources":["../../../../../../../src/cdk/testing/testbed/task-state-zone-interceptor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,eAAe,EAAa,MAAM,MAAM,CAAC;AASjD,sEAAsE;AACtE,MAAM,qBAAqB,GAAG,MAAM,CAAC,mCAAmC,CAAC,CAAC;AAO1E;;;;;GAKG;AACH,MAAM,OAAO,wBAAwB;IAQnC,YAAoB,UAA6B;QAA7B,eAAU,GAAV,UAAU,CAAmB;QAPjD,2DAA2D;QAC1C,kBAAa,GAAG,IAAI,eAAe,CAChD,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,kCAAkC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC,CAAC;QAEjG,oEAAoE;QAC3D,UAAK,GAA0B,IAAI,CAAC,aAAa,CAAC;IAEP,CAAC;IAErD,mFAAmF;IACnF,SAAS,CAAC,QAAsB,EAAE,OAAa,EAAE,MAAY,EAAE,YAA0B;QACvF,IAAI,OAAO,KAAK,MAAM,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,kCAAkC,CAAC,YAAY,CAAC,CAAC,CAAC;SAChF;IACH,CAAC;IAED,+DAA+D;IACvD,kCAAkC,CAAC,KAAmB;QAC5D,OAAO,EAAC,MAAM,EAAE,CAAC,KAAK,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,SAAS,EAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK;QACV,IAAI,IAAI,KAAK,SAAS,EAAE;YACtB,MAAM,KAAK,CAAC,gEAAgE;gBAC1E,+BAA+B,CAAC,CAAC;SACpC;QAED,yCAAyC;QACzC,MAAM,aAAa,GAAI,IAAY,CAAC,eAAe,CAA8B,CAAC;QAElF,4EAA4E;QAC5E,8DAA8D;QAC9D,IAAI,CAAC,aAAa,EAAE;YAClB,MAAM,KAAK,CACT,yEAAyE;gBACzE,8EAA8E,CAAC,CAAC;SACnF;QAED,6DAA6D;QAC7D,0CAA0C;QAC1C,MAAM,QAAQ,GAAG,aAAa,CAAC,aAAa,EAAsB,CAAC;QAEnE,sEAAsE;QACtE,uEAAuE;QACvE,kEAAkE;QAClE,gDAAgD;QAChD,IAAI,QAAQ,CAAC,qBAAqB,CAAC,EAAE;YACnC,OAAO,QAAQ,CAAC,qBAAqB,CAAE,CAAC;SACzC;QAED,sEAAsE;QACtE,2EAA2E;QAC3E,6EAA6E;QAC7E,sDAAsD;QACtD,MAAM,WAAW,GAAG,IAAI,wBAAwB,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;QACzE,MAAM,iBAAiB,GAAG,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE5D,uFAAuF;QACvF,qFAAqF;QACrF,6FAA6F;QAC7F,2FAA2F;QAC3F,4FAA4F;QAC5F,0BAA0B;QAC1B,QAAQ,CAAC,SAAS,GAAG,UAAS,GAAG,IAA8C;YAC7E,iBAAiB,CAAC,GAAG,IAAI,CAAC,CAAC;YAC3B,WAAW,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,CAAC;QACjC,CAAC,CAAC;QAEF,OAAO,QAAQ,CAAC,qBAAqB,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC;IAC7D,CAAC;CACF","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {BehaviorSubject, Observable} from 'rxjs';\nimport {ProxyZone, ProxyZoneStatic} from './proxy-zone-types';\n\n/** Current state of the intercepted zone. */\nexport interface TaskState {\n  /** Whether the zone is stable (i.e. no microtasks and macrotasks). */\n  stable: boolean;\n}\n\n/** Unique symbol that is used to patch a property to a proxy zone. */\nconst stateObservableSymbol = Symbol('ProxyZone_PATCHED#stateObservable');\n\n/** Type that describes a potentially patched proxy zone instance. */\ntype PatchedProxyZone = ProxyZone & {\n  [stateObservableSymbol]: undefined|Observable<TaskState>;\n};\n\n/**\n * Interceptor that can be set up in a `ProxyZone` instance. The interceptor\n * will keep track of the task state and emit whenever the state changes.\n *\n * This serves as a workaround for https://github.com/angular/angular/issues/32896.\n */\nexport class TaskStateZoneInterceptor {\n  /** Subject that can be used to emit a new state change. */\n  private readonly _stateSubject = new BehaviorSubject<TaskState>(\n      this._lastState ? this._getTaskStateFromInternalZoneState(this._lastState) : {stable: true});\n\n  /** Public observable that emits whenever the task state changes. */\n  readonly state: Observable<TaskState> = this._stateSubject;\n\n  constructor(private _lastState: HasTaskState|null) {}\n\n  /** This will be called whenever the task state changes in the intercepted zone. */\n  onHasTask(delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState) {\n    if (current === target) {\n      this._stateSubject.next(this._getTaskStateFromInternalZoneState(hasTaskState));\n    }\n  }\n\n  /** Gets the task state from the internal ZoneJS task state. */\n  private _getTaskStateFromInternalZoneState(state: HasTaskState): TaskState {\n    return {stable: !state.macroTask && !state.microTask};\n  }\n\n  /**\n   * Sets up the custom task state Zone interceptor in the  `ProxyZone`. Throws if\n   * no `ProxyZone` could be found.\n   * @returns an observable that emits whenever the task state changes.\n   */\n  static setup(): Observable<TaskState> {\n    if (Zone === undefined) {\n      throw Error('Could not find ZoneJS. For test harnesses running in TestBed, ' +\n        'ZoneJS needs to be installed.');\n    }\n\n    // tslint:disable-next-line:variable-name\n    const ProxyZoneSpec = (Zone as any)['ProxyZoneSpec'] as ProxyZoneStatic|undefined;\n\n    // If there is no \"ProxyZoneSpec\" installed, we throw an error and recommend\n    // setting up the proxy zone by pulling in the testing bundle.\n    if (!ProxyZoneSpec) {\n      throw Error(\n        'ProxyZoneSpec is needed for the test harnesses but could not be found. ' +\n        'Please make sure that your environment includes zone.js/dist/zone-testing.js');\n    }\n\n    // Ensure that there is a proxy zone instance set up, and get\n    // a reference to the instance if present.\n    const zoneSpec = ProxyZoneSpec.assertPresent() as PatchedProxyZone;\n\n    // If there already is a delegate registered in the proxy zone, and it\n    // is type of the custom task state interceptor, we just use that state\n    // observable. This allows us to only intercept Zone once per test\n    // (similar to how `fakeAsync` or `async` work).\n    if (zoneSpec[stateObservableSymbol]) {\n      return zoneSpec[stateObservableSymbol]!;\n    }\n\n    // Since we intercept on environment creation and the fixture has been\n    // created before, we might have missed tasks scheduled before. Fortunately\n    // the proxy zone keeps track of the previous task state, so we can just pass\n    // this as initial state to the task zone interceptor.\n    const interceptor = new TaskStateZoneInterceptor(zoneSpec.lastTaskState);\n    const zoneSpecOnHasTask = zoneSpec.onHasTask.bind(zoneSpec);\n\n    // We setup the task state interceptor in the `ProxyZone`. Note that we cannot register\n    // the interceptor as a new proxy zone delegate because it would mean that other zone\n    // delegates (e.g. `FakeAsyncTestZone` or `AsyncTestZone`) can accidentally overwrite/disable\n    // our interceptor. Since we just intend to monitor the task state of the proxy zone, it is\n    // sufficient to just patch the proxy zone. This also avoids that we interfere with the task\n    // queue scheduling logic.\n    zoneSpec.onHasTask = function(...args: [ZoneDelegate, Zone, Zone, HasTaskState]) {\n      zoneSpecOnHasTask(...args);\n      interceptor.onHasTask(...args);\n    };\n\n    return zoneSpec[stateObservableSymbol] = interceptor.state;\n  }\n}\n"]}