@angular/cdk
Version:
Angular Material Component Development Kit
102 lines • 17 kB
JavaScript
/**
* @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';
/** 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) {
status.onDetectChangesNow?.();
}
/**
* 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?.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.
*/
async function batchChangeDetection(fn, triggerBeforeAndAfter) {
// If change detection batching is already in progress, just run the function.
if (autoChangeDetectionSubject.getValue().isDisabled) {
return await fn();
}
// If nothing is handling change detection batching, install the default handler.
if (!autoChangeDetectionSubscription) {
handleAutoChangeDetectionStatus(defaultAutoChangeDetectionHandler);
}
if (triggerBeforeAndAfter) {
await 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 await fn();
}
finally {
await 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 await 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 async function manualChangeDetection(fn) {
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 async function parallel(values) {
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,MAAM,CAAC,kBAAkB,EAAE,EAAE,CAAC;AAChC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,+BAA+B,CAC7C,OAAoD;IAEpD,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,EAAE,WAAW,EAAE,CAAC;IAC/C,+BAA+B,GAAG,IAAI,CAAC;AACzC,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,oBAAoB,CAAI,EAAoB,EAAE,qBAA8B;IACzF,8EAA8E;IAC9E,IAAI,0BAA0B,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE;QACpD,OAAO,MAAM,EAAE,EAAE,CAAC;KACnB;IAED,iFAAiF;IACjF,IAAI,CAAC,+BAA+B,EAAE;QACpC,+BAA+B,CAAC,iCAAiC,CAAC,CAAC;KACpE;IAED,IAAI,qBAAqB,EAAE;QACzB,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAC1B,0BAA0B,CAAC,IAAI,CAAC;YAC9B,UAAU,EAAE,IAAI;YAChB,kBAAkB,EAAE,OAAqB;SAC1C,CAAC,CACH,CAAC;QACF,8FAA8F;QAC9F,8FAA8F;QAC9F,mCAAmC;QACnC,IAAI;YACF,OAAO,MAAM,EAAE,EAAE,CAAC;SACnB;gBAAS;YACR,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAC1B,0BAA0B,CAAC,IAAI,CAAC;gBAC9B,UAAU,EAAE,KAAK;gBACjB,kBAAkB,EAAE,OAAqB;aAC1C,CAAC,CACH,CAAC;SACH;KACF;SAAM;QACL,0BAA0B,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,IAAI,EAAC,CAAC,CAAC;QACpD,8FAA8F;QAC9F,8FAA8F;QAC9F,mCAAmC;QACnC,IAAI;YACF,OAAO,MAAM,EAAE,EAAE,CAAC;SACnB;gBAAS;YACR,0BAA0B,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,KAAK,EAAC,CAAC,CAAC;SACtD;KACF;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAI,EAAoB;IACjE,OAAO,oBAAoB,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;AACzC,CAAC;AAkED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAI,MAA0C;IAC1E,OAAO,oBAAoB,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;AACjE,CAAC","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) {\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 =>\n      autoChangeDetectionSubject.next({\n        isDisabled: true,\n        onDetectChangesNow: resolve as () => void,\n      }),\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 =>\n        autoChangeDetectionSubject.next({\n          isDisabled: false,\n          onDetectChangesNow: resolve as () => void,\n        }),\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 * 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>,\n    T2 | PromiseLike<T2>,\n    T3 | PromiseLike<T3>,\n    T4 | PromiseLike<T4>,\n    T5 | PromiseLike<T5>,\n  ],\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>,\n    T2 | PromiseLike<T2>,\n    T3 | PromiseLike<T3>,\n    T4 | PromiseLike<T4>,\n  ],\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>(\n  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"]}