@angular/core 17.0.0-next.5 → 17.0.0-next.7

package/esm2022/src/render3/list_reconciliation.mjs

@@ -0,0 +1,257 @@
+/**
+ * @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
+ */
+/**
+ * A type representing the live collection to be reconciled with any new (incoming) collection. This
+ * is an adapter class that makes it possible to work with different internal data structures,
+ * regardless of the actual values of the incoming collection.
+ */
+export class LiveCollection {
+    destroy(item) {
+        // noop by default
+    }
+    updateValue(index, value) {
+        // noop by default
+    }
+    // operations below could be implemented on top of the operations defined so far, but having
+    // them explicitly allow clear expression of intent and potentially more performant
+    // implementations
+    swap(index1, index2) {
+        const startIdx = Math.min(index1, index2);
+        const endIdx = Math.max(index1, index2);
+        const endItem = this.detach(endIdx);
+        if (endIdx - startIdx > 1) {
+            const startItem = this.detach(startIdx);
+            this.attach(startIdx, endItem);
+            this.attach(endIdx, startItem);
+        }
+        else {
+            this.attach(startIdx, endItem);
+        }
+    }
+    move(prevIndex, newIdx) {
+        this.attach(newIdx, this.detach(prevIndex));
+    }
+}
+/**
+ * The live collection reconciliation algorithm that perform various in-place operations, so it
+ * reflects the content of the new (incoming) collection.
+ *
+ * The reconciliation algorithm has 2 code paths:
+ * - "fast" path that don't require any memory allocation;
+ * - "slow" path that requires additional memory allocation for intermediate data structures used to
+ * collect additional information about the live collection.
+ * It might happen that the algorithm switches between the two modes in question in a single
+ * reconciliation path - generally it tries to stay on the "fast" path as much as possible.
+ *
+ * The overall complexity of the algorithm is O(n + m) for speed and O(n) for memory (where n is the
+ * length of the live collection and m is the length of the incoming collection). Given the problem
+ * at hand the complexity / performance constraints makes it impossible to perform the absolute
+ * minimum of operation to reconcile the 2 collections. The algorithm makes different tradeoffs to
+ * stay within reasonable performance bounds and may apply sub-optimal number of operations in
+ * certain situations.
+ *
+ * @param liveCollection the current, live collection;
+ * @param newCollection the new, incoming collection;
+ * @param trackByFn key generation function that determines equality between items in the life and
+ *     incoming collection;
+ */
+export function reconcile(liveCollection, newCollection, trackByFn) {
+    let detachedItems = undefined;
+    let liveKeysInTheFuture = undefined;
+    let liveStartIdx = 0;
+    let liveEndIdx = liveCollection.length - 1;
+    if (Array.isArray(newCollection)) {
+        let newEndIdx = newCollection.length - 1;
+        while (liveStartIdx <= liveEndIdx && liveStartIdx <= newEndIdx) {
+            // compare from the beginning
+            const liveStartKey = liveCollection.key(liveStartIdx);
+            const newStartValue = newCollection[liveStartIdx];
+            const newStartKey = trackByFn(liveStartIdx, newStartValue);
+            if (Object.is(liveStartKey, newStartKey)) {
+                liveCollection.updateValue(liveStartIdx, newStartValue);
+                liveStartIdx++;
+                continue;
+            }
+            // compare from the end
+            // TODO(perf): do _all_ the matching from the end
+            const liveEndKey = liveCollection.key(liveEndIdx);
+            const newEndItem = newCollection[newEndIdx];
+            const newEndKey = trackByFn(newEndIdx, newEndItem);
+            if (Object.is(liveEndKey, newEndKey)) {
+                liveCollection.updateValue(liveEndIdx, newEndItem);
+                liveEndIdx--;
+                newEndIdx--;
+                continue;
+            }
+            // Detect swap / moves:
+            if (Object.is(newStartKey, liveEndKey) && Object.is(newEndKey, liveStartKey)) {
+                // swap on both ends;
+                liveCollection.swap(liveStartIdx, liveEndIdx);
+                liveCollection.updateValue(liveStartIdx, newStartValue);
+                liveCollection.updateValue(liveEndIdx, newEndItem);
+                newEndIdx--;
+                liveStartIdx++;
+                liveEndIdx--;
+                continue;
+            }
+            else if (Object.is(newStartKey, liveEndKey)) {
+                // the new item is the same as the live item with the end pointer - this is a move forward
+                // to an earlier index;
+                liveCollection.move(liveEndIdx, liveStartIdx);
+                liveCollection.updateValue(liveStartIdx, newStartValue);
+                liveStartIdx++;
+                continue;
+            }
+            // Fallback to the slow path: we need to learn more about the content of the live and new
+            // collections.
+            detachedItems ??= new MultiMap();
+            liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx);
+            // Check if I'm inserting a previously detached item: if so, attach it here
+            if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newStartKey)) {
+                liveCollection.updateValue(liveStartIdx, newStartValue);
+                liveStartIdx++;
+                liveEndIdx++;
+            }
+            else if (!liveKeysInTheFuture.has(newStartKey)) {
+                // Check if we seen a new item that doesn't exist in the old collection and must be INSERTED
+                const newItem = liveCollection.create(liveStartIdx, newCollection[liveStartIdx]);
+                liveCollection.attach(liveStartIdx, newItem);
+                liveStartIdx++;
+                liveEndIdx++;
+            }
+            else {
+                // We know that the new item exists later on in old collection but we don't know its index
+                // and as the consequence can't move it (don't know where to find it). Detach the old item,
+                // hoping that it unlocks the fast path again.
+                detachedItems.set(liveStartKey, liveCollection.detach(liveStartIdx));
+                liveEndIdx--;
+            }
+        }
+        // Final cleanup steps:
+        // - more items in the new collection => insert
+        while (liveStartIdx <= newEndIdx) {
+            createOrAttach(liveCollection, detachedItems, trackByFn, liveStartIdx, newCollection[liveStartIdx]);
+            liveStartIdx++;
+        }
+    }
+    else if (newCollection != null) {
+        // iterable - immediately fallback to the slow path
+        const newCollectionIterator = newCollection[Symbol.iterator]();
+        let newIterationResult = newCollectionIterator.next();
+        while (!newIterationResult.done && liveStartIdx <= liveEndIdx) {
+            const newValue = newIterationResult.value;
+            const newKey = trackByFn(liveStartIdx, newValue);
+            const liveKey = liveCollection.key(liveStartIdx);
+            if (Object.is(liveKey, newKey)) {
+                // found a match - move on
+                liveCollection.updateValue(liveStartIdx, newValue);
+                liveStartIdx++;
+                newIterationResult = newCollectionIterator.next();
+            }
+            else {
+                detachedItems ??= new MultiMap();
+                liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx);
+                // Check if I'm inserting a previously detached item: if so, attach it here
+                if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newKey)) {
+                    liveCollection.updateValue(liveStartIdx, newValue);
+                    liveStartIdx++;
+                    liveEndIdx++;
+                    newIterationResult = newCollectionIterator.next();
+                }
+                else if (!liveKeysInTheFuture.has(newKey)) {
+                    liveCollection.attach(liveStartIdx, liveCollection.create(liveStartIdx, newValue));
+                    liveStartIdx++;
+                    liveEndIdx++;
+                    newIterationResult = newCollectionIterator.next();
+                }
+                else {
+                    // it is a move forward - detach the current item without advancing in collections
+                    detachedItems.set(liveKey, liveCollection.detach(liveStartIdx));
+                    liveEndIdx--;
+                }
+            }
+        }
+        // this is a new item as we run out of the items in the old collection - create or attach a
+        // previously detached one
+        while (!newIterationResult.done) {
+            createOrAttach(liveCollection, detachedItems, trackByFn, liveCollection.length, newIterationResult.value);
+            newIterationResult = newCollectionIterator.next();
+        }
+    }
+    // Cleanups common to the array and iterable:
+    // - more items in the live collection => delete starting from the end;
+    while (liveStartIdx <= liveEndIdx) {
+        liveCollection.destroy(liveCollection.detach(liveEndIdx--));
+    }
+    // - destroy items that were detached but never attached again.
+    detachedItems?.forEach(item => liveCollection.destroy(item));
+}
+function attachPreviouslyDetached(prevCollection, detachedItems, index, key) {
+    if (detachedItems !== undefined && detachedItems.has(key)) {
+        prevCollection.attach(index, detachedItems.get(key));
+        detachedItems.delete(key);
+        return true;
+    }
+    return false;
+}
+function createOrAttach(liveCollection, detachedItems, trackByFn, index, value) {
+    if (!attachPreviouslyDetached(liveCollection, detachedItems, index, trackByFn(index, value))) {
+        const newItem = liveCollection.create(index, value);
+        liveCollection.attach(index, newItem);
+    }
+    else {
+        liveCollection.updateValue(index, value);
+    }
+}
+function initLiveItemsInTheFuture(liveCollection, start, end) {
+    const keys = new Set();
+    for (let i = start; i <= end; i++) {
+        keys.add(liveCollection.key(i));
+    }
+    return keys;
+}
+class MultiMap {
+    constructor() {
+        this.map = new Map();
+    }
+    has(key) {
+        const listOfKeys = this.map.get(key);
+        return listOfKeys !== undefined && listOfKeys.length > 0;
+    }
+    delete(key) {
+        const listOfKeys = this.map.get(key);
+        if (listOfKeys !== undefined) {
+            // THINK: pop from the end or shift from the front? "Correct" vs. "slow".
+            listOfKeys.pop();
+            return true;
+        }
+        return false;
+    }
+    get(key) {
+        const listOfKeys = this.map.get(key);
+        return listOfKeys !== undefined && listOfKeys.length > 0 ? listOfKeys[0] : undefined;
+    }
+    set(key, value) {
+        // if value is array, they we always store it as [value].
+        if (!this.map.has(key)) {
+            this.map.set(key, [value]);
+            return;
+        }
+        // THINK: this allows duplicate values, but I guess this is fine?
+        // Is the existing key an array or not?
+        this.map.get(key)?.push(value);
+    }
+    forEach(cb) {
+        for (const [key, values] of this.map) {
+            for (const value of values) {
+                cb(value, key);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list_reconciliation.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/list_reconciliation.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 {TrackByFunction} from '../change_detection';\n\n/**\n * A type representing the live collection to be reconciled with any new (incoming) collection. This\n * is an adapter class that makes it possible to work with different internal data structures,\n * regardless of the actual values of the incoming collection.\n */\nexport abstract class LiveCollection<T, V> {\n  abstract get length(): number;\n  abstract at(index: number): T;\n  abstract key(index: number): unknown;\n  abstract attach(index: number, item: T): void;\n  abstract detach(index: number): T;\n  abstract create(index: number, value: V): T;\n  destroy(item: T): void {\n    // noop by default\n  }\n  updateValue(index: number, value: V): void {\n    // noop by default\n  }\n\n  // operations below could be implemented on top of the operations defined so far, but having\n  // them explicitly allow clear expression of intent and potentially more performant\n  // implementations\n  swap(index1: number, index2: number): void {\n    const startIdx = Math.min(index1, index2);\n    const endIdx = Math.max(index1, index2);\n    const endItem = this.detach(endIdx);\n    if (endIdx - startIdx > 1) {\n      const startItem = this.detach(startIdx);\n      this.attach(startIdx, endItem);\n      this.attach(endIdx, startItem);\n    } else {\n      this.attach(startIdx, endItem);\n    }\n  }\n  move(prevIndex: number, newIdx: number): void {\n    this.attach(newIdx, this.detach(prevIndex));\n  }\n}\n\n/**\n * The live collection reconciliation algorithm that perform various in-place operations, so it\n * reflects the content of the new (incoming) collection.\n *\n * The reconciliation algorithm has 2 code paths:\n * - \"fast\" path that don't require any memory allocation;\n * - \"slow\" path that requires additional memory allocation for intermediate data structures used to\n * collect additional information about the live collection.\n * It might happen that the algorithm switches between the two modes in question in a single\n * reconciliation path - generally it tries to stay on the \"fast\" path as much as possible.\n *\n * The overall complexity of the algorithm is O(n + m) for speed and O(n) for memory (where n is the\n * length of the live collection and m is the length of the incoming collection). Given the problem\n * at hand the complexity / performance constraints makes it impossible to perform the absolute\n * minimum of operation to reconcile the 2 collections. The algorithm makes different tradeoffs to\n * stay within reasonable performance bounds and may apply sub-optimal number of operations in\n * certain situations.\n *\n * @param liveCollection the current, live collection;\n * @param newCollection the new, incoming collection;\n * @param trackByFn key generation function that determines equality between items in the life and\n *     incoming collection;\n */\nexport function reconcile<T, V>(\n    liveCollection: LiveCollection<T, V>, newCollection: Iterable<V>|undefined|null,\n    trackByFn: TrackByFunction<V>): void {\n  let detachedItems: MultiMap<unknown, T>|undefined = undefined;\n  let liveKeysInTheFuture: Set<unknown>|undefined = undefined;\n\n  let liveStartIdx = 0;\n  let liveEndIdx = liveCollection.length - 1;\n\n  if (Array.isArray(newCollection)) {\n    let newEndIdx = newCollection.length - 1;\n\n    while (liveStartIdx <= liveEndIdx && liveStartIdx <= newEndIdx) {\n      // compare from the beginning\n      const liveStartKey = liveCollection.key(liveStartIdx);\n      const newStartValue = newCollection[liveStartIdx];\n      const newStartKey = trackByFn(liveStartIdx, newStartValue);\n      if (Object.is(liveStartKey, newStartKey)) {\n        liveCollection.updateValue(liveStartIdx, newStartValue);\n        liveStartIdx++;\n        continue;\n      }\n\n      // compare from the end\n      // TODO(perf): do _all_ the matching from the end\n      const liveEndKey = liveCollection.key(liveEndIdx);\n      const newEndItem = newCollection[newEndIdx];\n      const newEndKey = trackByFn(newEndIdx, newEndItem);\n      if (Object.is(liveEndKey, newEndKey)) {\n        liveCollection.updateValue(liveEndIdx, newEndItem);\n        liveEndIdx--;\n        newEndIdx--;\n        continue;\n      }\n\n      // Detect swap / moves:\n      if (Object.is(newStartKey, liveEndKey) && Object.is(newEndKey, liveStartKey)) {\n        // swap on both ends;\n        liveCollection.swap(liveStartIdx, liveEndIdx);\n        liveCollection.updateValue(liveStartIdx, newStartValue);\n        liveCollection.updateValue(liveEndIdx, newEndItem);\n        newEndIdx--;\n        liveStartIdx++;\n        liveEndIdx--;\n        continue;\n      } else if (Object.is(newStartKey, liveEndKey)) {\n        // the new item is the same as the live item with the end pointer - this is a move forward\n        // to an earlier index;\n        liveCollection.move(liveEndIdx, liveStartIdx);\n        liveCollection.updateValue(liveStartIdx, newStartValue);\n        liveStartIdx++;\n        continue;\n      }\n\n      // Fallback to the slow path: we need to learn more about the content of the live and new\n      // collections.\n      detachedItems ??= new MultiMap();\n      liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx);\n\n      // Check if I'm inserting a previously detached item: if so, attach it here\n      if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newStartKey)) {\n        liveCollection.updateValue(liveStartIdx, newStartValue);\n        liveStartIdx++;\n        liveEndIdx++;\n      } else if (!liveKeysInTheFuture.has(newStartKey)) {\n        // Check if we seen a new item that doesn't exist in the old collection and must be INSERTED\n        const newItem = liveCollection.create(liveStartIdx, newCollection[liveStartIdx]);\n        liveCollection.attach(liveStartIdx, newItem);\n        liveStartIdx++;\n        liveEndIdx++;\n      } else {\n        // We know that the new item exists later on in old collection but we don't know its index\n        // and as the consequence can't move it (don't know where to find it). Detach the old item,\n        // hoping that it unlocks the fast path again.\n        detachedItems.set(liveStartKey, liveCollection.detach(liveStartIdx));\n        liveEndIdx--;\n      }\n    }\n\n    // Final cleanup steps:\n    // - more items in the new collection => insert\n    while (liveStartIdx <= newEndIdx) {\n      createOrAttach(\n          liveCollection, detachedItems, trackByFn, liveStartIdx, newCollection[liveStartIdx]);\n      liveStartIdx++;\n    }\n\n  } else if (newCollection != null) {\n    // iterable - immediately fallback to the slow path\n    const newCollectionIterator = newCollection[Symbol.iterator]();\n    let newIterationResult = newCollectionIterator.next();\n    while (!newIterationResult.done && liveStartIdx <= liveEndIdx) {\n      const newValue = newIterationResult.value;\n      const newKey = trackByFn(liveStartIdx, newValue);\n      const liveKey = liveCollection.key(liveStartIdx);\n      if (Object.is(liveKey, newKey)) {\n        // found a match - move on\n        liveCollection.updateValue(liveStartIdx, newValue);\n        liveStartIdx++;\n        newIterationResult = newCollectionIterator.next();\n      } else {\n        detachedItems ??= new MultiMap();\n        liveKeysInTheFuture ??= initLiveItemsInTheFuture(liveCollection, liveStartIdx, liveEndIdx);\n\n        // Check if I'm inserting a previously detached item: if so, attach it here\n        if (attachPreviouslyDetached(liveCollection, detachedItems, liveStartIdx, newKey)) {\n          liveCollection.updateValue(liveStartIdx, newValue);\n          liveStartIdx++;\n          liveEndIdx++;\n          newIterationResult = newCollectionIterator.next();\n        } else if (!liveKeysInTheFuture.has(newKey)) {\n          liveCollection.attach(liveStartIdx, liveCollection.create(liveStartIdx, newValue));\n          liveStartIdx++;\n          liveEndIdx++;\n          newIterationResult = newCollectionIterator.next();\n        } else {\n          // it is a move forward - detach the current item without advancing in collections\n          detachedItems.set(liveKey, liveCollection.detach(liveStartIdx));\n          liveEndIdx--;\n        }\n      }\n    }\n\n    // this is a new item as we run out of the items in the old collection - create or attach a\n    // previously detached one\n    while (!newIterationResult.done) {\n      createOrAttach(\n          liveCollection, detachedItems, trackByFn, liveCollection.length,\n          newIterationResult.value);\n      newIterationResult = newCollectionIterator.next();\n    }\n  }\n\n  // Cleanups common to the array and iterable:\n  // - more items in the live collection => delete starting from the end;\n  while (liveStartIdx <= liveEndIdx) {\n    liveCollection.destroy(liveCollection.detach(liveEndIdx--));\n  }\n\n  // - destroy items that were detached but never attached again.\n  detachedItems?.forEach(item => liveCollection.destroy(item));\n}\n\nfunction attachPreviouslyDetached<T, V>(\n    prevCollection: LiveCollection<T, V>, detachedItems: MultiMap<unknown, T>|undefined,\n    index: number, key: unknown): boolean {\n  if (detachedItems !== undefined && detachedItems.has(key)) {\n    prevCollection.attach(index, detachedItems.get(key)!);\n    detachedItems.delete(key);\n    return true;\n  }\n  return false;\n}\n\nfunction createOrAttach<T, V>(\n    liveCollection: LiveCollection<T, V>, detachedItems: MultiMap<unknown, T>|undefined,\n    trackByFn: TrackByFunction<unknown>, index: number, value: V) {\n  if (!attachPreviouslyDetached(liveCollection, detachedItems, index, trackByFn(index, value))) {\n    const newItem = liveCollection.create(index, value);\n    liveCollection.attach(index, newItem);\n  } else {\n    liveCollection.updateValue(index, value);\n  }\n}\n\nfunction initLiveItemsInTheFuture<T>(\n    liveCollection: LiveCollection<unknown, unknown>, start: number, end: number): Set<unknown> {\n  const keys = new Set();\n  for (let i = start; i <= end; i++) {\n    keys.add(liveCollection.key(i));\n  }\n  return keys;\n}\n\nclass MultiMap<K, V> {\n  private map = new Map<K, Array<V>>();\n\n  has(key: K): boolean {\n    const listOfKeys = this.map.get(key);\n    return listOfKeys !== undefined && listOfKeys.length > 0;\n  }\n\n  delete(key: K): boolean {\n    const listOfKeys = this.map.get(key);\n    if (listOfKeys !== undefined) {\n      // THINK: pop from the end or shift from the front? \"Correct\" vs. \"slow\".\n      listOfKeys.pop();\n      return true;\n    }\n    return false;\n  }\n\n  get(key: K): V|undefined {\n    const listOfKeys = this.map.get(key);\n    return listOfKeys !== undefined && listOfKeys.length > 0 ? listOfKeys[0] : undefined;\n  }\n\n  set(key: K, value: V): void {\n    // if value is array, they we always store it as [value].\n    if (!this.map.has(key)) {\n      this.map.set(key, [value]);\n      return;\n    }\n    // THINK: this allows duplicate values, but I guess this is fine?\n    // Is the existing key an array or not?\n    this.map.get(key)?.push(value);\n  }\n\n  forEach(cb: (v: V, k: K) => void) {\n    for (const [key, values] of this.map) {\n      for (const value of values) {\n        cb(value, key);\n      }\n    }\n  }\n}\n"]}

package/esm2022/src/render3/metadata.mjs

@@ -22,7 +22,7 @@ export function getAsyncClassMetadata(type) {
 }
 /**
  * Handles the process of applying metadata info to a component class in case
- * component template had `{#defer}` blocks (thus some dependencies became deferrable).
+ * component template had defer blocks (thus some dependencies became deferrable).
  *
  * @param type Component class where metadata should be added
  * @param dependencyLoaderFn Function that loads dependencies
@@ -80,4 +80,4 @@ export function setClassMetadata(type, decorators, ctorParameters, propDecorator
         }
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/render3/pipe.mjs

@@ -136,17 +136,17 @@ function getPipeNotFoundErrorMessage(name) {
  * the pipe only when an input to the pipe changes.
  *
  * @param index Pipe index where the pipe was stored on creation.
- * @param slotOffset the offset in the reserved slot space
+ * @param offset the binding offset
  * @param v1 1st argument to {@link PipeTransform#transform}.
  *
  * @codeGenApi
  */
-export function ɵɵpipeBind1(index, slotOffset, v1) {
+export function ɵɵpipeBind1(index, offset, v1) {
     const adjustedIndex = index + HEADER_OFFSET;
     const lView = getLView();
     const pipeInstance = load(lView, adjustedIndex);
     return isPure(lView, adjustedIndex) ?
-        pureFunction1Internal(lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, pipeInstance) :
+        pureFunction1Internal(lView, getBindingRoot(), offset, pipeInstance.transform, v1, pipeInstance) :
         pipeInstance.transform(v1);
 }
 /**
@@ -237,4 +237,4 @@ export function ɵɵpipeBindV(index, slotOffset, values) {
 function isPure(lView, index) {
     return lView[TVIEW].data[index].pure;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipe.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/pipe.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 {PipeTransform} from '../change_detection/pipe_transform';\nimport {setInjectImplementation} from '../di/inject_switch';\nimport {formatRuntimeError, RuntimeError, RuntimeErrorCode} from '../errors';\nimport {Type} from '../interface/type';\n\nimport {InjectorProfilerContext, setInjectorProfilerContext} from './debug/injector_profiler';\nimport {getFactoryDef} from './definition_factory';\nimport {NodeInjector, setIncludeViewProviders} from './di';\nimport {store, ɵɵdirectiveInject} from './instructions/all';\nimport {isHostComponentStandalone} from './instructions/element_validation';\nimport {PipeDef, PipeDefList} from './interfaces/definition';\nimport {TTextNode} from './interfaces/node';\nimport {CONTEXT, DECLARATION_COMPONENT_VIEW, HEADER_OFFSET, LView, TVIEW} from './interfaces/view';\nimport {pureFunction1Internal, pureFunction2Internal, pureFunction3Internal, pureFunction4Internal, pureFunctionVInternal} from './pure_function';\nimport {getBindingRoot, getCurrentTNode, getLView, getTView} from './state';\nimport {load} from './util/view_utils';\n\n\n\n/**\n * Create a pipe.\n *\n * @param index Pipe index where the pipe will be stored.\n * @param pipeName The name of the pipe\n * @returns T the instance of the pipe.\n *\n * @codeGenApi\n */\nexport function ɵɵpipe(index: number, pipeName: string): any {\n  const tView = getTView();\n  let pipeDef: PipeDef<any>;\n  const adjustedIndex = index + HEADER_OFFSET;\n\n  if (tView.firstCreatePass) {\n    // The `getPipeDef` throws if a pipe with a given name is not found\n    // (so we use non-null assertion below).\n    pipeDef = getPipeDef(pipeName, tView.pipeRegistry)!;\n    tView.data[adjustedIndex] = pipeDef;\n    if (pipeDef.onDestroy) {\n      (tView.destroyHooks ??= []).push(adjustedIndex, pipeDef.onDestroy);\n    }\n  } else {\n    pipeDef = tView.data[adjustedIndex] as PipeDef<any>;\n  }\n\n  const pipeFactory = pipeDef.factory || (pipeDef.factory = getFactoryDef(pipeDef.type, true));\n\n  let previousInjectorProfilerContext: InjectorProfilerContext;\n  if (ngDevMode) {\n    previousInjectorProfilerContext = setInjectorProfilerContext({\n      injector: new NodeInjector(getCurrentTNode() as TTextNode, getLView()),\n      token: pipeDef.type\n    });\n  }\n  const previousInjectImplementation = setInjectImplementation(ɵɵdirectiveInject);\n  try {\n    // DI for pipes is supposed to behave like directives when placed on a component\n    // host node, which means that we have to disable access to `viewProviders`.\n    const previousIncludeViewProviders = setIncludeViewProviders(false);\n    const pipeInstance = pipeFactory();\n    setIncludeViewProviders(previousIncludeViewProviders);\n    store(tView, getLView(), adjustedIndex, pipeInstance);\n    return pipeInstance;\n  } finally {\n    // we have to restore the injector implementation in finally, just in case the creation of the\n    // pipe throws an error.\n    setInjectImplementation(previousInjectImplementation);\n    ngDevMode && setInjectorProfilerContext(previousInjectorProfilerContext!);\n  }\n}\n\n/**\n * Searches the pipe registry for a pipe with the given name. If one is found,\n * returns the pipe. Otherwise, an error is thrown because the pipe cannot be resolved.\n *\n * @param name Name of pipe to resolve\n * @param registry Full list of available pipes\n * @returns Matching PipeDef\n */\nfunction getPipeDef(name: string, registry: PipeDefList|null): PipeDef<any>|undefined {\n  if (registry) {\n    if (ngDevMode) {\n      const pipes = registry.filter(pipe => pipe.name === name);\n      // TODO: Throw an error in the next major\n      if (pipes.length > 1) {\n        console.warn(formatRuntimeError(\n            RuntimeErrorCode.MULTIPLE_MATCHING_PIPES, getMultipleMatchingPipesMessage(name)));\n      }\n    }\n    for (let i = registry.length - 1; i >= 0; i--) {\n      const pipeDef = registry[i];\n      if (name === pipeDef.name) {\n        return pipeDef;\n      }\n    }\n  }\n  if (ngDevMode) {\n    throw new RuntimeError(RuntimeErrorCode.PIPE_NOT_FOUND, getPipeNotFoundErrorMessage(name));\n  }\n  return;\n}\n\n/**\n * Generates a helpful error message for the user when multiple pipes match the name.\n *\n * @param name Name of the pipe\n * @returns The error message\n */\nfunction getMultipleMatchingPipesMessage(name: string) {\n  const lView = getLView();\n  const declarationLView = lView[DECLARATION_COMPONENT_VIEW] as LView<Type<unknown>>;\n  const context = declarationLView[CONTEXT];\n  const hostIsStandalone = isHostComponentStandalone(lView);\n  const componentInfoMessage = context ? ` in the '${context.constructor.name}' component` : '';\n  const verifyMessage = `check ${\n      hostIsStandalone ? '\\'@Component.imports\\' of this component' :\n                         'the imports of this module'}`;\n  const errorMessage =\n      `Multiple pipes match the name \\`${name}\\`${componentInfoMessage}. ${verifyMessage}`;\n  return errorMessage;\n}\n\n/**\n * Generates a helpful error message for the user when a pipe is not found.\n *\n * @param name Name of the missing pipe\n * @returns The error message\n */\nfunction getPipeNotFoundErrorMessage(name: string) {\n  const lView = getLView();\n  const declarationLView = lView[DECLARATION_COMPONENT_VIEW] as LView<Type<unknown>>;\n  const context = declarationLView[CONTEXT];\n  const hostIsStandalone = isHostComponentStandalone(lView);\n  const componentInfoMessage = context ? ` in the '${context.constructor.name}' component` : '';\n  const verifyMessage = `Verify that it is ${\n      hostIsStandalone ? 'included in the \\'@Component.imports\\' of this component' :\n                         'declared or imported in this module'}`;\n  const errorMessage =\n      `The pipe '${name}' could not be found${componentInfoMessage}. ${verifyMessage}`;\n  return errorMessage;\n}\n\n/**\n * Invokes a pipe with 1 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param slotOffset the offset in the reserved slot space\n * @param v1 1st argument to {@link PipeTransform#transform}.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBind1(index: number, slotOffset: number, v1: any): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ?\n      pureFunction1Internal(\n          lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, pipeInstance) :\n      pipeInstance.transform(v1);\n}\n\n/**\n * Invokes a pipe with 2 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param slotOffset the offset in the reserved slot space\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBind2(index: number, slotOffset: number, v1: any, v2: any): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ?\n      pureFunction2Internal(\n          lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, pipeInstance) :\n      pipeInstance.transform(v1, v2);\n}\n\n/**\n * Invokes a pipe with 3 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param slotOffset the offset in the reserved slot space\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n * @param v3 4rd argument to {@link PipeTransform#transform}.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBind3(index: number, slotOffset: number, v1: any, v2: any, v3: any): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ?\n      pureFunction3Internal(\n          lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, v3, pipeInstance) :\n      pipeInstance.transform(v1, v2, v3);\n}\n\n/**\n * Invokes a pipe with 4 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param slotOffset the offset in the reserved slot space\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n * @param v3 3rd argument to {@link PipeTransform#transform}.\n * @param v4 4th argument to {@link PipeTransform#transform}.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBind4(\n    index: number, slotOffset: number, v1: any, v2: any, v3: any, v4: any): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ? pureFunction4Internal(\n                                            lView, getBindingRoot(), slotOffset,\n                                            pipeInstance.transform, v1, v2, v3, v4, pipeInstance) :\n                                        pipeInstance.transform(v1, v2, v3, v4);\n}\n\n/**\n * Invokes a pipe with variable number of arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param slotOffset the offset in the reserved slot space\n * @param values Array of arguments to pass to {@link PipeTransform#transform} method.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBindV(index: number, slotOffset: number, values: [any, ...any[]]): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ?\n      pureFunctionVInternal(\n          lView, getBindingRoot(), slotOffset, pipeInstance.transform, values, pipeInstance) :\n      pipeInstance.transform.apply(pipeInstance, values);\n}\n\nfunction isPure(lView: LView, index: number): boolean {\n  return (<PipeDef<any>>lView[TVIEW].data[index]).pure;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pipe.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/pipe.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 {PipeTransform} from '../change_detection/pipe_transform';\nimport {setInjectImplementation} from '../di/inject_switch';\nimport {formatRuntimeError, RuntimeError, RuntimeErrorCode} from '../errors';\nimport {Type} from '../interface/type';\n\nimport {InjectorProfilerContext, setInjectorProfilerContext} from './debug/injector_profiler';\nimport {getFactoryDef} from './definition_factory';\nimport {NodeInjector, setIncludeViewProviders} from './di';\nimport {store, ɵɵdirectiveInject} from './instructions/all';\nimport {isHostComponentStandalone} from './instructions/element_validation';\nimport {PipeDef, PipeDefList} from './interfaces/definition';\nimport {TTextNode} from './interfaces/node';\nimport {CONTEXT, DECLARATION_COMPONENT_VIEW, HEADER_OFFSET, LView, TVIEW} from './interfaces/view';\nimport {pureFunction1Internal, pureFunction2Internal, pureFunction3Internal, pureFunction4Internal, pureFunctionVInternal} from './pure_function';\nimport {getBindingRoot, getCurrentTNode, getLView, getTView} from './state';\nimport {load} from './util/view_utils';\n\n\n\n/**\n * Create a pipe.\n *\n * @param index Pipe index where the pipe will be stored.\n * @param pipeName The name of the pipe\n * @returns T the instance of the pipe.\n *\n * @codeGenApi\n */\nexport function ɵɵpipe(index: number, pipeName: string): any {\n  const tView = getTView();\n  let pipeDef: PipeDef<any>;\n  const adjustedIndex = index + HEADER_OFFSET;\n\n  if (tView.firstCreatePass) {\n    // The `getPipeDef` throws if a pipe with a given name is not found\n    // (so we use non-null assertion below).\n    pipeDef = getPipeDef(pipeName, tView.pipeRegistry)!;\n    tView.data[adjustedIndex] = pipeDef;\n    if (pipeDef.onDestroy) {\n      (tView.destroyHooks ??= []).push(adjustedIndex, pipeDef.onDestroy);\n    }\n  } else {\n    pipeDef = tView.data[adjustedIndex] as PipeDef<any>;\n  }\n\n  const pipeFactory = pipeDef.factory || (pipeDef.factory = getFactoryDef(pipeDef.type, true));\n\n  let previousInjectorProfilerContext: InjectorProfilerContext;\n  if (ngDevMode) {\n    previousInjectorProfilerContext = setInjectorProfilerContext({\n      injector: new NodeInjector(getCurrentTNode() as TTextNode, getLView()),\n      token: pipeDef.type\n    });\n  }\n  const previousInjectImplementation = setInjectImplementation(ɵɵdirectiveInject);\n  try {\n    // DI for pipes is supposed to behave like directives when placed on a component\n    // host node, which means that we have to disable access to `viewProviders`.\n    const previousIncludeViewProviders = setIncludeViewProviders(false);\n    const pipeInstance = pipeFactory();\n    setIncludeViewProviders(previousIncludeViewProviders);\n    store(tView, getLView(), adjustedIndex, pipeInstance);\n    return pipeInstance;\n  } finally {\n    // we have to restore the injector implementation in finally, just in case the creation of the\n    // pipe throws an error.\n    setInjectImplementation(previousInjectImplementation);\n    ngDevMode && setInjectorProfilerContext(previousInjectorProfilerContext!);\n  }\n}\n\n/**\n * Searches the pipe registry for a pipe with the given name. If one is found,\n * returns the pipe. Otherwise, an error is thrown because the pipe cannot be resolved.\n *\n * @param name Name of pipe to resolve\n * @param registry Full list of available pipes\n * @returns Matching PipeDef\n */\nfunction getPipeDef(name: string, registry: PipeDefList|null): PipeDef<any>|undefined {\n  if (registry) {\n    if (ngDevMode) {\n      const pipes = registry.filter(pipe => pipe.name === name);\n      // TODO: Throw an error in the next major\n      if (pipes.length > 1) {\n        console.warn(formatRuntimeError(\n            RuntimeErrorCode.MULTIPLE_MATCHING_PIPES, getMultipleMatchingPipesMessage(name)));\n      }\n    }\n    for (let i = registry.length - 1; i >= 0; i--) {\n      const pipeDef = registry[i];\n      if (name === pipeDef.name) {\n        return pipeDef;\n      }\n    }\n  }\n  if (ngDevMode) {\n    throw new RuntimeError(RuntimeErrorCode.PIPE_NOT_FOUND, getPipeNotFoundErrorMessage(name));\n  }\n  return;\n}\n\n/**\n * Generates a helpful error message for the user when multiple pipes match the name.\n *\n * @param name Name of the pipe\n * @returns The error message\n */\nfunction getMultipleMatchingPipesMessage(name: string) {\n  const lView = getLView();\n  const declarationLView = lView[DECLARATION_COMPONENT_VIEW] as LView<Type<unknown>>;\n  const context = declarationLView[CONTEXT];\n  const hostIsStandalone = isHostComponentStandalone(lView);\n  const componentInfoMessage = context ? ` in the '${context.constructor.name}' component` : '';\n  const verifyMessage = `check ${\n      hostIsStandalone ? '\\'@Component.imports\\' of this component' :\n                         'the imports of this module'}`;\n  const errorMessage =\n      `Multiple pipes match the name \\`${name}\\`${componentInfoMessage}. ${verifyMessage}`;\n  return errorMessage;\n}\n\n/**\n * Generates a helpful error message for the user when a pipe is not found.\n *\n * @param name Name of the missing pipe\n * @returns The error message\n */\nfunction getPipeNotFoundErrorMessage(name: string) {\n  const lView = getLView();\n  const declarationLView = lView[DECLARATION_COMPONENT_VIEW] as LView<Type<unknown>>;\n  const context = declarationLView[CONTEXT];\n  const hostIsStandalone = isHostComponentStandalone(lView);\n  const componentInfoMessage = context ? ` in the '${context.constructor.name}' component` : '';\n  const verifyMessage = `Verify that it is ${\n      hostIsStandalone ? 'included in the \\'@Component.imports\\' of this component' :\n                         'declared or imported in this module'}`;\n  const errorMessage =\n      `The pipe '${name}' could not be found${componentInfoMessage}. ${verifyMessage}`;\n  return errorMessage;\n}\n\n/**\n * Invokes a pipe with 1 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param offset the binding offset\n * @param v1 1st argument to {@link PipeTransform#transform}.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBind1(index: number, offset: number, v1: any): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ?\n      pureFunction1Internal(\n          lView, getBindingRoot(), offset, pipeInstance.transform, v1, pipeInstance) :\n      pipeInstance.transform(v1);\n}\n\n/**\n * Invokes a pipe with 2 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param slotOffset the offset in the reserved slot space\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBind2(index: number, slotOffset: number, v1: any, v2: any): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ?\n      pureFunction2Internal(\n          lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, pipeInstance) :\n      pipeInstance.transform(v1, v2);\n}\n\n/**\n * Invokes a pipe with 3 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param slotOffset the offset in the reserved slot space\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n * @param v3 4rd argument to {@link PipeTransform#transform}.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBind3(index: number, slotOffset: number, v1: any, v2: any, v3: any): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ?\n      pureFunction3Internal(\n          lView, getBindingRoot(), slotOffset, pipeInstance.transform, v1, v2, v3, pipeInstance) :\n      pipeInstance.transform(v1, v2, v3);\n}\n\n/**\n * Invokes a pipe with 4 arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param slotOffset the offset in the reserved slot space\n * @param v1 1st argument to {@link PipeTransform#transform}.\n * @param v2 2nd argument to {@link PipeTransform#transform}.\n * @param v3 3rd argument to {@link PipeTransform#transform}.\n * @param v4 4th argument to {@link PipeTransform#transform}.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBind4(\n    index: number, slotOffset: number, v1: any, v2: any, v3: any, v4: any): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ? pureFunction4Internal(\n                                            lView, getBindingRoot(), slotOffset,\n                                            pipeInstance.transform, v1, v2, v3, v4, pipeInstance) :\n                                        pipeInstance.transform(v1, v2, v3, v4);\n}\n\n/**\n * Invokes a pipe with variable number of arguments.\n *\n * This instruction acts as a guard to {@link PipeTransform#transform} invoking\n * the pipe only when an input to the pipe changes.\n *\n * @param index Pipe index where the pipe was stored on creation.\n * @param slotOffset the offset in the reserved slot space\n * @param values Array of arguments to pass to {@link PipeTransform#transform} method.\n *\n * @codeGenApi\n */\nexport function ɵɵpipeBindV(index: number, slotOffset: number, values: [any, ...any[]]): any {\n  const adjustedIndex = index + HEADER_OFFSET;\n  const lView = getLView();\n  const pipeInstance = load<PipeTransform>(lView, adjustedIndex);\n  return isPure(lView, adjustedIndex) ?\n      pureFunctionVInternal(\n          lView, getBindingRoot(), slotOffset, pipeInstance.transform, values, pipeInstance) :\n      pipeInstance.transform.apply(pipeInstance, values);\n}\n\nfunction isPure(lView: LView, index: number): boolean {\n  return (<PipeDef<any>>lView[TVIEW].data[index]).pure;\n}\n"]}