@angular/core 17.0.0-next.8 → 17.0.0-rc.1

package/esm2022/src/defer/interfaces.mjs

@@ -0,0 +1,81 @@
+/**
+ * @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
+ */
+/**
+ * Describes the state of defer block dependency loading.
+ */
+export var DeferDependenciesLoadingState;
+(function (DeferDependenciesLoadingState) {
+    /** Initial state, dependency loading is not yet triggered */
+    DeferDependenciesLoadingState[DeferDependenciesLoadingState["NOT_STARTED"] = 0] = "NOT_STARTED";
+    /** Dependency loading is in progress */
+    DeferDependenciesLoadingState[DeferDependenciesLoadingState["IN_PROGRESS"] = 1] = "IN_PROGRESS";
+    /** Dependency loading has completed successfully */
+    DeferDependenciesLoadingState[DeferDependenciesLoadingState["COMPLETE"] = 2] = "COMPLETE";
+    /** Dependency loading has failed */
+    DeferDependenciesLoadingState[DeferDependenciesLoadingState["FAILED"] = 3] = "FAILED";
+})(DeferDependenciesLoadingState || (DeferDependenciesLoadingState = {}));
+/** Slot index where `minimum` parameter value is stored. */
+export const MINIMUM_SLOT = 0;
+/** Slot index where `after` parameter value is stored. */
+export const LOADING_AFTER_SLOT = 1;
+/**
+ * Describes the current state of this defer block instance.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export var DeferBlockState;
+(function (DeferBlockState) {
+    /** The placeholder block content is rendered */
+    DeferBlockState[DeferBlockState["Placeholder"] = 0] = "Placeholder";
+    /** The loading block content is rendered */
+    DeferBlockState[DeferBlockState["Loading"] = 1] = "Loading";
+    /** The main content block content is rendered */
+    DeferBlockState[DeferBlockState["Complete"] = 2] = "Complete";
+    /** The error block content is rendered */
+    DeferBlockState[DeferBlockState["Error"] = 3] = "Error";
+})(DeferBlockState || (DeferBlockState = {}));
+/**
+ * Describes the initial state of this defer block instance.
+ *
+ * Note: this state is internal only and *must* be represented
+ * with a number lower than any value in the `DeferBlockState` enum.
+ */
+export var DeferBlockInternalState;
+(function (DeferBlockInternalState) {
+    /** Initial state. Nothing is rendered yet. */
+    DeferBlockInternalState[DeferBlockInternalState["Initial"] = -1] = "Initial";
+})(DeferBlockInternalState || (DeferBlockInternalState = {}));
+export const NEXT_DEFER_BLOCK_STATE = 0;
+// Note: it's *important* to keep the state in this slot, because this slot
+// is used by runtime logic to differentiate between LViews, LContainers and
+// other types (see `isLView` and `isLContainer` functions). In case of defer
+// blocks, this slot would always be a number.
+export const DEFER_BLOCK_STATE = 1;
+export const STATE_IS_FROZEN_UNTIL = 2;
+export const LOADING_AFTER_CLEANUP_FN = 3;
+export const TRIGGER_CLEANUP_FNS = 4;
+export const PREFETCH_TRIGGER_CLEANUP_FNS = 5;
+/**
+ * Options for configuring defer blocks behavior.
+ * @publicApi
+ * @developerPreview
+ */
+export var DeferBlockBehavior;
+(function (DeferBlockBehavior) {
+    /**
+     * Manual triggering mode for defer blocks. Provides control over when defer blocks render
+     * and which state they render. This is the default behavior in test environments.
+     */
+    DeferBlockBehavior[DeferBlockBehavior["Manual"] = 0] = "Manual";
+    /**
+     * Playthrough mode for defer blocks. This mode behaves like defer blocks would in a browser.
+     */
+    DeferBlockBehavior[DeferBlockBehavior["Playthrough"] = 1] = "Playthrough";
+})(DeferBlockBehavior || (DeferBlockBehavior = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/defer/interfaces.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAyBH;;GAEG;AACH,MAAM,CAAN,IAAY,6BAYX;AAZD,WAAY,6BAA6B;IACvC,6DAA6D;IAC7D,+FAAW,CAAA;IAEX,wCAAwC;IACxC,+FAAW,CAAA;IAEX,oDAAoD;IACpD,yFAAQ,CAAA;IAER,oCAAoC;IACpC,qFAAM,CAAA;AACR,CAAC,EAZW,6BAA6B,KAA7B,6BAA6B,QAYxC;AAED,4DAA4D;AAC5D,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC;AAE9B,0DAA0D;AAC1D,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AA6DpC;;;;;GAKG;AACH,MAAM,CAAN,IAAY,eAYX;AAZD,WAAY,eAAe;IACzB,gDAAgD;IAChD,mEAAe,CAAA;IAEf,4CAA4C;IAC5C,2DAAW,CAAA;IAEX,iDAAiD;IACjD,6DAAY,CAAA;IAEZ,0CAA0C;IAC1C,uDAAS,CAAA;AACX,CAAC,EAZW,eAAe,KAAf,eAAe,QAY1B;AAED;;;;;GAKG;AACH,MAAM,CAAN,IAAY,uBAGX;AAHD,WAAY,uBAAuB;IACjC,8CAA8C;IAC9C,4EAAY,CAAA;AACd,CAAC,EAHW,uBAAuB,KAAvB,uBAAuB,QAGlC;AAED,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC;AACxC,2EAA2E;AAC3E,4EAA4E;AAC5E,6EAA6E;AAC7E,8CAA8C;AAC9C,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AACnC,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AACvC,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAC1C,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC;AACrC,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC;AAmD9C;;;;GAIG;AACH,MAAM,CAAN,IAAY,kBAWX;AAXD,WAAY,kBAAkB;IAC5B;;;OAGG;IACH,+DAAM,CAAA;IAEN;;OAEG;IACH,yEAAW,CAAA;AACb,CAAC,EAXW,kBAAkB,KAAlB,kBAAkB,QAW7B","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 type {DependencyType} from '../render3/interfaces/definition';\n\n/**\n * Describes the shape of a function generated by the compiler\n * to download dependencies that can be defer-loaded.\n */\nexport type DependencyResolverFn = () => Array<Promise<DependencyType>>;\n\n/**\n * Defines types of defer block triggers.\n */\nexport const enum TriggerType {\n  /**\n   * Represents regular triggers (e.g. `@defer (on idle) { ... }`).\n   */\n  Regular,\n\n  /**\n   * Represents prefetch triggers (e.g. `@defer (prefetch on idle) { ... }`).\n   */\n  Prefetch,\n}\n\n/**\n * Describes the state of defer block dependency loading.\n */\nexport enum DeferDependenciesLoadingState {\n  /** Initial state, dependency loading is not yet triggered */\n  NOT_STARTED,\n\n  /** Dependency loading is in progress */\n  IN_PROGRESS,\n\n  /** Dependency loading has completed successfully */\n  COMPLETE,\n\n  /** Dependency loading has failed */\n  FAILED,\n}\n\n/** Slot index where `minimum` parameter value is stored. */\nexport const MINIMUM_SLOT = 0;\n\n/** Slot index where `after` parameter value is stored. */\nexport const LOADING_AFTER_SLOT = 1;\n\n/** Configuration object for a loading block as it is stored in the component constants. */\nexport type DeferredLoadingBlockConfig = [minimumTime: number|null, afterTime: number|null];\n\n/** Configuration object for a placeholder block as it is stored in the component constants. */\nexport type DeferredPlaceholderBlockConfig = [minimumTime: number|null];\n\n/**\n * Describes the data shared across all instances of a defer block.\n */\nexport interface TDeferBlockDetails {\n  /**\n   * Index in an LView and TData arrays where a template for the primary content\n   * can be found.\n   */\n  primaryTmplIndex: number;\n\n  /**\n   * Index in an LView and TData arrays where a template for the loading block can be found.\n   */\n  loadingTmplIndex: number|null;\n\n  /**\n   * Extra configuration parameters (such as `after` and `minimum`) for the loading block.\n   */\n  loadingBlockConfig: DeferredLoadingBlockConfig|null;\n\n  /**\n   * Index in an LView and TData arrays where a template for the placeholder block can be found.\n   */\n  placeholderTmplIndex: number|null;\n\n  /**\n   * Extra configuration parameters (such as `after` and `minimum`) for the placeholder block.\n   */\n  placeholderBlockConfig: DeferredPlaceholderBlockConfig|null;\n\n  /**\n   * Index in an LView and TData arrays where a template for the error block can be found.\n   */\n  errorTmplIndex: number|null;\n\n  /**\n   * Compiler-generated function that loads all dependencies for a defer block.\n   */\n  dependencyResolverFn: DependencyResolverFn|null;\n\n  /**\n   * Keeps track of the current loading state of defer block dependencies.\n   */\n  loadingState: DeferDependenciesLoadingState;\n\n  /**\n   * Dependency loading Promise. This Promise is helpful for cases when there\n   * are multiple instances of a defer block (e.g. if it was used inside of an *ngFor),\n   * which all await the same set of dependencies.\n   */\n  loadingPromise: Promise<unknown>|null;\n}\n\n/**\n * Describes the current state of this defer block instance.\n *\n * @publicApi\n * @developerPreview\n */\nexport enum DeferBlockState {\n  /** The placeholder block content is rendered */\n  Placeholder = 0,\n\n  /** The loading block content is rendered */\n  Loading = 1,\n\n  /** The main content block content is rendered */\n  Complete = 2,\n\n  /** The error block content is rendered */\n  Error = 3,\n}\n\n/**\n * Describes the initial state of this defer block instance.\n *\n * Note: this state is internal only and *must* be represented\n * with a number lower than any value in the `DeferBlockState` enum.\n */\nexport enum DeferBlockInternalState {\n  /** Initial state. Nothing is rendered yet. */\n  Initial = -1,\n}\n\nexport const NEXT_DEFER_BLOCK_STATE = 0;\n// Note: it's *important* to keep the state in this slot, because this slot\n// is used by runtime logic to differentiate between LViews, LContainers and\n// other types (see `isLView` and `isLContainer` functions). In case of defer\n// blocks, this slot would always be a number.\nexport const DEFER_BLOCK_STATE = 1;\nexport const STATE_IS_FROZEN_UNTIL = 2;\nexport const LOADING_AFTER_CLEANUP_FN = 3;\nexport const TRIGGER_CLEANUP_FNS = 4;\nexport const PREFETCH_TRIGGER_CLEANUP_FNS = 5;\n\n/**\n * Describes instance-specific defer block data.\n *\n * Note: currently there is only the `state` slot, but more slots\n * would be added later to keep track of `after` and `maximum` features\n * (which would require per-instance state).\n */\nexport interface LDeferBlockDetails extends Array<unknown> {\n  /**\n   * Currently rendered block state.\n   */\n  [DEFER_BLOCK_STATE]: DeferBlockState|DeferBlockInternalState;\n\n  /**\n   * Block state that was requested when another state was rendered.\n   */\n  [NEXT_DEFER_BLOCK_STATE]: DeferBlockState|null;\n\n  /**\n   * Timestamp indicating when the current state can be switched to\n   * the next one, in case teh current state has `minimum` parameter.\n   */\n  [STATE_IS_FROZEN_UNTIL]: number|null;\n\n  /**\n   * Contains a reference to a cleanup function which cancels a timeout\n   * when Angular waits before rendering loading state. This is used when\n   * the loading block has the `after` parameter configured.\n   */\n  [LOADING_AFTER_CLEANUP_FN]: VoidFunction|null;\n\n  /**\n   * List of cleanup functions for regular triggers.\n   */\n  [TRIGGER_CLEANUP_FNS]: VoidFunction[]|null;\n\n  /**\n   * List of cleanup functions for prefetch triggers.\n   */\n  [PREFETCH_TRIGGER_CLEANUP_FNS]: VoidFunction[]|null;\n}\n\n/**\n * Internal structure used for configuration of defer block behavior.\n * */\nexport interface DeferBlockConfig {\n  behavior: DeferBlockBehavior;\n}\n\n/**\n * Options for configuring defer blocks behavior.\n * @publicApi\n * @developerPreview\n */\nexport enum DeferBlockBehavior {\n  /**\n   * Manual triggering mode for defer blocks. Provides control over when defer blocks render\n   * and which state they render. This is the default behavior in test environments.\n   */\n  Manual,\n\n  /**\n   * Playthrough mode for defer blocks. This mode behaves like defer blocks would in a browser.\n   */\n  Playthrough,\n}\n\n/**\n * **INTERNAL**, avoid referencing it in application code.\n *\n * Describes a helper class that allows to intercept a call to retrieve current\n * dependency loading function and replace it with a different implementation.\n * This interceptor class is needed to allow testing blocks in different states\n * by simulating loading response.\n */\nexport interface DeferBlockDependencyInterceptor {\n  /**\n   * Invoked for each defer block when dependency loading function is accessed.\n   */\n  intercept(dependencyFn: DependencyResolverFn|null): DependencyResolverFn|null;\n\n  /**\n   * Allows to configure an interceptor function.\n   */\n  setInterceptor(interceptorFn: (current: DependencyResolverFn) => DependencyResolverFn): void;\n}\n"]}

package/esm2022/src/defer/timer_scheduler.mjs

@@ -0,0 +1,201 @@
+/**
+ * @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 { ɵɵdefineInjectable } from '../di';
+import { INJECTOR } from '../render3/interfaces/view';
+import { arrayInsert2, arraySplice } from '../util/array_utils';
+/**
+ * Returns a function that captures a provided delay.
+ * Invoking the returned function schedules a trigger.
+ */
+export function onTimer(delay) {
+    return (callback, lView) => scheduleTimerTrigger(delay, callback, lView);
+}
+/**
+ * Schedules a callback to be invoked after a given timeout.
+ *
+ * @param delay A number of ms to wait until firing a callback.
+ * @param callback A function to be invoked after a timeout.
+ * @param lView LView that hosts an instance of a defer block.
+ */
+export function scheduleTimerTrigger(delay, callback, lView) {
+    const injector = lView[INJECTOR];
+    const scheduler = injector.get(TimerScheduler);
+    const cleanupFn = () => scheduler.remove(callback);
+    scheduler.add(delay, callback);
+    return cleanupFn;
+}
+/**
+ * Helper service to schedule `setTimeout`s for batches of defer blocks,
+ * to avoid calling `setTimeout` for each defer block (e.g. if defer blocks
+ * are created inside a for loop).
+ */
+export class TimerScheduler {
+    constructor() {
+        // Indicates whether current callbacks are being invoked.
+        this.executingCallbacks = false;
+        // Currently scheduled `setTimeout` id.
+        this.timeoutId = null;
+        // When currently scheduled timer would fire.
+        this.invokeTimerAt = null;
+        // List of callbacks to be invoked.
+        // For each callback we also store a timestamp on when the callback
+        // should be invoked. We store timestamps and callback functions
+        // in a flat array to avoid creating new objects for each entry.
+        // [timestamp1, callback1, timestamp2, callback2, ...]
+        this.current = [];
+        // List of callbacks collected while invoking current set of callbacks.
+        // Those callbacks are added to the "current" queue at the end of
+        // the current callback invocation. The shape of this list is the same
+        // as the shape of the `current` list.
+        this.deferred = [];
+    }
+    add(delay, callback) {
+        const target = this.executingCallbacks ? this.deferred : this.current;
+        this.addToQueue(target, Date.now() + delay, callback);
+        this.scheduleTimer();
+    }
+    remove(callback) {
+        const { current, deferred } = this;
+        const callbackIndex = this.removeFromQueue(current, callback);
+        if (callbackIndex === -1) {
+            // Try cleaning up deferred queue only in case
+            // we didn't find a callback in the "current" queue.
+            this.removeFromQueue(deferred, callback);
+        }
+        // If the last callback was removed and there is a pending timeout - cancel it.
+        if (current.length === 0 && deferred.length === 0) {
+            this.clearTimeout();
+        }
+    }
+    addToQueue(target, invokeAt, callback) {
+        let insertAtIndex = target.length;
+        for (let i = 0; i < target.length; i += 2) {
+            const invokeQueuedCallbackAt = target[i];
+            if (invokeQueuedCallbackAt > invokeAt) {
+                // We've reached a first timer that is scheduled
+                // for a later time than what we are trying to insert.
+                // This is the location at which we need to insert,
+                // no need to iterate further.
+                insertAtIndex = i;
+                break;
+            }
+        }
+        arrayInsert2(target, insertAtIndex, invokeAt, callback);
+    }
+    removeFromQueue(target, callback) {
+        let index = -1;
+        for (let i = 0; i < target.length; i += 2) {
+            const queuedCallback = target[i + 1];
+            if (queuedCallback === callback) {
+                index = i;
+                break;
+            }
+        }
+        if (index > -1) {
+            // Remove 2 elements: a timestamp slot and
+            // the following slot with a callback function.
+            arraySplice(target, index, 2);
+        }
+        return index;
+    }
+    scheduleTimer() {
+        const callback = () => {
+            this.clearTimeout();
+            this.executingCallbacks = true;
+            // Clone the current state of the queue, since it might be altered
+            // as we invoke callbacks.
+            const current = [...this.current];
+            // Invoke callbacks that were scheduled to run before the current time.
+            const now = Date.now();
+            for (let i = 0; i < current.length; i += 2) {
+                const invokeAt = current[i];
+                const callback = current[i + 1];
+                if (invokeAt <= now) {
+                    callback();
+                }
+                else {
+                    // We've reached a timer that should not be invoked yet.
+                    break;
+                }
+            }
+            // The state of the queue might've changed after callbacks invocation,
+            // run the cleanup logic based on the *current* state of the queue.
+            let lastCallbackIndex = -1;
+            for (let i = 0; i < this.current.length; i += 2) {
+                const invokeAt = this.current[i];
+                if (invokeAt <= now) {
+                    // Add +1 to account for a callback function that
+                    // goes after the timestamp in events array.
+                    lastCallbackIndex = i + 1;
+                }
+                else {
+                    // We've reached a timer that should not be invoked yet.
+                    break;
+                }
+            }
+            if (lastCallbackIndex >= 0) {
+                arraySplice(this.current, 0, lastCallbackIndex + 1);
+            }
+            this.executingCallbacks = false;
+            // If there are any callbacks added during an invocation
+            // of the current ones - move them over to the "current"
+            // queue.
+            if (this.deferred.length > 0) {
+                for (let i = 0; i < this.deferred.length; i += 2) {
+                    const invokeAt = this.deferred[i];
+                    const callback = this.deferred[i + 1];
+                    this.addToQueue(this.current, invokeAt, callback);
+                }
+                this.deferred.length = 0;
+            }
+            this.scheduleTimer();
+        };
+        // Avoid running timer callbacks more than once per
+        // average frame duration. This is needed for better
+        // batching and to avoid kicking off excessive change
+        // detection cycles.
+        const FRAME_DURATION_MS = 16; // 1000ms / 60fps
+        if (this.current.length > 0) {
+            const now = Date.now();
+            // First element in the queue points at the timestamp
+            // of the first (earliest) event.
+            const invokeAt = this.current[0];
+            if (this.timeoutId === null ||
+                // Reschedule a timer in case a queue contains an item with
+                // an earlier timestamp and the delta is more than an average
+                // frame duration.
+                (this.invokeTimerAt && (this.invokeTimerAt - invokeAt > FRAME_DURATION_MS))) {
+                // There was a timeout already, but an earlier event was added
+                // into the queue. In this case we drop an old timer and setup
+                // a new one with an updated (smaller) timeout.
+                this.clearTimeout();
+                const timeout = Math.max(invokeAt - now, FRAME_DURATION_MS);
+                this.invokeTimerAt = invokeAt;
+                this.timeoutId = setTimeout(callback, timeout);
+            }
+        }
+    }
+    clearTimeout() {
+        if (this.timeoutId !== null) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+    ngOnDestroy() {
+        this.clearTimeout();
+        this.current.length = 0;
+        this.deferred.length = 0;
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: TimerScheduler,
+        providedIn: 'root',
+        factory: () => new TimerScheduler(),
+    }); }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timer_scheduler.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/defer/timer_scheduler.ts"],"names":[],"mappings":"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","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 {ɵɵdefineInjectable} from '../di';\nimport {INJECTOR, LView} from '../render3/interfaces/view';\nimport {arrayInsert2, arraySplice} from '../util/array_utils';\n\n/**\n * Returns a function that captures a provided delay.\n * Invoking the returned function schedules a trigger.\n */\nexport function onTimer(delay: number) {\n  return (callback: VoidFunction, lView: LView) => scheduleTimerTrigger(delay, callback, lView);\n}\n\n/**\n * Schedules a callback to be invoked after a given timeout.\n *\n * @param delay A number of ms to wait until firing a callback.\n * @param callback A function to be invoked after a timeout.\n * @param lView LView that hosts an instance of a defer block.\n */\nexport function scheduleTimerTrigger(delay: number, callback: VoidFunction, lView: LView) {\n  const injector = lView[INJECTOR]!;\n  const scheduler = injector.get(TimerScheduler);\n  const cleanupFn = () => scheduler.remove(callback);\n  scheduler.add(delay, callback);\n  return cleanupFn;\n}\n\n/**\n * Helper service to schedule `setTimeout`s for batches of defer blocks,\n * to avoid calling `setTimeout` for each defer block (e.g. if defer blocks\n * are created inside a for loop).\n */\nexport class TimerScheduler {\n  // Indicates whether current callbacks are being invoked.\n  executingCallbacks = false;\n\n  // Currently scheduled `setTimeout` id.\n  timeoutId: number|null = null;\n\n  // When currently scheduled timer would fire.\n  invokeTimerAt: number|null = null;\n\n  // List of callbacks to be invoked.\n  // For each callback we also store a timestamp on when the callback\n  // should be invoked. We store timestamps and callback functions\n  // in a flat array to avoid creating new objects for each entry.\n  // [timestamp1, callback1, timestamp2, callback2, ...]\n  current: Array<number|VoidFunction> = [];\n\n  // List of callbacks collected while invoking current set of callbacks.\n  // Those callbacks are added to the \"current\" queue at the end of\n  // the current callback invocation. The shape of this list is the same\n  // as the shape of the `current` list.\n  deferred: Array<number|VoidFunction> = [];\n\n  add(delay: number, callback: VoidFunction) {\n    const target = this.executingCallbacks ? this.deferred : this.current;\n    this.addToQueue(target, Date.now() + delay, callback);\n    this.scheduleTimer();\n  }\n\n  remove(callback: VoidFunction) {\n    const {current, deferred} = this;\n    const callbackIndex = this.removeFromQueue(current, callback);\n    if (callbackIndex === -1) {\n      // Try cleaning up deferred queue only in case\n      // we didn't find a callback in the \"current\" queue.\n      this.removeFromQueue(deferred, callback);\n    }\n    // If the last callback was removed and there is a pending timeout - cancel it.\n    if (current.length === 0 && deferred.length === 0) {\n      this.clearTimeout();\n    }\n  }\n\n  private addToQueue(target: Array<number|VoidFunction>, invokeAt: number, callback: VoidFunction) {\n    let insertAtIndex = target.length;\n    for (let i = 0; i < target.length; i += 2) {\n      const invokeQueuedCallbackAt = target[i] as number;\n      if (invokeQueuedCallbackAt > invokeAt) {\n        // We've reached a first timer that is scheduled\n        // for a later time than what we are trying to insert.\n        // This is the location at which we need to insert,\n        // no need to iterate further.\n        insertAtIndex = i;\n        break;\n      }\n    }\n    arrayInsert2(target, insertAtIndex, invokeAt, callback);\n  }\n\n  private removeFromQueue(target: Array<number|VoidFunction>, callback: VoidFunction) {\n    let index = -1;\n    for (let i = 0; i < target.length; i += 2) {\n      const queuedCallback = target[i + 1];\n      if (queuedCallback === callback) {\n        index = i;\n        break;\n      }\n    }\n    if (index > -1) {\n      // Remove 2 elements: a timestamp slot and\n      // the following slot with a callback function.\n      arraySplice(target, index, 2);\n    }\n    return index;\n  }\n\n  private scheduleTimer() {\n    const callback = () => {\n      this.clearTimeout();\n\n      this.executingCallbacks = true;\n\n      // Clone the current state of the queue, since it might be altered\n      // as we invoke callbacks.\n      const current = [...this.current];\n\n      // Invoke callbacks that were scheduled to run before the current time.\n      const now = Date.now();\n      for (let i = 0; i < current.length; i += 2) {\n        const invokeAt = current[i] as number;\n        const callback = current[i + 1] as VoidFunction;\n        if (invokeAt <= now) {\n          callback();\n        } else {\n          // We've reached a timer that should not be invoked yet.\n          break;\n        }\n      }\n      // The state of the queue might've changed after callbacks invocation,\n      // run the cleanup logic based on the *current* state of the queue.\n      let lastCallbackIndex = -1;\n      for (let i = 0; i < this.current.length; i += 2) {\n        const invokeAt = this.current[i] as number;\n        if (invokeAt <= now) {\n          // Add +1 to account for a callback function that\n          // goes after the timestamp in events array.\n          lastCallbackIndex = i + 1;\n        } else {\n          // We've reached a timer that should not be invoked yet.\n          break;\n        }\n      }\n      if (lastCallbackIndex >= 0) {\n        arraySplice(this.current, 0, lastCallbackIndex + 1);\n      }\n\n      this.executingCallbacks = false;\n\n      // If there are any callbacks added during an invocation\n      // of the current ones - move them over to the \"current\"\n      // queue.\n      if (this.deferred.length > 0) {\n        for (let i = 0; i < this.deferred.length; i += 2) {\n          const invokeAt = this.deferred[i] as number;\n          const callback = this.deferred[i + 1] as VoidFunction;\n          this.addToQueue(this.current, invokeAt, callback);\n        }\n        this.deferred.length = 0;\n      }\n      this.scheduleTimer();\n    };\n\n    // Avoid running timer callbacks more than once per\n    // average frame duration. This is needed for better\n    // batching and to avoid kicking off excessive change\n    // detection cycles.\n    const FRAME_DURATION_MS = 16;  // 1000ms / 60fps\n\n    if (this.current.length > 0) {\n      const now = Date.now();\n      // First element in the queue points at the timestamp\n      // of the first (earliest) event.\n      const invokeAt = this.current[0] as number;\n      if (this.timeoutId === null ||\n          // Reschedule a timer in case a queue contains an item with\n          // an earlier timestamp and the delta is more than an average\n          // frame duration.\n          (this.invokeTimerAt && (this.invokeTimerAt - invokeAt > FRAME_DURATION_MS))) {\n        // There was a timeout already, but an earlier event was added\n        // into the queue. In this case we drop an old timer and setup\n        // a new one with an updated (smaller) timeout.\n        this.clearTimeout();\n\n        const timeout = Math.max(invokeAt - now, FRAME_DURATION_MS);\n        this.invokeTimerAt = invokeAt;\n        this.timeoutId = setTimeout(callback, timeout) as unknown as number;\n      }\n    }\n  }\n\n  private clearTimeout() {\n    if (this.timeoutId !== null) {\n      clearTimeout(this.timeoutId);\n      this.timeoutId = null;\n    }\n  }\n\n  ngOnDestroy() {\n    this.clearTimeout();\n    this.current.length = 0;\n    this.deferred.length = 0;\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: TimerScheduler,\n    providedIn: 'root',\n    factory: () => new TimerScheduler(),\n  });\n}\n"]}

package/esm2022/src/defer/utils.mjs

@@ -0,0 +1,122 @@
+/**
+ * @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 { assertIndexInDeclRange } from '../render3/assert';
+import { HEADER_OFFSET, TVIEW } from '../render3/interfaces/view';
+import { getTNode } from '../render3/util/view_utils';
+import { assertEqual, throwError } from '../util/assert';
+import { DeferBlockState, DeferDependenciesLoadingState, LOADING_AFTER_SLOT, MINIMUM_SLOT } from './interfaces';
+/**
+ * Calculates a data slot index for defer block info (either static or
+ * instance-specific), given an index of a defer instruction.
+ */
+export function getDeferBlockDataIndex(deferBlockIndex) {
+    // Instance state is located at the *next* position
+    // after the defer block slot in an LView or TView.data.
+    return deferBlockIndex + 1;
+}
+/** Retrieves a defer block state from an LView, given a TNode that represents a block. */
+export function getLDeferBlockDetails(lView, tNode) {
+    const tView = lView[TVIEW];
+    const slotIndex = getDeferBlockDataIndex(tNode.index);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    return lView[slotIndex];
+}
+/** Stores a defer block instance state in LView. */
+export function setLDeferBlockDetails(lView, deferBlockIndex, lDetails) {
+    const tView = lView[TVIEW];
+    const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    lView[slotIndex] = lDetails;
+}
+/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */
+export function getTDeferBlockDetails(tView, tNode) {
+    const slotIndex = getDeferBlockDataIndex(tNode.index);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    return tView.data[slotIndex];
+}
+/** Stores a defer block static info in `TView.data`. */
+export function setTDeferBlockDetails(tView, deferBlockIndex, deferBlockConfig) {
+    const slotIndex = getDeferBlockDataIndex(deferBlockIndex);
+    ngDevMode && assertIndexInDeclRange(tView, slotIndex);
+    tView.data[slotIndex] = deferBlockConfig;
+}
+export function getTemplateIndexForState(newState, hostLView, tNode) {
+    const tView = hostLView[TVIEW];
+    const tDetails = getTDeferBlockDetails(tView, tNode);
+    switch (newState) {
+        case DeferBlockState.Complete:
+            return tDetails.primaryTmplIndex;
+        case DeferBlockState.Loading:
+            return tDetails.loadingTmplIndex;
+        case DeferBlockState.Error:
+            return tDetails.errorTmplIndex;
+        case DeferBlockState.Placeholder:
+            return tDetails.placeholderTmplIndex;
+        default:
+            ngDevMode && throwError(`Unexpected defer block state: ${newState}`);
+            return null;
+    }
+}
+/**
+ * Returns a minimum amount of time that a given state should be rendered for,
+ * taking into account `minimum` parameter value. If the `minimum` value is
+ * not specified - returns `null`.
+ */
+export function getMinimumDurationForState(tDetails, currentState) {
+    if (currentState === DeferBlockState.Placeholder) {
+        return tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null;
+    }
+    else if (currentState === DeferBlockState.Loading) {
+        return tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null;
+    }
+    return null;
+}
+/** Retrieves the value of the `after` parameter on the @loading block. */
+export function getLoadingBlockAfter(tDetails) {
+    return tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null;
+}
+/**
+ * Adds downloaded dependencies into a directive or a pipe registry,
+ * making sure that a dependency doesn't yet exist in the registry.
+ */
+export function addDepsToRegistry(currentDeps, newDeps) {
+    if (!currentDeps || currentDeps.length === 0) {
+        return newDeps;
+    }
+    const currentDepSet = new Set(currentDeps);
+    for (const dep of newDeps) {
+        currentDepSet.add(dep);
+    }
+    // If `currentDeps` is the same length, there were no new deps and can
+    // return the original array.
+    return (currentDeps.length === currentDepSet.size) ? currentDeps : Array.from(currentDepSet);
+}
+/** Retrieves a TNode that represents main content of a defer block. */
+export function getPrimaryBlockTNode(tView, tDetails) {
+    const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;
+    return getTNode(tView, adjustedIndex);
+}
+/**
+ * Asserts whether all dependencies for a defer block are loaded.
+ * Always run this function (in dev mode) before rendering a defer
+ * block in completed state.
+ */
+export function assertDeferredDependenciesLoaded(tDetails) {
+    assertEqual(tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE, 'Expecting all deferred dependencies to be loaded.');
+}
+/**
+ * Determines if a given value matches the expected structure of a defer block
+ *
+ * We can safely rely on the primaryTmplIndex because every defer block requires
+ * that a primary template exists. All the other template options are optional.
+ */
+export function isTDeferBlockDetails(value) {
+    return (typeof value === 'object') &&
+        (typeof value.primaryTmplIndex === 'number');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/defer/utils.ts"],"names":[],"mappings":"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","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 {assertIndexInDeclRange} from '../render3/assert';\nimport {DependencyDef} from '../render3/interfaces/definition';\nimport {TContainerNode, TNode} from '../render3/interfaces/node';\nimport {HEADER_OFFSET, LView, TVIEW, TView} from '../render3/interfaces/view';\nimport {getTNode} from '../render3/util/view_utils';\nimport {assertEqual, throwError} from '../util/assert';\n\nimport {DeferBlockState, DeferDependenciesLoadingState, LDeferBlockDetails, LOADING_AFTER_SLOT, MINIMUM_SLOT, TDeferBlockDetails} from './interfaces';\n\n\n/**\n * Calculates a data slot index for defer block info (either static or\n * instance-specific), given an index of a defer instruction.\n */\nexport function getDeferBlockDataIndex(deferBlockIndex: number) {\n  // Instance state is located at the *next* position\n  // after the defer block slot in an LView or TView.data.\n  return deferBlockIndex + 1;\n}\n\n/** Retrieves a defer block state from an LView, given a TNode that represents a block. */\nexport function getLDeferBlockDetails(lView: LView, tNode: TNode): LDeferBlockDetails {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return lView[slotIndex];\n}\n\n/** Stores a defer block instance state in LView. */\nexport function setLDeferBlockDetails(\n    lView: LView, deferBlockIndex: number, lDetails: LDeferBlockDetails) {\n  const tView = lView[TVIEW];\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  lView[slotIndex] = lDetails;\n}\n\n/** Retrieves static info about a defer block, given a TView and a TNode that represents a block. */\nexport function getTDeferBlockDetails(tView: TView, tNode: TNode): TDeferBlockDetails {\n  const slotIndex = getDeferBlockDataIndex(tNode.index);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  return tView.data[slotIndex] as TDeferBlockDetails;\n}\n\n/** Stores a defer block static info in `TView.data`. */\nexport function setTDeferBlockDetails(\n    tView: TView, deferBlockIndex: number, deferBlockConfig: TDeferBlockDetails) {\n  const slotIndex = getDeferBlockDataIndex(deferBlockIndex);\n  ngDevMode && assertIndexInDeclRange(tView, slotIndex);\n  tView.data[slotIndex] = deferBlockConfig;\n}\n\nexport function getTemplateIndexForState(\n    newState: DeferBlockState, hostLView: LView, tNode: TNode): number|null {\n  const tView = hostLView[TVIEW];\n  const tDetails = getTDeferBlockDetails(tView, tNode);\n\n  switch (newState) {\n    case DeferBlockState.Complete:\n      return tDetails.primaryTmplIndex;\n    case DeferBlockState.Loading:\n      return tDetails.loadingTmplIndex;\n    case DeferBlockState.Error:\n      return tDetails.errorTmplIndex;\n    case DeferBlockState.Placeholder:\n      return tDetails.placeholderTmplIndex;\n    default:\n      ngDevMode && throwError(`Unexpected defer block state: ${newState}`);\n      return null;\n  }\n}\n\n/**\n * Returns a minimum amount of time that a given state should be rendered for,\n * taking into account `minimum` parameter value. If the `minimum` value is\n * not specified - returns `null`.\n */\nexport function getMinimumDurationForState(\n    tDetails: TDeferBlockDetails, currentState: DeferBlockState): number|null {\n  if (currentState === DeferBlockState.Placeholder) {\n    return tDetails.placeholderBlockConfig?.[MINIMUM_SLOT] ?? null;\n  } else if (currentState === DeferBlockState.Loading) {\n    return tDetails.loadingBlockConfig?.[MINIMUM_SLOT] ?? null;\n  }\n  return null;\n}\n\n/** Retrieves the value of the `after` parameter on the @loading block. */\nexport function getLoadingBlockAfter(tDetails: TDeferBlockDetails): number|null {\n  return tDetails.loadingBlockConfig?.[LOADING_AFTER_SLOT] ?? null;\n}\n\n/**\n * Adds downloaded dependencies into a directive or a pipe registry,\n * making sure that a dependency doesn't yet exist in the registry.\n */\nexport function addDepsToRegistry<T extends DependencyDef[]>(currentDeps: T|null, newDeps: T): T {\n  if (!currentDeps || currentDeps.length === 0) {\n    return newDeps;\n  }\n\n  const currentDepSet = new Set(currentDeps);\n  for (const dep of newDeps) {\n    currentDepSet.add(dep);\n  }\n\n  // If `currentDeps` is the same length, there were no new deps and can\n  // return the original array.\n  return (currentDeps.length === currentDepSet.size) ? currentDeps : Array.from(currentDepSet) as T;\n}\n\n/** Retrieves a TNode that represents main content of a defer block. */\nexport function getPrimaryBlockTNode(tView: TView, tDetails: TDeferBlockDetails): TContainerNode {\n  const adjustedIndex = tDetails.primaryTmplIndex + HEADER_OFFSET;\n  return getTNode(tView, adjustedIndex) as TContainerNode;\n}\n\n/**\n * Asserts whether all dependencies for a defer block are loaded.\n * Always run this function (in dev mode) before rendering a defer\n * block in completed state.\n */\nexport function assertDeferredDependenciesLoaded(tDetails: TDeferBlockDetails) {\n  assertEqual(\n      tDetails.loadingState, DeferDependenciesLoadingState.COMPLETE,\n      'Expecting all deferred dependencies to be loaded.');\n}\n\n/**\n * Determines if a given value matches the expected structure of a defer block\n *\n * We can safely rely on the primaryTmplIndex because every defer block requires\n * that a primary template exists. All the other template options are optional.\n */\nexport function isTDeferBlockDetails(value: unknown): value is TDeferBlockDetails {\n  return (typeof value === 'object') &&\n      (typeof (value as TDeferBlockDetails).primaryTmplIndex === 'number');\n}\n"]}