source: trip-planner-front/node_modules/@angular/cdk/esm2015/testing/change-detection.js@ bdd6491

/**
 * @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 { __awaiter } from "tslib";
import { BehaviorSubject } from 'rxjs';
/** Subject used to dispatch and listen for changes to the auto change detection status . */
const autoChangeDetectionSubject = new BehaviorSubject({
    isDisabled: false
});
/** The current subscription to `autoChangeDetectionSubject`. */
let autoChangeDetectionSubscription;
/**
 * The default handler for auto change detection status changes. This handler will be used if the
 * specific environment does not install its own.
 * @param status The new auto change detection status.
 */
function defaultAutoChangeDetectionHandler(status) {
    var _a;
    (_a = status.onDetectChangesNow) === null || _a === void 0 ? void 0 : _a.call(status);
}
/**
 * Allows a test `HarnessEnvironment` to install its own handler for auto change detection status
 * changes.
 * @param handler The handler for the auto change detection status.
 */
export function handleAutoChangeDetectionStatus(handler) {
    stopHandlingAutoChangeDetectionStatus();
    autoChangeDetectionSubscription = autoChangeDetectionSubject.subscribe(handler);
}
/** Allows a `HarnessEnvironment` to stop handling auto change detection status changes. */
export function stopHandlingAutoChangeDetectionStatus() {
    autoChangeDetectionSubscription === null || autoChangeDetectionSubscription === void 0 ? void 0 : autoChangeDetectionSubscription.unsubscribe();
    autoChangeDetectionSubscription = null;
}
/**
 * Batches together triggering of change detection over the duration of the given function.
 * @param fn The function to call with batched change detection.
 * @param triggerBeforeAndAfter Optionally trigger change detection once before and after the batch
 *   operation. If false, change detection will not be triggered.
 * @return The result of the given function.
 */
function batchChangeDetection(fn, triggerBeforeAndAfter) {
    return __awaiter(this, void 0, void 0, function* () {
        // If change detection batching is already in progress, just run the function.
        if (autoChangeDetectionSubject.getValue().isDisabled) {
            return yield fn();
        }
        // If nothing is handling change detection batching, install the default handler.
        if (!autoChangeDetectionSubscription) {
            handleAutoChangeDetectionStatus(defaultAutoChangeDetectionHandler);
        }
        if (triggerBeforeAndAfter) {
            yield new Promise(resolve => autoChangeDetectionSubject.next({
                isDisabled: true,
                onDetectChangesNow: resolve,
            }));
            // The function passed in may throw (e.g. if the user wants to make an expectation of an error
            // being thrown. If this happens, we need to make sure we still re-enable change detection, so
            // we wrap it in a `finally` block.
            try {
                return yield fn();
            }
            finally {
                yield new Promise(resolve => autoChangeDetectionSubject.next({
                    isDisabled: false,
                    onDetectChangesNow: resolve,
                }));
            }
        }
        else {
            autoChangeDetectionSubject.next({ isDisabled: true });
            // The function passed in may throw (e.g. if the user wants to make an expectation of an error
            // being thrown. If this happens, we need to make sure we still re-enable change detection, so
            // we wrap it in a `finally` block.
            try {
                return yield fn();
            }
            finally {
                autoChangeDetectionSubject.next({ isDisabled: false });
            }
        }
    });
}
/**
 * Disables the harness system's auto change detection for the duration of the given function.
 * @param fn The function to disable auto change detection for.
 * @return The result of the given function.
 */
export function manualChangeDetection(fn) {
    return __awaiter(this, void 0, void 0, function* () {
        return batchChangeDetection(fn, false);
    });
}
/**
 * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change
 * detection over the entire operation such that change detection occurs exactly once before
 * resolving the values and once after.
 * @param values A getter for the async values to resolve in parallel with batched change detection.
 * @return The resolved values.
 */
