@angular/core 17.0.0-next.7 → 17.0.0-rc.0

package/esm2022/src/defer/interfaces.mjs

@@ -0,0 +1,79 @@
+/**
+ * @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;
+/**
+ * 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;AAsBH;;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;AAyC1C;;;;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 * Enumerates all `on` triggers of a defer block.\n */\nexport const enum DeferBlockTriggers {\n  OnIdle,\n  OnTimer,\n  OnImmediate,\n  OnHover,\n  OnInteraction,\n  OnViewport,\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;\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/**\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,192 @@
+/**
+ * @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';
+import { wrapWithLViewCleanup } from './utils';
+/**
+ * Returns a function that captures a provided delay.
+ * Invoking the returned function schedules a trigger.
+ */
+export function onTimer(delay) {
+    return (callback, lView, withLViewCleanup) => scheduleTimerTrigger(delay, callback, lView, withLViewCleanup);
+}
+/**
+ * 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.
+ * @param withLViewCleanup A flag that indicates whether a scheduled callback
+ *           should be cancelled in case an LView is destroyed before a callback
+ *           was invoked.
+ */
+export function scheduleTimerTrigger(delay, callback, lView, withLViewCleanup) {
+    const injector = lView[INJECTOR];
+    const scheduler = injector.get(TimerScheduler);
+    const cleanupFn = () => scheduler.remove(callback);
+    const wrappedCallback = withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;
+    scheduler.add(delay, wrappedCallback);
+    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 callbackIndex = this.removeFromQueue(this.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(this.deferred, callback);
+        }
+    }
+    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 = () => {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+            this.executingCallbacks = true;
+            // Invoke callbacks that were scheduled to run
+            // before the current time.
+            let now = Date.now();
+            let lastCallbackIndex = null;
+            for (let i = 0; i < this.current.length; i += 2) {
+                const invokeAt = this.current[i];
+                const callback = this.current[i + 1];
+                if (invokeAt <= now) {
+                    callback();
+                    // Point at the invoked callback function, which is located
+                    // after the timestamp.
+                    lastCallbackIndex = i + 1;
+                }
+                else {
+                    // We've reached a timer that should not be invoked yet.
+                    break;
+                }
+            }
+            if (lastCallbackIndex !== null) {
+                // If last callback index is `null` - no callbacks were invoked,
+                // so no cleanup is needed. Otherwise, remove invoked callbacks
+                // from the queue.
+                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 ||
+                // 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))) {
+                if (this.timeoutId !== null) {
+                    // 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.
+                    clearTimeout(this.timeoutId);
+                    this.timeoutId = null;
+                }
+                const timeout = Math.max(invokeAt - now, FRAME_DURATION_MS);
+                this.invokeTimerAt = invokeAt;
+                this.timeoutId = setTimeout(callback, timeout);
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this.timeoutId !== null) {
+            clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+        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\nimport {wrapWithLViewCleanup} from './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, withLViewCleanup: boolean) =>\n             scheduleTimerTrigger(delay, callback, lView, withLViewCleanup);\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 * @param withLViewCleanup A flag that indicates whether a scheduled callback\n *           should be cancelled in case an LView is destroyed before a callback\n *           was invoked.\n */\nexport function scheduleTimerTrigger(\n    delay: number, callback: VoidFunction, lView: LView, withLViewCleanup: boolean) {\n  const injector = lView[INJECTOR]!;\n  const scheduler = injector.get(TimerScheduler);\n  const cleanupFn = () => scheduler.remove(callback);\n  const wrappedCallback =\n      withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;\n  scheduler.add(delay, wrappedCallback);\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 callbackIndex = this.removeFromQueue(this.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(this.deferred, callback);\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      clearTimeout(this.timeoutId!);\n      this.timeoutId = null;\n\n      this.executingCallbacks = true;\n\n      // Invoke callbacks that were scheduled to run\n      // before the current time.\n      let now = Date.now();\n      let lastCallbackIndex: number|null = null;\n      for (let i = 0; i < this.current.length; i += 2) {\n        const invokeAt = this.current[i] as number;\n        const callback = this.current[i + 1] as VoidFunction;\n        if (invokeAt <= now) {\n          callback();\n          // Point at the invoked callback function, which is located\n          // after the timestamp.\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 !== null) {\n        // If last callback index is `null` - no callbacks were invoked,\n        // so no cleanup is needed. Otherwise, remove invoked callbacks\n        // from the queue.\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 ||\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        if (this.timeoutId !== null) {\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          clearTimeout(this.timeoutId);\n          this.timeoutId = null;\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  ngOnDestroy() {\n    if (this.timeoutId !== null) {\n      clearTimeout(this.timeoutId);\n      this.timeoutId = null;\n    }\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,134 @@
+/**
+ * @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, removeLViewOnDestroy, storeLViewOnDestroy } from '../render3/util/view_utils';
+import { assertEqual, throwError } from '../util/assert';
+import { DeferBlockState, DeferDependenciesLoadingState, LOADING_AFTER_SLOT, MINIMUM_SLOT } from './interfaces';
+/**
+ * Wraps a given callback into a logic that registers a cleanup function
+ * in the LView cleanup slot, to be invoked when an LView is destroyed.
+ */
+export function wrapWithLViewCleanup(callback, lView, cleanup) {
+    const wrappedCallback = () => {
+        callback();
+        removeLViewOnDestroy(lView, cleanup);
+    };
+    storeLViewOnDestroy(lView, cleanup);
+    return wrappedCallback;
+}
+/**
+ * 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, removeLViewOnDestroy, storeLViewOnDestroy} 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 * Wraps a given callback into a logic that registers a cleanup function\n * in the LView cleanup slot, to be invoked when an LView is destroyed.\n */\nexport function wrapWithLViewCleanup(\n    callback: VoidFunction, lView: LView, cleanup: VoidFunction): VoidFunction {\n  const wrappedCallback = () => {\n    callback();\n    removeLViewOnDestroy(lView, cleanup);\n  };\n  storeLViewOnDestroy(lView, cleanup);\n  return wrappedCallback;\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"]}

package/esm2022/src/errors.mjs

@@ -46,4 +46,4 @@ export function formatRuntimeError(code, message) {
     }
     return errorMessage;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../../../packages/core/src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,2BAA2B,EAAC,MAAM,0BAA0B,CAAC;AA+GrE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,YAAkD,SAAQ,KAAK;IAC1E,YAAmB,IAAO,EAAE,OAA0B;QACpD,KAAK,CAAC,kBAAkB,CAAI,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;QAD3B,SAAI,GAAJ,IAAI,CAAG;IAE1B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAC9B,IAAO,EAAE,OAA0B;IACrC,+FAA+F;IAC/F,2DAA2D;IAC3D,kDAAkD;IAClD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;IAExC,IAAI,YAAY,GAAG,GAAG,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IAEjE,IAAI,SAAS,IAAI,IAAI,GAAG,CAAC,EAAE;QACzB,MAAM,kBAAkB,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC7D,MAAM,SAAS,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAChD,YAAY;YACR,GAAG,YAAY,GAAG,SAAS,iBAAiB,2BAA2B,IAAI,QAAQ,EAAE,CAAC;KAC3F;IACD,OAAO,YAAY,CAAC;AACtB,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 {ERROR_DETAILS_PAGE_BASE_URL} from './error_details_base_url';\n\n/**\n * The list of error codes used in runtime code of the `core` package.\n * Reserved error code range: 100-999.\n *\n * Note: the minus sign denotes the fact that a particular code has a detailed guide on\n * angular.io. This extra annotation is needed to avoid introducing a separate set to store\n * error codes which have guides, which might leak into runtime code.\n *\n * Full list of available error guides can be found at https://angular.io/errors.\n *\n * Error code ranges per package:\n *  - core (this package): 100-999\n *  - forms: 1000-1999\n *  - common: 2000-2999\n *  - animations: 3000-3999\n *  - router: 4000-4999\n *  - platform-browser: 5000-5500\n */\nexport const enum RuntimeErrorCode {\n  // Change Detection Errors\n  EXPRESSION_CHANGED_AFTER_CHECKED = -100,\n  RECURSIVE_APPLICATION_REF_TICK = 101,\n  RECURSIVE_APPLICATION_RENDER = 102,\n\n  // Dependency Injection Errors\n  CYCLIC_DI_DEPENDENCY = -200,\n  PROVIDER_NOT_FOUND = -201,\n  INVALID_FACTORY_DEPENDENCY = 202,\n  MISSING_INJECTION_CONTEXT = -203,\n  INVALID_INJECTION_TOKEN = 204,\n  INJECTOR_ALREADY_DESTROYED = 205,\n  PROVIDER_IN_WRONG_CONTEXT = 207,\n  MISSING_INJECTION_TOKEN = 208,\n  INVALID_MULTI_PROVIDER = -209,\n  MISSING_DOCUMENT = 210,\n\n  // Template Errors\n  MULTIPLE_COMPONENTS_MATCH = -300,\n  EXPORT_NOT_FOUND = -301,\n  PIPE_NOT_FOUND = -302,\n  UNKNOWN_BINDING = 303,\n  UNKNOWN_ELEMENT = 304,\n  TEMPLATE_STRUCTURE_ERROR = 305,\n  INVALID_EVENT_BINDING = 306,\n  HOST_DIRECTIVE_UNRESOLVABLE = 307,\n  HOST_DIRECTIVE_NOT_STANDALONE = 308,\n  DUPLICATE_DIRECTITVE = 309,\n  HOST_DIRECTIVE_COMPONENT = 310,\n  HOST_DIRECTIVE_UNDEFINED_BINDING = 311,\n  HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,\n  MULTIPLE_MATCHING_PIPES = 313,\n\n  // Bootstrap Errors\n  MULTIPLE_PLATFORMS = 400,\n  PLATFORM_NOT_FOUND = 401,\n  MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,\n  BOOTSTRAP_COMPONENTS_NOT_FOUND = -403,\n  PLATFORM_ALREADY_DESTROYED = 404,\n  ASYNC_INITIALIZERS_STILL_RUNNING = 405,\n  APPLICATION_REF_ALREADY_DESTROYED = 406,\n  RENDERER_NOT_FOUND = 407,\n\n  // Hydration Errors\n  HYDRATION_NODE_MISMATCH = -500,\n  HYDRATION_MISSING_SIBLINGS = -501,\n  HYDRATION_MISSING_NODE = -502,\n  UNSUPPORTED_PROJECTION_DOM_NODES = -503,\n  INVALID_SKIP_HYDRATION_HOST = -504,\n  MISSING_HYDRATION_ANNOTATIONS = -505,\n  HYDRATION_STABLE_TIMEDOUT = -506,\n  MISSING_SSR_CONTENT_INTEGRITY_MARKER = -507,\n\n  // Signal Errors\n  SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,\n  REQUIRE_SYNC_WITHOUT_SYNC_EMIT = 601,\n\n  // Styling Errors\n\n  // Declarations Errors\n\n  // i18n Errors\n  INVALID_I18N_STRUCTURE = 700,\n  MISSING_LOCALE_DATA = 701,\n\n  // standalone errors\n  IMPORT_PROVIDERS_FROM_STANDALONE = 800,\n\n  // JIT Compilation Errors\n  // Other\n  INVALID_DIFFER_INPUT = 900,\n  NO_SUPPORTING_DIFFER_FACTORY = 901,\n  VIEW_ALREADY_ATTACHED = 902,\n  INVALID_INHERITANCE = 903,\n  UNSAFE_VALUE_IN_RESOURCE_URL = 904,\n  UNSAFE_VALUE_IN_SCRIPT = 905,\n  MISSING_GENERATED_DEF = 906,\n  TYPE_IS_NOT_STANDALONE = 907,\n  MISSING_ZONEJS = 908,\n  UNEXPECTED_ZONE_STATE = 909,\n  UNSAFE_IFRAME_ATTRS = -910,\n  VIEW_ALREADY_DESTROYED = 911,\n  COMPONENT_ID_COLLISION = -912,\n\n  // Runtime dependency tracker errors\n  RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000,\n  RUNTIME_DEPS_ORPHAN_COMPONENT = 1001,\n}\n\n\n/**\n * Class that represents a runtime error.\n * Formats and outputs the error message in a consistent way.\n *\n * Example:\n * ```\n *  throw new RuntimeError(\n *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,\n *    ngDevMode && 'Injector has already been destroyed.');\n * ```\n *\n * Note: the `message` argument contains a descriptive error message as a string in development\n * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the\n * `message` argument becomes `false`, thus we account for it in the typings and the runtime\n * logic.\n */\nexport class RuntimeError<T extends number = RuntimeErrorCode> extends Error {\n  constructor(public code: T, message: null|false|string) {\n    super(formatRuntimeError<T>(code, message));\n  }\n}\n\n/**\n * Called to format a runtime error.\n * See additional info on the `message` argument type in the `RuntimeError` class description.\n */\nexport function formatRuntimeError<T extends number = RuntimeErrorCode>(\n    code: T, message: null|false|string): string {\n  // Error code might be a negative number, which is a special marker that instructs the logic to\n  // generate a link to the error details page on angular.io.\n  // We also prepend `0` to non-compile-time errors.\n  const fullCode = `NG0${Math.abs(code)}`;\n\n  let errorMessage = `${fullCode}${message ? ': ' + message : ''}`;\n\n  if (ngDevMode && code < 0) {\n    const addPeriodSeparator = !errorMessage.match(/[.,;!?\\n]$/);\n    const separator = addPeriodSeparator ? '.' : '';\n    errorMessage =\n        `${errorMessage}${separator} Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/${fullCode}`;\n  }\n  return errorMessage;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../../../packages/core/src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,2BAA2B,EAAC,MAAM,0BAA0B,CAAC;AAiHrE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,YAAkD,SAAQ,KAAK;IAC1E,YAAmB,IAAO,EAAE,OAA0B;QACpD,KAAK,CAAC,kBAAkB,CAAI,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;QAD3B,SAAI,GAAJ,IAAI,CAAG;IAE1B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAC9B,IAAO,EAAE,OAA0B;IACrC,+FAA+F;IAC/F,2DAA2D;IAC3D,kDAAkD;IAClD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;IAExC,IAAI,YAAY,GAAG,GAAG,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IAEjE,IAAI,SAAS,IAAI,IAAI,GAAG,CAAC,EAAE;QACzB,MAAM,kBAAkB,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;QAC7D,MAAM,SAAS,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAChD,YAAY;YACR,GAAG,YAAY,GAAG,SAAS,iBAAiB,2BAA2B,IAAI,QAAQ,EAAE,CAAC;KAC3F;IACD,OAAO,YAAY,CAAC;AACtB,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 {ERROR_DETAILS_PAGE_BASE_URL} from './error_details_base_url';\n\n/**\n * The list of error codes used in runtime code of the `core` package.\n * Reserved error code range: 100-999.\n *\n * Note: the minus sign denotes the fact that a particular code has a detailed guide on\n * angular.io. This extra annotation is needed to avoid introducing a separate set to store\n * error codes which have guides, which might leak into runtime code.\n *\n * Full list of available error guides can be found at https://angular.io/errors.\n *\n * Error code ranges per package:\n *  - core (this package): 100-999\n *  - forms: 1000-1999\n *  - common: 2000-2999\n *  - animations: 3000-3999\n *  - router: 4000-4999\n *  - platform-browser: 5000-5500\n */\nexport const enum RuntimeErrorCode {\n  // Change Detection Errors\n  EXPRESSION_CHANGED_AFTER_CHECKED = -100,\n  RECURSIVE_APPLICATION_REF_TICK = 101,\n  RECURSIVE_APPLICATION_RENDER = 102,\n\n  // Dependency Injection Errors\n  CYCLIC_DI_DEPENDENCY = -200,\n  PROVIDER_NOT_FOUND = -201,\n  INVALID_FACTORY_DEPENDENCY = 202,\n  MISSING_INJECTION_CONTEXT = -203,\n  INVALID_INJECTION_TOKEN = 204,\n  INJECTOR_ALREADY_DESTROYED = 205,\n  PROVIDER_IN_WRONG_CONTEXT = 207,\n  MISSING_INJECTION_TOKEN = 208,\n  INVALID_MULTI_PROVIDER = -209,\n  MISSING_DOCUMENT = 210,\n\n  // Template Errors\n  MULTIPLE_COMPONENTS_MATCH = -300,\n  EXPORT_NOT_FOUND = -301,\n  PIPE_NOT_FOUND = -302,\n  UNKNOWN_BINDING = 303,\n  UNKNOWN_ELEMENT = 304,\n  TEMPLATE_STRUCTURE_ERROR = 305,\n  INVALID_EVENT_BINDING = 306,\n  HOST_DIRECTIVE_UNRESOLVABLE = 307,\n  HOST_DIRECTIVE_NOT_STANDALONE = 308,\n  DUPLICATE_DIRECTITVE = 309,\n  HOST_DIRECTIVE_COMPONENT = 310,\n  HOST_DIRECTIVE_UNDEFINED_BINDING = 311,\n  HOST_DIRECTIVE_CONFLICTING_ALIAS = 312,\n  MULTIPLE_MATCHING_PIPES = 313,\n\n  // Bootstrap Errors\n  MULTIPLE_PLATFORMS = 400,\n  PLATFORM_NOT_FOUND = 401,\n  MISSING_REQUIRED_INJECTABLE_IN_BOOTSTRAP = 402,\n  BOOTSTRAP_COMPONENTS_NOT_FOUND = -403,\n  PLATFORM_ALREADY_DESTROYED = 404,\n  ASYNC_INITIALIZERS_STILL_RUNNING = 405,\n  APPLICATION_REF_ALREADY_DESTROYED = 406,\n  RENDERER_NOT_FOUND = 407,\n\n  // Hydration Errors\n  HYDRATION_NODE_MISMATCH = -500,\n  HYDRATION_MISSING_SIBLINGS = -501,\n  HYDRATION_MISSING_NODE = -502,\n  UNSUPPORTED_PROJECTION_DOM_NODES = -503,\n  INVALID_SKIP_HYDRATION_HOST = -504,\n  MISSING_HYDRATION_ANNOTATIONS = -505,\n  HYDRATION_STABLE_TIMEDOUT = -506,\n  MISSING_SSR_CONTENT_INTEGRITY_MARKER = -507,\n\n  // Signal Errors\n  SIGNAL_WRITE_FROM_ILLEGAL_CONTEXT = 600,\n  REQUIRE_SYNC_WITHOUT_SYNC_EMIT = 601,\n  ASSERTION_NOT_INSIDE_REACTIVE_CONTEXT = -602,\n\n  // Styling Errors\n\n  // Declarations Errors\n\n  // i18n Errors\n  INVALID_I18N_STRUCTURE = 700,\n  MISSING_LOCALE_DATA = 701,\n\n  // standalone errors\n  IMPORT_PROVIDERS_FROM_STANDALONE = 800,\n\n  // JIT Compilation Errors\n  // Other\n  INVALID_DIFFER_INPUT = 900,\n  NO_SUPPORTING_DIFFER_FACTORY = 901,\n  VIEW_ALREADY_ATTACHED = 902,\n  INVALID_INHERITANCE = 903,\n  UNSAFE_VALUE_IN_RESOURCE_URL = 904,\n  UNSAFE_VALUE_IN_SCRIPT = 905,\n  MISSING_GENERATED_DEF = 906,\n  TYPE_IS_NOT_STANDALONE = 907,\n  MISSING_ZONEJS = 908,\n  UNEXPECTED_ZONE_STATE = 909,\n  UNSAFE_IFRAME_ATTRS = -910,\n  VIEW_ALREADY_DESTROYED = 911,\n  COMPONENT_ID_COLLISION = -912,\n  IMAGE_PERFORMANCE_WARNING = -913,\n\n  // Runtime dependency tracker errors\n  RUNTIME_DEPS_INVALID_IMPORTED_TYPE = 1000,\n  RUNTIME_DEPS_ORPHAN_COMPONENT = 1001,\n}\n\n\n/**\n * Class that represents a runtime error.\n * Formats and outputs the error message in a consistent way.\n *\n * Example:\n * ```\n *  throw new RuntimeError(\n *    RuntimeErrorCode.INJECTOR_ALREADY_DESTROYED,\n *    ngDevMode && 'Injector has already been destroyed.');\n * ```\n *\n * Note: the `message` argument contains a descriptive error message as a string in development\n * mode (when the `ngDevMode` is defined). In production mode (after tree-shaking pass), the\n * `message` argument becomes `false`, thus we account for it in the typings and the runtime\n * logic.\n */\nexport class RuntimeError<T extends number = RuntimeErrorCode> extends Error {\n  constructor(public code: T, message: null|false|string) {\n    super(formatRuntimeError<T>(code, message));\n  }\n}\n\n/**\n * Called to format a runtime error.\n * See additional info on the `message` argument type in the `RuntimeError` class description.\n */\nexport function formatRuntimeError<T extends number = RuntimeErrorCode>(\n    code: T, message: null|false|string): string {\n  // Error code might be a negative number, which is a special marker that instructs the logic to\n  // generate a link to the error details page on angular.io.\n  // We also prepend `0` to non-compile-time errors.\n  const fullCode = `NG0${Math.abs(code)}`;\n\n  let errorMessage = `${fullCode}${message ? ': ' + message : ''}`;\n\n  if (ngDevMode && code < 0) {\n    const addPeriodSeparator = !errorMessage.match(/[.,;!?\\n]$/);\n    const separator = addPeriodSeparator ? '.' : '';\n    errorMessage =\n        `${errorMessage}${separator} Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/${fullCode}`;\n  }\n  return errorMessage;\n}\n"]}