export function parallel(values) {
    return __awaiter(this, void 0, void 0, function* () {
        return batchChangeDetection(() => Promise.all(values()), true);
    });
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"change-detection.js","sourceRoot":"","sources":["../../../../../../src/cdk/testing/change-detection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;AAEH,OAAO,EAAC,eAAe,EAAe,MAAM,MAAM,CAAC;AAcnD,4FAA4F;AAC5F,MAAM,0BAA0B,GAAG,IAAI,eAAe,CAA4B;IAChF,UAAU,EAAE,KAAK;CAClB,CAAC,CAAC;AAEH,gEAAgE;AAChE,IAAI,+BAAoD,CAAC;AAEzD;;;;GAIG;AACH,SAAS,iCAAiC,CAAC,MAAiC;;IAC1E,MAAA,MAAM,CAAC,kBAAkB,+CAAzB,MAAM,CAAuB,CAAC;AAChC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,+BAA+B,CAC3C,OAAoD;IACtD,qCAAqC,EAAE,CAAC;IACxC,+BAA+B,GAAG,0BAA0B,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAClF,CAAC;AAED,2FAA2F;AAC3F,MAAM,UAAU,qCAAqC;IACnD,+BAA+B,aAA/B,+BAA+B,uBAA/B,+BAA+B,CAAE,WAAW,EAAE,CAAC;IAC/C,+BAA+B,GAAG,IAAI,CAAC;AACzC,CAAC;AAED;;;;;;GAMG;AACH,SAAe,oBAAoB,CAAI,EAAoB,EAAE,qBAA8B;;QACzF,8EAA8E;QAC9E,IAAI,0BAA0B,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE;YACpD,OAAO,MAAM,EAAE,EAAE,CAAC;SACnB;QAED,iFAAiF;QACjF,IAAI,CAAC,+BAA+B,EAAE;YACpC,+BAA+B,CAAC,iCAAiC,CAAC,CAAC;SACpE;QAED,IAAI,qBAAqB,EAAE;YACzB,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,0BAA0B,CAAC,IAAI,CAAC;gBAC3D,UAAU,EAAE,IAAI;gBAChB,kBAAkB,EAAE,OAAqB;aAC1C,CAAC,CAAC,CAAC;YACJ,8FAA8F;YAC9F,8FAA8F;YAC9F,mCAAmC;YACnC,IAAI;gBACF,OAAO,MAAM,EAAE,EAAE,CAAC;aACnB;oBAAS;gBACR,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,0BAA0B,CAAC,IAAI,CAAC;oBAC3D,UAAU,EAAE,KAAK;oBACjB,kBAAkB,EAAE,OAAqB;iBAC1C,CAAC,CAAC,CAAC;aACL;SACF;aAAM;YACL,0BAA0B,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,IAAI,EAAC,CAAC,CAAC;YACpD,8FAA8F;YAC9F,8FAA8F;YAC9F,mCAAmC;YACnC,IAAI;gBACF,OAAO,MAAM,EAAE,EAAE,CAAC;aACnB;oBAAS;gBACR,0BAA0B,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,KAAK,EAAC,CAAC,CAAC;aACtD;SACF;IACH,CAAC;CAAA;AAED;;;;GAIG;AACH,MAAM,UAAgB,qBAAqB,CAAI,EAAoB;;QACjE,OAAO,oBAAoB,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;CAAA;AA2DD;;;;;;GAMG;AACH,MAAM,UAAgB,QAAQ,CAAI,MAA0C;;QAC1E,OAAO,oBAAoB,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;IACjE,CAAC;CAAA","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, Subscription} from 'rxjs';\n\n/** Represents the status of auto change detection. */\nexport interface AutoChangeDetectionStatus {\n  /** Whether auto change detection is disabled. */\n  isDisabled: boolean;\n  /**\n   * An optional callback, if present it indicates that change detection should be run immediately,\n   * while handling the status change. The callback should then be called as soon as change\n   * detection is done.\n   */\n  onDetectChangesNow?: () => void;\n}\n\n/** Subject used to dispatch and listen for changes to the auto change detection status . */\nconst autoChangeDetectionSubject = new BehaviorSubject<AutoChangeDetectionStatus>({\n  isDisabled: false\n});\n\n/** The current subscription to `autoChangeDetectionSubject`. */\nlet autoChangeDetectionSubscription: Subscription | null;\n\n/**\n * The default handler for auto change detection status changes. This handler will be used if the\n * specific environment does not install its own.\n * @param status The new auto change detection status.\n */\nfunction defaultAutoChangeDetectionHandler(status: AutoChangeDetectionStatus) {\n  status.onDetectChangesNow?.();\n}\n\n/**\n * Allows a test `HarnessEnvironment` to install its own handler for auto change detection status\n * changes.\n * @param handler The handler for the auto change detection status.\n */\nexport function handleAutoChangeDetectionStatus(\n    handler: (status: AutoChangeDetectionStatus) => void) {\n  stopHandlingAutoChangeDetectionStatus();\n  autoChangeDetectionSubscription = autoChangeDetectionSubject.subscribe(handler);\n}\n\n/** Allows a `HarnessEnvironment` to stop handling auto change detection status changes. */\nexport function stopHandlingAutoChangeDetectionStatus() {\n  autoChangeDetectionSubscription?.unsubscribe();\n  autoChangeDetectionSubscription = null;\n}\n\n/**\n * Batches together triggering of change detection over the duration of the given function.\n * @param fn The function to call with batched change detection.\n * @param triggerBeforeAndAfter Optionally trigger change detection once before and after the batch\n *   operation. If false, change detection will not be triggered.\n * @return The result of the given function.\n */\nasync function batchChangeDetection<T>(fn: () => Promise<T>, triggerBeforeAndAfter: boolean) {\n  // If change detection batching is already in progress, just run the function.\n  if (autoChangeDetectionSubject.getValue().isDisabled) {\n    return await fn();\n  }\n\n  // If nothing is handling change detection batching, install the default handler.\n  if (!autoChangeDetectionSubscription) {\n    handleAutoChangeDetectionStatus(defaultAutoChangeDetectionHandler);\n  }\n\n  if (triggerBeforeAndAfter) {\n    await new Promise(resolve => autoChangeDetectionSubject.next({\n      isDisabled: true,\n      onDetectChangesNow: resolve as () => void,\n    }));\n    // The function passed in may throw (e.g. if the user wants to make an expectation of an error\n    // being thrown. If this happens, we need to make sure we still re-enable change detection, so\n    // we wrap it in a `finally` block.\n    try {\n      return await fn();\n    } finally {\n      await new Promise(resolve => autoChangeDetectionSubject.next({\n        isDisabled: false,\n        onDetectChangesNow: resolve as () => void,\n      }));\n    }\n  } else {\n    autoChangeDetectionSubject.next({isDisabled: true});\n    // The function passed in may throw (e.g. if the user wants to make an expectation of an error\n    // being thrown. If this happens, we need to make sure we still re-enable change detection, so\n    // we wrap it in a `finally` block.\n    try {\n      return await fn();\n    } finally {\n      autoChangeDetectionSubject.next({isDisabled: false});\n    }\n  }\n}\n\n/**\n * Disables the harness system's auto change detection for the duration of the given function.\n * @param fn The function to disable auto change detection for.\n * @return The result of the given function.\n */\nexport async function manualChangeDetection<T>(fn: () => Promise<T>) {\n  return batchChangeDetection(fn, false);\n}\n\n\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T1, T2, T3, T4, T5>(\n  values: () =>\n      [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>,\n       T5 | PromiseLike<T5>\n      ]): Promise<[T1, T2, T3, T4, T5]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T1, T2, T3, T4>(\n  values: () =>\n      [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>, T4 | PromiseLike<T4>]):\n  Promise<[T1, T2, T3, T4]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T1, T2, T3>(\n  values: () => [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>, T3 | PromiseLike<T3>]):\n  Promise<[T1, T2, T3]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T1, T2>(values: () => [T1 | PromiseLike<T1>, T2 | PromiseLike<T2>]):\n  Promise<[T1, T2]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport function parallel<T>(values: () => (T | PromiseLike<T>)[]): Promise<T[]>;\n\n/**\n * Resolves the given list of async values in parallel (i.e. via Promise.all) while batching change\n * detection over the entire operation such that change detection occurs exactly once before\n * resolving the values and once after.\n * @param values A getter for the async values to resolve in parallel with batched change detection.\n * @return The resolved values.\n */\nexport async function parallel<T>(values: () => Iterable<T | PromiseLike<T>>): Promise<T[]> {\n  return batchChangeDetection(() => Promise.all(values()), true);\n}\n"]}