@angular/compiler 17.0.0-rc.0 → 17.0.0-rc.2

package/esm2022/src/template/pipeline/ir/src/handle.mjs

@@ -0,0 +1,13 @@
+/**
+ * @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
+ */
+export class SlotHandle {
+    constructor() {
+        this.slot = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXIvc3JjL3RlbXBsYXRlL3BpcGVsaW5lL2lyL3NyYy9oYW5kbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsTUFBTSxPQUFPLFVBQVU7SUFBdkI7UUFDRSxTQUFJLEdBQWdCLElBQUksQ0FBQztJQUMzQixDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IGNsYXNzIFNsb3RIYW5kbGUge1xuICBzbG90OiBudW1iZXJ8bnVsbCA9IG51bGw7XG59XG4iXX0=

package/esm2022/src/template/pipeline/ir/src/ops/create.mjs

@@ -6,16 +6,17 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import * as o from '../../../../../output/output_ast';
-import { OpKind } from '../enums';
+import { Namespace, OpKind } from '../enums';
+import { SlotHandle } from '../handle';
 import { OpList } from '../operations';
-import { TRAIT_CONSUMES_SLOT, TRAIT_HAS_CONST, TRAIT_USES_SLOT_INDEX } from '../traits';
+import { TRAIT_CONSUMES_SLOT } from '../traits';
 import { NEW_OP } from './shared';
 /**
  * The set of OpKinds that represent the creation of an element or container
  */
 const elementContainerOpKinds = new Set([
     OpKind.Element, OpKind.ElementStart, OpKind.Container, OpKind.ContainerStart, OpKind.Template,
-    OpKind.Projection
+    OpKind.RepeaterCreate
 ]);
 /**
  * Checks whether the given operation represents the creation of an element or container.
@@ -31,6 +32,7 @@ export function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sour
         kind: OpKind.ElementStart,
         xref,
         tag,
+        handle: new SlotHandle(),
         attributes: null,
         localRefs: [],
         nonBindable: false,
@@ -44,13 +46,14 @@ export function createElementStartOp(tag, xref, namespace, i18nPlaceholder, sour
 /**
  * Create a `TemplateOp`.
  */
-export function createTemplateOp(xref, tag, namespace, generatedInBlock, i18nPlaceholder, sourceSpan) {
+export function createTemplateOp(xref, tag, functionNameSuffix, namespace, i18nPlaceholder, sourceSpan) {
     return {
         kind: OpKind.Template,
         xref,
         attributes: null,
         tag,
-        block: generatedInBlock,
+        handle: new SlotHandle(),
+        functionNameSuffix,
         decls: null,
         vars: null,
         localRefs: [],
@@ -62,6 +65,30 @@ export function createTemplateOp(xref, tag, namespace, generatedInBlock, i18nPla
         ...NEW_OP,
     };
 }
+export function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, sourceSpan) {
+    return {
+        kind: OpKind.RepeaterCreate,
+        attributes: null,
+        xref: primaryView,
+        handle: new SlotHandle(),
+        emptyView,
+        track,
+        trackByFn: null,
+        tag,
+        functionNameSuffix: 'For',
+        namespace: Namespace.HTML,
+        nonBindable: false,
+        localRefs: [],
+        decls: null,
+        vars: null,
+        varNames,
+        usesComponentInstance: false,
+        sourceSpan,
+        ...TRAIT_CONSUMES_SLOT,
+        ...NEW_OP,
+        numSlotsUsed: emptyView === null ? 2 : 3,
+    };
+}
 /**
  * Create an `ElementEndOp`.
  */
@@ -94,6 +121,7 @@ export function createTextOp(xref, initialValue, sourceSpan) {
     return {
         kind: OpKind.Text,
         xref,
+        handle: new SlotHandle(),
         initialValue,
         sourceSpan,
         ...TRAIT_CONSUMES_SLOT,
@@ -103,10 +131,11 @@ export function createTextOp(xref, initialValue, sourceSpan) {
 /**
  * Create a `ListenerOp`. Host bindings reuse all the listener logic.
  */
-export function createListenerOp(target, name, tag, animationPhase, hostListener, sourceSpan) {
+export function createListenerOp(target, targetSlot, name, tag, animationPhase, hostListener, sourceSpan) {
     return {
         kind: OpKind.Listener,
         target,
+        targetSlot,
         tag,
         hostListener,
         name,
@@ -117,27 +146,18 @@ export function createListenerOp(target, name, tag, animationPhase, hostListener
         animationPhase: animationPhase,
         sourceSpan,
         ...NEW_OP,
-        ...TRAIT_USES_SLOT_INDEX,
     };
 }
-export function createPipeOp(xref, name) {
+export function createPipeOp(xref, slot, name) {
     return {
         kind: OpKind.Pipe,
         xref,
+        handle: slot,
         name,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
 }
-/**
- * Whether the active namespace is HTML, MathML, or SVG mode.
- */
-export var Namespace;
-(function (Namespace) {
-    Namespace[Namespace["HTML"] = 0] = "HTML";
-    Namespace[Namespace["SVG"] = 1] = "SVG";
-    Namespace[Namespace["Math"] = 2] = "Math";
-})(Namespace || (Namespace = {}));
 export function createNamespaceOp(namespace) {
     return {
         kind: OpKind.Namespace,
@@ -152,16 +172,16 @@ export function createProjectionDefOp(def) {
         ...NEW_OP,
     };
 }
-export function createProjectionOp(xref, selector) {
+export function createProjectionOp(xref, selector, sourceSpan) {
     return {
         kind: OpKind.Projection,
         xref,
+        handle: new SlotHandle(),
         selector,
         projectionSlotIndex: 0,
-        attributes: null,
+        attributes: [],
         localRefs: [],
-        nonBindable: false,
-        sourceSpan: null,
+        sourceSpan,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -179,51 +199,54 @@ export function createExtractedAttributeOp(target, bindingKind, name, expression
         ...NEW_OP,
     };
 }
-export function createDeferOp(xref, main, sourceSpan) {
+export function createDeferOp(xref, main, mainSlot, sourceSpan) {
     return {
         kind: OpKind.Defer,
         xref,
-        target: main,
-        loading: null,
-        placeholder: null,
-        error: null,
+        handle: new SlotHandle(),
+        mainView: main,
+        mainSlot,
+        loadingView: null,
+        loadingSlot: null,
+        loadingConfig: null,
+        loadingMinimumTime: null,
+        loadingAfterTime: null,
+        placeholderView: null,
+        placeholderSlot: null,
+        placeholderConfig: null,
+        placeholderMinimumTime: null,
+        errorView: null,
+        errorSlot: null,
         sourceSpan,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
-        ...TRAIT_USES_SLOT_INDEX,
-    };
-}
-export function createDeferSecondaryOp(deferOp, secondaryView, secondaryBlockKind) {
-    return {
-        kind: OpKind.DeferSecondaryBlock,
-        deferOp,
-        target: secondaryView,
-        secondaryBlockKind,
-        constValue: null,
-        makeExpression: literalOrArrayLiteral,
-        ...NEW_OP,
-        ...TRAIT_USES_SLOT_INDEX,
-        ...TRAIT_HAS_CONST,
+        numSlotsUsed: 2,
     };
 }
-export function createDeferOnOp(xref, sourceSpan) {
+export function createDeferOnOp(defer, trigger, prefetch, sourceSpan) {
     return {
         kind: OpKind.DeferOn,
-        xref,
+        defer,
+        trigger,
+        prefetch,
         sourceSpan,
         ...NEW_OP,
-        ...TRAIT_CONSUMES_SLOT,
     };
 }
 /**
  * Create an `ExtractedMessageOp`.
  */
-export function createExtractedMessageOp(owner, expression, statements) {
+export function createExtractedMessageOp(owner, message, isRoot) {
     return {
         kind: OpKind.ExtractedMessage,
         owner,
-        expression,
-        statements,
+        message,
+        isRoot,
+        params: new Map(),
+        postprocessingParams: new Map(),
+        needsPostprocessing: false,
+        formattedParams: null,
+        formattedPostprocessingParams: null,
         ...NEW_OP,
     };
 }
@@ -234,13 +257,11 @@ export function createI18nStartOp(xref, message, root) {
     return {
         kind: OpKind.I18nStart,
         xref,
+        handle: new SlotHandle(),
         root: root ?? xref,
         message,
-        params: new Map(),
-        postprocessingParams: new Map(),
         messageIndex: null,
         subTemplateIndex: null,
-        needsPostprocessing: false,
         ...NEW_OP,
         ...TRAIT_CONSUMES_SLOT,
     };
@@ -273,4 +294,4 @@ export function literalOrArrayLiteral(value) {
     }
     return o.literal(value, o.INFERRED_TYPE);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/compiler/src/template/pipeline/ir/src/ops/create.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 * as i18n from '../../../../../i18n/i18n_ast';\nimport * as o from '../../../../../output/output_ast';\nimport {ParseSourceSpan} from '../../../../../parse_util';\nimport {BindingKind, DeferSecondaryKind, OpKind} from '../enums';\nimport {Op, OpList, XrefId} from '../operations';\nimport {ConsumesSlotOpTrait, HasConstTrait, TRAIT_CONSUMES_SLOT, TRAIT_HAS_CONST, TRAIT_USES_SLOT_INDEX, UsesSlotIndexTrait} from '../traits';\n\nimport {ListEndOp, NEW_OP, StatementOp, VariableOp} from './shared';\n\nimport type {UpdateOp} from './update';\n\n/**\n * An operation usable on the creation side of the IR.\n */\nexport type CreateOp =\n    ListEndOp<CreateOp>|StatementOp<CreateOp>|ElementOp|ElementStartOp|ElementEndOp|ContainerOp|\n    ContainerStartOp|ContainerEndOp|TemplateOp|EnableBindingsOp|DisableBindingsOp|TextOp|ListenerOp|\n    PipeOp|VariableOp<CreateOp>|NamespaceOp|ProjectionDefOp|ProjectionOp|ExtractedAttributeOp|\n    DeferOp|DeferSecondaryBlockOp|DeferOnOp|ExtractedMessageOp|I18nOp|I18nStartOp|I18nEndOp|IcuOp;\n\n/**\n * An operation representing the creation of an element or container.\n */\nexport type ElementOrContainerOps =\n    ElementOp|ElementStartOp|ContainerOp|ContainerStartOp|TemplateOp|ProjectionOp;\n\n/**\n * The set of OpKinds that represent the creation of an element or container\n */\nconst elementContainerOpKinds = new Set([\n  OpKind.Element, OpKind.ElementStart, OpKind.Container, OpKind.ContainerStart, OpKind.Template,\n  OpKind.Projection\n]);\n\n/**\n * Checks whether the given operation represents the creation of an element or container.\n */\nexport function isElementOrContainerOp(op: CreateOp): op is ElementOrContainerOps {\n  return elementContainerOpKinds.has(op.kind);\n}\n\n/**\n * Representation of a local reference on an element.\n */\nexport interface LocalRef {\n  /**\n   * User-defined name of the local ref variable.\n   */\n  name: string;\n\n  /**\n   * Target of the local reference variable (often `''`).\n   */\n  target: string;\n}\n\n/**\n * Base interface for `Element`, `ElementStart`, and `Template` operations, containing common fields\n * used to represent their element-like nature.\n */\nexport interface ElementOrContainerOpBase extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: ElementOrContainerOps['kind'];\n\n  /**\n   * `XrefId` allocated for this element.\n   *\n   * This ID is used to reference this element from other IR structures.\n   */\n  xref: XrefId;\n\n  /**\n   * Attributes of various kinds on this element. Represented as a `ConstIndex` pointer into the\n   * shared `consts` array of the component compilation.\n   */\n  attributes: ConstIndex|null;\n\n  /**\n   * Local references to this element.\n   *\n   * Before local ref processing, this is an array of `LocalRef` declarations.\n   *\n   * After processing, it's a `ConstIndex` pointer into the shared `consts` array of the component\n   * compilation.\n   */\n  localRefs: LocalRef[]|ConstIndex|null;\n\n  /**\n   * Whether this container is marked `ngNonBindable`, which disabled Angular binding for itself and\n   * all descendants.\n   */\n  nonBindable: boolean;\n\n  sourceSpan: ParseSourceSpan;\n}\n\nexport interface ElementOpBase extends ElementOrContainerOpBase {\n  kind: OpKind.Element|OpKind.ElementStart|OpKind.Template;\n\n  /**\n   * The HTML tag name for this element.\n   */\n  tag: string|null;\n\n  /**\n   * The namespace of this element, which controls the preceding namespace instruction.\n   */\n  namespace: Namespace;\n}\n\n/**\n * Logical operation representing the start of an element in the creation IR.\n */\nexport interface ElementStartOp extends ElementOpBase {\n  kind: OpKind.ElementStart;\n\n  /**\n   * The i18n placeholder data associated with this element.\n   */\n  i18nPlaceholder?: i18n.TagPlaceholder;\n}\n\n/**\n * Create an `ElementStartOp`.\n */\nexport function createElementStartOp(\n    tag: string, xref: XrefId, namespace: Namespace, i18nPlaceholder: i18n.TagPlaceholder|undefined,\n    sourceSpan: ParseSourceSpan): ElementStartOp {\n  return {\n    kind: OpKind.ElementStart,\n    xref,\n    tag,\n    attributes: null,\n    localRefs: [],\n    nonBindable: false,\n    namespace,\n    i18nPlaceholder,\n    sourceSpan,\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing an element with no children in the creation IR.\n */\nexport interface ElementOp extends ElementOpBase {\n  kind: OpKind.Element;\n\n  /**\n   * The i18n placeholder data associated with this element.\n   */\n  i18nPlaceholder?: i18n.TagPlaceholder;\n}\n\n/**\n * Logical operation representing an embedded view declaration in the creation IR.\n */\nexport interface TemplateOp extends ElementOpBase {\n  kind: OpKind.Template;\n\n  /**\n   * The number of declaration slots used by this template, or `null` if slots have not yet been\n   * assigned.\n   */\n  decls: number|null;\n\n  /**\n   * The number of binding variable slots used by this template, or `null` if binding variables have\n   * not yet been counted.\n   */\n  vars: number|null;\n\n  /**\n   * Whether or not this template was automatically created for use with block syntax (control flow\n   * or defer). This will eventually cause the emitted template instruction to use fewer arguments,\n   * since several of the default arguments are unnecessary for blocks.\n   */\n  block: boolean;\n\n  /**\n   * The i18n placeholder data associated with this template.\n   */\n  i18nPlaceholder?: i18n.TagPlaceholder;\n}\n\n/**\n * Create a `TemplateOp`.\n */\nexport function createTemplateOp(\n    xref: XrefId, tag: string|null, namespace: Namespace, generatedInBlock: boolean,\n    i18nPlaceholder: i18n.TagPlaceholder|undefined, sourceSpan: ParseSourceSpan): TemplateOp {\n  return {\n    kind: OpKind.Template,\n    xref,\n    attributes: null,\n    tag,\n    block: generatedInBlock,\n    decls: null,\n    vars: null,\n    localRefs: [],\n    nonBindable: false,\n    namespace,\n    i18nPlaceholder,\n    sourceSpan,\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing the end of an element structure in the creation IR.\n *\n * Pairs with an `ElementStart` operation.\n */\nexport interface ElementEndOp extends Op<CreateOp> {\n  kind: OpKind.ElementEnd;\n\n  /**\n   * The `XrefId` of the element declared via `ElementStart`.\n   */\n  xref: XrefId;\n\n  sourceSpan: ParseSourceSpan|null;\n}\n\n/**\n * Create an `ElementEndOp`.\n */\nexport function createElementEndOp(xref: XrefId, sourceSpan: ParseSourceSpan|null): ElementEndOp {\n  return {\n    kind: OpKind.ElementEnd,\n    xref,\n    sourceSpan,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing the start of a container in the creation IR.\n */\nexport interface ContainerStartOp extends ElementOrContainerOpBase {\n  kind: OpKind.ContainerStart;\n}\n\n/**\n * Logical operation representing an empty container in the creation IR.\n */\nexport interface ContainerOp extends ElementOrContainerOpBase {\n  kind: OpKind.Container;\n}\n\n/**\n * Logical operation representing the end of a container structure in the creation IR.\n *\n * Pairs with an `ContainerStart` operation.\n */\nexport interface ContainerEndOp extends Op<CreateOp> {\n  kind: OpKind.ContainerEnd;\n\n  /**\n   * The `XrefId` of the element declared via `ContainerStart`.\n   */\n  xref: XrefId;\n\n  sourceSpan: ParseSourceSpan;\n}\n\n/**\n * Logical operation causing binding to be disabled in descendents of a non-bindable container.\n */\nexport interface DisableBindingsOp extends Op<CreateOp> {\n  kind: OpKind.DisableBindings;\n\n  /**\n   * `XrefId` of the element that was marked non-bindable.\n   */\n  xref: XrefId;\n}\n\nexport function createDisableBindingsOp(xref: XrefId): DisableBindingsOp {\n  return {\n    kind: OpKind.DisableBindings,\n    xref,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation causing binding to be re-enabled after visiting descendants of a\n * non-bindable container.\n */\nexport interface EnableBindingsOp extends Op<CreateOp> {\n  kind: OpKind.EnableBindings;\n\n  /**\n   * `XrefId` of the element that was marked non-bindable.\n   */\n  xref: XrefId;\n}\n\nexport function createEnableBindingsOp(xref: XrefId): EnableBindingsOp {\n  return {\n    kind: OpKind.EnableBindings,\n    xref,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing a text node in the creation IR.\n */\nexport interface TextOp extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.Text;\n\n  /**\n   * `XrefId` used to reference this text node in other IR structures.\n   */\n  xref: XrefId;\n\n  /**\n   * The static initial value of the text node.\n   */\n  initialValue: string;\n\n  sourceSpan: ParseSourceSpan|null;\n}\n\n/**\n * Create a `TextOp`.\n */\nexport function createTextOp(\n    xref: XrefId, initialValue: string, sourceSpan: ParseSourceSpan|null): TextOp {\n  return {\n    kind: OpKind.Text,\n    xref,\n    initialValue,\n    sourceSpan,\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing an event listener on an element in the creation IR.\n */\nexport interface ListenerOp extends Op<CreateOp>, UsesSlotIndexTrait {\n  kind: OpKind.Listener;\n\n  /**\n   * Whether this listener is from a host binding.\n   */\n  hostListener: boolean;\n\n  /**\n   * Name of the event which is being listened to.\n   */\n  name: string;\n\n  /**\n   * Tag name of the element on which this listener is placed. Might be null, if this listener\n   * belongs to a host binding.\n   */\n  tag: string|null;\n\n  /**\n   * A list of `UpdateOp`s representing the body of the event listener.\n   */\n  handlerOps: OpList<UpdateOp>;\n\n  /**\n   * Name of the function\n   */\n  handlerFnName: string|null;\n\n  /**\n   * Whether this listener is known to consume `$event` in its body.\n   */\n  consumesDollarEvent: boolean;\n\n  /**\n   * Whether the listener is listening for an animation event.\n   */\n  isAnimationListener: boolean;\n\n  /**\n   * The animation phase of the listener.\n   */\n  animationPhase: string|null;\n\n  sourceSpan: ParseSourceSpan;\n}\n\n/**\n * Create a `ListenerOp`. Host bindings reuse all the listener logic.\n */\nexport function createListenerOp(\n    target: XrefId, name: string, tag: string|null, animationPhase: string|null,\n    hostListener: boolean, sourceSpan: ParseSourceSpan): ListenerOp {\n  return {\n    kind: OpKind.Listener,\n    target,\n    tag,\n    hostListener,\n    name,\n    handlerOps: new OpList(),\n    handlerFnName: null,\n    consumesDollarEvent: false,\n    isAnimationListener: animationPhase !== null,\n    animationPhase: animationPhase,\n    sourceSpan,\n    ...NEW_OP,\n    ...TRAIT_USES_SLOT_INDEX,\n  };\n}\n\nexport interface PipeOp extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.Pipe;\n  xref: XrefId;\n  name: string;\n}\n\nexport function createPipeOp(xref: XrefId, name: string): PipeOp {\n  return {\n    kind: OpKind.Pipe,\n    xref,\n    name,\n    ...NEW_OP,\n    ...TRAIT_CONSUMES_SLOT,\n  };\n}\n\n/**\n * Whether the active namespace is HTML, MathML, or SVG mode.\n */\nexport enum Namespace {\n  HTML,\n  SVG,\n  Math,\n}\n\n/**\n * An op corresponding to a namespace instruction, for switching between HTML, SVG, and MathML.\n */\nexport interface NamespaceOp extends Op<CreateOp> {\n  kind: OpKind.Namespace;\n  active: Namespace;\n}\n\nexport function createNamespaceOp(namespace: Namespace): NamespaceOp {\n  return {\n    kind: OpKind.Namespace,\n    active: namespace,\n    ...NEW_OP,\n  };\n}\n\n/**\n * An op that creates a content projection slot.\n */\nexport interface ProjectionDefOp extends Op<CreateOp> {\n  kind: OpKind.ProjectionDef;\n\n  // The parsed selector information for this projection def.\n  def: o.Expression|null;\n}\n\nexport function createProjectionDefOp(def: o.Expression|null): ProjectionDefOp {\n  return {\n    kind: OpKind.ProjectionDef,\n    def,\n    ...NEW_OP,\n  };\n}\n\n/**\n * An op that creates a content projection slot.\n */\nexport interface ProjectionOp extends Op<CreateOp>, ConsumesSlotOpTrait, ElementOrContainerOpBase {\n  kind: OpKind.Projection;\n\n  xref: XrefId;\n\n  slot: number|null;\n\n  projectionSlotIndex: number;\n\n  selector: string;\n}\n\nexport function createProjectionOp(xref: XrefId, selector: string): ProjectionOp {\n  return {\n    kind: OpKind.Projection,\n    xref,\n    selector,\n    projectionSlotIndex: 0,\n    attributes: null,\n    localRefs: [],\n    nonBindable: false,\n    sourceSpan: null!,  // TODO\n    ...NEW_OP,\n    ...TRAIT_CONSUMES_SLOT,\n  };\n}\n\n/**\n * Represents an attribute that has been extracted for inclusion in the consts array.\n */\nexport interface ExtractedAttributeOp extends Op<CreateOp> {\n  kind: OpKind.ExtractedAttribute;\n\n  /**\n   * The `XrefId` of the template-like element the extracted attribute will belong to.\n   */\n  target: XrefId;\n\n  /**\n   *  The kind of binding represented by this extracted attribute.\n   */\n  bindingKind: BindingKind;\n\n  /**\n   * The name of the extracted attribute.\n   */\n  name: string;\n\n  /**\n   * The value expression of the extracted attribute.\n   */\n  expression: o.Expression|null;\n}\n\n/**\n * Create an `ExtractedAttributeOp`.\n */\nexport function createExtractedAttributeOp(\n    target: XrefId, bindingKind: BindingKind, name: string,\n    expression: o.Expression|null): ExtractedAttributeOp {\n  return {\n    kind: OpKind.ExtractedAttribute,\n    target,\n    bindingKind,\n    name,\n    expression,\n    ...NEW_OP,\n  };\n}\n\nexport interface DeferOp extends Op<CreateOp>, ConsumesSlotOpTrait, UsesSlotIndexTrait {\n  kind: OpKind.Defer;\n\n  /**\n   * The xref of this defer op.\n   */\n  xref: XrefId;\n\n  /**\n   * The xref of the main view. This will be associated with `slot`.\n   */\n  target: XrefId;\n\n  /**\n   * Secondary loading block associated with this defer op.\n   */\n  loading: DeferSecondaryBlockOp|null;\n\n  /**\n   * Secondary placeholder block associated with this defer op.\n   */\n  placeholder: DeferSecondaryBlockOp|null;\n\n  /**\n   * Secondary error block associated with this defer op.\n   */\n  error: DeferSecondaryBlockOp|null;\n\n  sourceSpan: ParseSourceSpan;\n}\n\nexport function createDeferOp(xref: XrefId, main: XrefId, sourceSpan: ParseSourceSpan): DeferOp {\n  return {\n    kind: OpKind.Defer,\n    xref,\n    target: main,\n    loading: null,\n    placeholder: null,\n    error: null,\n    sourceSpan,\n    ...NEW_OP,\n    ...TRAIT_CONSUMES_SLOT,\n    ...TRAIT_USES_SLOT_INDEX,\n  };\n}\n\nexport interface DeferSecondaryBlockOp extends Op<CreateOp>, UsesSlotIndexTrait, HasConstTrait {\n  kind: OpKind.DeferSecondaryBlock;\n\n  /**\n   * The xref of the corresponding defer op.\n   */\n  deferOp: XrefId;\n\n  /**\n   * Which kind of secondary block this op represents.\n   */\n  secondaryBlockKind: DeferSecondaryKind;\n\n  /**\n   * The xref of the secondary view. This will be associated with `slot`.\n   */\n  target: XrefId;\n}\n\nexport function createDeferSecondaryOp(\n    deferOp: XrefId, secondaryView: XrefId,\n    secondaryBlockKind: DeferSecondaryKind): DeferSecondaryBlockOp {\n  return {\n    kind: OpKind.DeferSecondaryBlock,\n    deferOp,\n    target: secondaryView,\n    secondaryBlockKind,\n    constValue: null,\n    makeExpression: literalOrArrayLiteral,\n    ...NEW_OP,\n    ...TRAIT_USES_SLOT_INDEX,\n    ...TRAIT_HAS_CONST,\n  };\n}\n\nexport interface DeferOnOp extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.DeferOn;\n\n  sourceSpan: ParseSourceSpan;\n}\n\nexport function createDeferOnOp(xref: XrefId, sourceSpan: ParseSourceSpan): DeferOnOp {\n  return {\n    kind: OpKind.DeferOn,\n    xref,\n    sourceSpan,\n    ...NEW_OP,\n    ...TRAIT_CONSUMES_SLOT,\n  };\n}\n\n/**\n * Represents an i18n message that has been extracted for inclusion in the consts array.\n */\nexport interface ExtractedMessageOp extends Op<CreateOp> {\n  kind: OpKind.ExtractedMessage;\n\n  /**\n   * A reference to the i18n op this message was extracted from.\n   */\n  owner: XrefId;\n\n  /**\n   * The message expression.\n   */\n  expression: o.Expression;\n\n  /**\n   * The statements to construct the message.\n   */\n  statements: o.Statement[];\n}\n\n/**\n * Create an `ExtractedMessageOp`.\n */\nexport function createExtractedMessageOp(\n    owner: XrefId, expression: o.Expression, statements: o.Statement[]): ExtractedMessageOp {\n  return {\n    kind: OpKind.ExtractedMessage,\n    owner,\n    expression,\n    statements,\n    ...NEW_OP,\n  };\n}\n\nexport interface I18nOpBase extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.I18nStart|OpKind.I18n;\n\n  /**\n   * `XrefId` allocated for this i18n block.\n   */\n  xref: XrefId;\n\n  /**\n   * A reference to the root i18n block that this one belongs to. For a a root i18n block, this is\n   * the same as xref.\n   */\n  root: XrefId;\n\n  /**\n   * The i18n metadata associated with this op.\n   */\n  message: i18n.Message;\n\n  /**\n   * Map of values to use for named placeholders in the i18n message. (Resolved at message creation)\n   */\n  params: Map<string, o.Expression>;\n\n  /**\n   * Map of values to use for named placeholders in the i18n message. (Resolved during\n   * post-porcessing)\n   */\n  postprocessingParams: Map<string, o.Expression>;\n\n  /**\n   * The index in the consts array where the message i18n message is stored.\n   */\n  messageIndex: ConstIndex|null;\n\n  /**\n   * The index of this sub-block in the i18n message. For a root i18n block, this is null.\n   */\n  subTemplateIndex: number|null;\n\n  /**\n   * Whether the i18n message requires postprocessing.\n   */\n  needsPostprocessing: boolean;\n}\n\n/**\n * Represents an empty i18n block.\n */\nexport interface I18nOp extends I18nOpBase {\n  kind: OpKind.I18n;\n}\n\n/**\n * Represents the start of an i18n block.\n */\nexport interface I18nStartOp extends I18nOpBase {\n  kind: OpKind.I18nStart;\n}\n\n/**\n * Create an `I18nStartOp`.\n */\nexport function createI18nStartOp(xref: XrefId, message: i18n.Message, root?: XrefId): I18nStartOp {\n  return {\n    kind: OpKind.I18nStart,\n    xref,\n    root: root ?? xref,\n    message,\n    params: new Map(),\n    postprocessingParams: new Map(),\n    messageIndex: null,\n    subTemplateIndex: null,\n    needsPostprocessing: false,\n    ...NEW_OP,\n    ...TRAIT_CONSUMES_SLOT,\n  };\n}\n\n/**\n * Represents the end of an i18n block.\n */\nexport interface I18nEndOp extends Op<CreateOp> {\n  kind: OpKind.I18nEnd;\n\n  /**\n   * The `XrefId` of the `I18nStartOp` that created this block.\n   */\n  xref: XrefId;\n}\n\n/**\n * Create an `I18nEndOp`.\n */\nexport function createI18nEndOp(xref: XrefId): I18nEndOp {\n  return {\n    kind: OpKind.I18nEnd,\n    xref,\n    ...NEW_OP,\n  };\n}\n\n/**\n * An op that represents an ICU expression.\n */\nexport interface IcuOp extends Op<CreateOp> {\n  kind: OpKind.Icu;\n\n  /**\n   * The ID of the ICU.\n   */\n  xref: XrefId;\n\n  /**\n   * The i18n message for this ICU.\n   */\n  message: i18n.Message;\n\n  sourceSpan: ParseSourceSpan;\n}\n\n/**\n * Creates an op to create an ICU expression.\n */\nexport function createIcuOp(\n    xref: XrefId, message: i18n.Message, sourceSpan: ParseSourceSpan): IcuOp {\n  return {\n    kind: OpKind.Icu,\n    xref,\n    message,\n    sourceSpan,\n    ...NEW_OP,\n  };\n}\n\n\n/**\n * An index into the `consts` array which is shared across the compilation of all views in a\n * component.\n */\nexport type ConstIndex = number&{__brand: 'ConstIndex'};\n\nexport function literalOrArrayLiteral(value: any): o.Expression {\n  if (Array.isArray(value)) {\n    return o.literalArr(value.map(literalOrArrayLiteral));\n  }\n  return o.literal(value, o.INFERRED_TYPE);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create.js","sourceRoot":"","sources":["../../../../../../../../../../../packages/compiler/src/template/pipeline/ir/src/ops/create.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 * as i18n from '../../../../../i18n/i18n_ast';\nimport * as o from '../../../../../output/output_ast';\nimport {ParseSourceSpan} from '../../../../../parse_util';\nimport {BindingKind, DeferTriggerKind, I18nParamValueFlags, Namespace, OpKind} from '../enums';\nimport {SlotHandle} from '../handle';\nimport {Op, OpList, XrefId} from '../operations';\nimport {ConsumesSlotOpTrait, TRAIT_CONSUMES_SLOT} from '../traits';\n\nimport {ListEndOp, NEW_OP, StatementOp, VariableOp} from './shared';\n\nimport type {UpdateOp} from './update';\n\n/**\n * An operation usable on the creation side of the IR.\n */\nexport type CreateOp =\n    ListEndOp<CreateOp>|StatementOp<CreateOp>|ElementOp|ElementStartOp|ElementEndOp|ContainerOp|\n    ContainerStartOp|ContainerEndOp|TemplateOp|EnableBindingsOp|DisableBindingsOp|TextOp|ListenerOp|\n    PipeOp|VariableOp<CreateOp>|NamespaceOp|ProjectionDefOp|ProjectionOp|ExtractedAttributeOp|\n    DeferOp|DeferOnOp|RepeaterCreateOp|ExtractedMessageOp|I18nOp|I18nStartOp|I18nEndOp|IcuOp;\n\n/**\n * An operation representing the creation of an element or container.\n */\nexport type ElementOrContainerOps =\n    ElementOp|ElementStartOp|ContainerOp|ContainerStartOp|TemplateOp|RepeaterCreateOp;\n\n/**\n * The set of OpKinds that represent the creation of an element or container\n */\nconst elementContainerOpKinds = new Set([\n  OpKind.Element, OpKind.ElementStart, OpKind.Container, OpKind.ContainerStart, OpKind.Template,\n  OpKind.RepeaterCreate\n]);\n\n/**\n * Checks whether the given operation represents the creation of an element or container.\n */\nexport function isElementOrContainerOp(op: CreateOp): op is ElementOrContainerOps {\n  return elementContainerOpKinds.has(op.kind);\n}\n\n/**\n * Representation of a local reference on an element.\n */\nexport interface LocalRef {\n  /**\n   * User-defined name of the local ref variable.\n   */\n  name: string;\n\n  /**\n   * Target of the local reference variable (often `''`).\n   */\n  target: string;\n}\n\n/**\n * Base interface for `Element`, `ElementStart`, and `Template` operations, containing common fields\n * used to represent their element-like nature.\n */\nexport interface ElementOrContainerOpBase extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: ElementOrContainerOps['kind'];\n\n  /**\n   * `XrefId` allocated for this element.\n   *\n   * This ID is used to reference this element from other IR structures.\n   */\n  xref: XrefId;\n\n  /**\n   * Attributes of various kinds on this element. Represented as a `ConstIndex` pointer into the\n   * shared `consts` array of the component compilation.\n   */\n  attributes: ConstIndex|null;\n\n  /**\n   * Local references to this element.\n   *\n   * Before local ref processing, this is an array of `LocalRef` declarations.\n   *\n   * After processing, it's a `ConstIndex` pointer into the shared `consts` array of the component\n   * compilation.\n   */\n  localRefs: LocalRef[]|ConstIndex|null;\n\n  /**\n   * Whether this container is marked `ngNonBindable`, which disabled Angular binding for itself and\n   * all descendants.\n   */\n  nonBindable: boolean;\n\n  sourceSpan: ParseSourceSpan;\n}\n\nexport interface ElementOpBase extends ElementOrContainerOpBase {\n  kind: OpKind.Element|OpKind.ElementStart|OpKind.Template|OpKind.RepeaterCreate;\n\n  /**\n   * The HTML tag name for this element.\n   */\n  tag: string|null;\n\n  /**\n   * The namespace of this element, which controls the preceding namespace instruction.\n   */\n  namespace: Namespace;\n}\n\n/**\n * Logical operation representing the start of an element in the creation IR.\n */\nexport interface ElementStartOp extends ElementOpBase {\n  kind: OpKind.ElementStart;\n\n  /**\n   * The i18n placeholder data associated with this element.\n   */\n  i18nPlaceholder?: i18n.TagPlaceholder;\n}\n\n/**\n * Create an `ElementStartOp`.\n */\nexport function createElementStartOp(\n    tag: string, xref: XrefId, namespace: Namespace, i18nPlaceholder: i18n.TagPlaceholder|undefined,\n    sourceSpan: ParseSourceSpan): ElementStartOp {\n  return {\n    kind: OpKind.ElementStart,\n    xref,\n    tag,\n    handle: new SlotHandle(),\n    attributes: null,\n    localRefs: [],\n    nonBindable: false,\n    namespace,\n    i18nPlaceholder,\n    sourceSpan,\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing an element with no children in the creation IR.\n */\nexport interface ElementOp extends ElementOpBase {\n  kind: OpKind.Element;\n\n  /**\n   * The i18n placeholder data associated with this element.\n   */\n  i18nPlaceholder?: i18n.TagPlaceholder;\n}\n\n/**\n * Logical operation representing an embedded view declaration in the creation IR.\n */\nexport interface TemplateOp extends ElementOpBase {\n  kind: OpKind.Template;\n\n  /**\n   * The number of declaration slots used by this template, or `null` if slots have not yet been\n   * assigned.\n   */\n  decls: number|null;\n\n  /**\n   * The number of binding variable slots used by this template, or `null` if binding variables have\n   * not yet been counted.\n   */\n  vars: number|null;\n\n  /**\n   * Suffix to add to the name of the generated template function.\n   */\n  functionNameSuffix: string;\n\n  /**\n   * The i18n placeholder data associated with this template.\n   */\n  i18nPlaceholder?: i18n.TagPlaceholder;\n}\n\n/**\n * Create a `TemplateOp`.\n */\nexport function createTemplateOp(\n    xref: XrefId, tag: string|null, functionNameSuffix: string, namespace: Namespace,\n    i18nPlaceholder: i18n.TagPlaceholder|undefined, sourceSpan: ParseSourceSpan): TemplateOp {\n  return {\n    kind: OpKind.Template,\n    xref,\n    attributes: null,\n    tag,\n    handle: new SlotHandle(),\n    functionNameSuffix,\n    decls: null,\n    vars: null,\n    localRefs: [],\n    nonBindable: false,\n    namespace,\n    i18nPlaceholder,\n    sourceSpan,\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n  };\n}\n\n/**\n * An op that creates a repeater (e.g. a for loop).\n */\nexport interface RepeaterCreateOp extends ElementOpBase {\n  kind: OpKind.RepeaterCreate;\n\n  /**\n   * The number of declaration slots used by this repeater's template, or `null` if slots have not\n   * yet been assigned.\n   */\n  decls: number|null;\n\n  /**\n   * The number of binding variable slots used by this repeater's, or `null` if binding variables\n   * have not yet been counted.\n   */\n  vars: number|null;\n\n  /**\n   * The Xref of the empty view function. (For the primary view function, use the `xref` property).\n   */\n  emptyView: XrefId|null;\n\n  /**\n   * The track expression to use while iterating.\n   */\n  track: o.Expression;\n\n  /**\n   * `null` initially, then an `o.Expression`. Might be a track expression, or might be a reference\n   * into the constant pool.\n   */\n  trackByFn: o.Expression|null;\n\n  /**\n   * Context variables avaialable in this block.\n   */\n  varNames: RepeaterVarNames;\n\n  /**\n   * Whether the repeater track function relies on the component instance.\n   */\n  usesComponentInstance: boolean;\n\n  /**\n   * Suffix to add to the name of the generated template function.\n   */\n  functionNameSuffix: string;\n\n  sourceSpan: ParseSourceSpan;\n}\n\n// TODO: add source spans?\nexport interface RepeaterVarNames {\n  $index: string;\n  $count: string;\n  $first: string;\n  $last: string;\n  $even: string;\n  $odd: string;\n  $implicit: string;\n}\n\nexport function createRepeaterCreateOp(\n    primaryView: XrefId, emptyView: XrefId|null, tag: string|null, track: o.Expression,\n    varNames: RepeaterVarNames, sourceSpan: ParseSourceSpan): RepeaterCreateOp {\n  return {\n    kind: OpKind.RepeaterCreate,\n    attributes: null,\n    xref: primaryView,\n    handle: new SlotHandle(),\n    emptyView,\n    track,\n    trackByFn: null,\n    tag,\n    functionNameSuffix: 'For',\n    namespace: Namespace.HTML,\n    nonBindable: false,\n    localRefs: [],\n    decls: null,\n    vars: null,\n    varNames,\n    usesComponentInstance: false,\n    sourceSpan,\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n    numSlotsUsed: emptyView === null ? 2 : 3,\n  };\n}\n\n/**\n * Logical operation representing the end of an element structure in the creation IR.\n *\n * Pairs with an `ElementStart` operation.\n */\nexport interface ElementEndOp extends Op<CreateOp> {\n  kind: OpKind.ElementEnd;\n\n  /**\n   * The `XrefId` of the element declared via `ElementStart`.\n   */\n  xref: XrefId;\n\n  sourceSpan: ParseSourceSpan|null;\n}\n\n/**\n * Create an `ElementEndOp`.\n */\nexport function createElementEndOp(xref: XrefId, sourceSpan: ParseSourceSpan|null): ElementEndOp {\n  return {\n    kind: OpKind.ElementEnd,\n    xref,\n    sourceSpan,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing the start of a container in the creation IR.\n */\nexport interface ContainerStartOp extends ElementOrContainerOpBase {\n  kind: OpKind.ContainerStart;\n}\n\n/**\n * Logical operation representing an empty container in the creation IR.\n */\nexport interface ContainerOp extends ElementOrContainerOpBase {\n  kind: OpKind.Container;\n}\n\n/**\n * Logical operation representing the end of a container structure in the creation IR.\n *\n * Pairs with an `ContainerStart` operation.\n */\nexport interface ContainerEndOp extends Op<CreateOp> {\n  kind: OpKind.ContainerEnd;\n\n  /**\n   * The `XrefId` of the element declared via `ContainerStart`.\n   */\n  xref: XrefId;\n\n  sourceSpan: ParseSourceSpan;\n}\n\n/**\n * Logical operation causing binding to be disabled in descendents of a non-bindable container.\n */\nexport interface DisableBindingsOp extends Op<CreateOp> {\n  kind: OpKind.DisableBindings;\n\n  /**\n   * `XrefId` of the element that was marked non-bindable.\n   */\n  xref: XrefId;\n}\n\nexport function createDisableBindingsOp(xref: XrefId): DisableBindingsOp {\n  return {\n    kind: OpKind.DisableBindings,\n    xref,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation causing binding to be re-enabled after visiting descendants of a\n * non-bindable container.\n */\nexport interface EnableBindingsOp extends Op<CreateOp> {\n  kind: OpKind.EnableBindings;\n\n  /**\n   * `XrefId` of the element that was marked non-bindable.\n   */\n  xref: XrefId;\n}\n\nexport function createEnableBindingsOp(xref: XrefId): EnableBindingsOp {\n  return {\n    kind: OpKind.EnableBindings,\n    xref,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing a text node in the creation IR.\n */\nexport interface TextOp extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.Text;\n\n  /**\n   * `XrefId` used to reference this text node in other IR structures.\n   */\n  xref: XrefId;\n\n  /**\n   * The static initial value of the text node.\n   */\n  initialValue: string;\n\n  sourceSpan: ParseSourceSpan|null;\n}\n\n/**\n * Create a `TextOp`.\n */\nexport function createTextOp(\n    xref: XrefId, initialValue: string, sourceSpan: ParseSourceSpan|null): TextOp {\n  return {\n    kind: OpKind.Text,\n    xref,\n    handle: new SlotHandle(),\n    initialValue,\n    sourceSpan,\n    ...TRAIT_CONSUMES_SLOT,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Logical operation representing an event listener on an element in the creation IR.\n */\nexport interface ListenerOp extends Op<CreateOp> {\n  kind: OpKind.Listener;\n\n  target: XrefId;\n  targetSlot: SlotHandle;\n\n  /**\n   * Whether this listener is from a host binding.\n   */\n  hostListener: boolean;\n\n  /**\n   * Name of the event which is being listened to.\n   */\n  name: string;\n\n  /**\n   * Tag name of the element on which this listener is placed. Might be null, if this listener\n   * belongs to a host binding.\n   */\n  tag: string|null;\n\n  /**\n   * A list of `UpdateOp`s representing the body of the event listener.\n   */\n  handlerOps: OpList<UpdateOp>;\n\n  /**\n   * Name of the function\n   */\n  handlerFnName: string|null;\n\n  /**\n   * Whether this listener is known to consume `$event` in its body.\n   */\n  consumesDollarEvent: boolean;\n\n  /**\n   * Whether the listener is listening for an animation event.\n   */\n  isAnimationListener: boolean;\n\n  /**\n   * The animation phase of the listener.\n   */\n  animationPhase: string|null;\n\n  sourceSpan: ParseSourceSpan;\n}\n\n/**\n * Create a `ListenerOp`. Host bindings reuse all the listener logic.\n */\nexport function createListenerOp(\n    target: XrefId, targetSlot: SlotHandle, name: string, tag: string|null,\n    animationPhase: string|null, hostListener: boolean, sourceSpan: ParseSourceSpan): ListenerOp {\n  return {\n    kind: OpKind.Listener,\n    target,\n    targetSlot,\n    tag,\n    hostListener,\n    name,\n    handlerOps: new OpList(),\n    handlerFnName: null,\n    consumesDollarEvent: false,\n    isAnimationListener: animationPhase !== null,\n    animationPhase: animationPhase,\n    sourceSpan,\n    ...NEW_OP,\n  };\n}\n\nexport interface PipeOp extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.Pipe;\n  xref: XrefId;\n  name: string;\n}\n\nexport function createPipeOp(xref: XrefId, slot: SlotHandle, name: string): PipeOp {\n  return {\n    kind: OpKind.Pipe,\n    xref,\n    handle: slot,\n    name,\n    ...NEW_OP,\n    ...TRAIT_CONSUMES_SLOT,\n  };\n}\n\n/**\n * An op corresponding to a namespace instruction, for switching between HTML, SVG, and MathML.\n */\nexport interface NamespaceOp extends Op<CreateOp> {\n  kind: OpKind.Namespace;\n  active: Namespace;\n}\n\nexport function createNamespaceOp(namespace: Namespace): NamespaceOp {\n  return {\n    kind: OpKind.Namespace,\n    active: namespace,\n    ...NEW_OP,\n  };\n}\n\n/**\n * An op that creates a content projection slot.\n */\nexport interface ProjectionDefOp extends Op<CreateOp> {\n  kind: OpKind.ProjectionDef;\n\n  // The parsed selector information for this projection def.\n  def: o.Expression|null;\n}\n\nexport function createProjectionDefOp(def: o.Expression|null): ProjectionDefOp {\n  return {\n    kind: OpKind.ProjectionDef,\n    def,\n    ...NEW_OP,\n  };\n}\n\n/**\n * An op that creates a content projection slot.\n */\nexport interface ProjectionOp extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.Projection;\n\n  xref: XrefId;\n\n  projectionSlotIndex: number;\n\n  attributes: string[];\n\n  localRefs: string[];\n\n  selector: string;\n\n  sourceSpan: ParseSourceSpan;\n}\n\nexport function createProjectionOp(\n    xref: XrefId, selector: string, sourceSpan: ParseSourceSpan): ProjectionOp {\n  return {\n    kind: OpKind.Projection,\n    xref,\n    handle: new SlotHandle(),\n    selector,\n    projectionSlotIndex: 0,\n    attributes: [],\n    localRefs: [],\n    sourceSpan,\n    ...NEW_OP,\n    ...TRAIT_CONSUMES_SLOT,\n  };\n}\n\n/**\n * Represents an attribute that has been extracted for inclusion in the consts array.\n */\nexport interface ExtractedAttributeOp extends Op<CreateOp> {\n  kind: OpKind.ExtractedAttribute;\n\n  /**\n   * The `XrefId` of the template-like element the extracted attribute will belong to.\n   */\n  target: XrefId;\n\n  /**\n   *  The kind of binding represented by this extracted attribute.\n   */\n  bindingKind: BindingKind;\n\n  /**\n   * The name of the extracted attribute.\n   */\n  name: string;\n\n  /**\n   * The value expression of the extracted attribute.\n   */\n  expression: o.Expression|null;\n}\n\n/**\n * Create an `ExtractedAttributeOp`.\n */\nexport function createExtractedAttributeOp(\n    target: XrefId, bindingKind: BindingKind, name: string,\n    expression: o.Expression|null): ExtractedAttributeOp {\n  return {\n    kind: OpKind.ExtractedAttribute,\n    target,\n    bindingKind,\n    name,\n    expression,\n    ...NEW_OP,\n  };\n}\n\nexport interface DeferOp extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.Defer;\n\n  /**\n   * The xref of this defer op.\n   */\n  xref: XrefId;\n\n  /**\n   * The xref of the main view.\n   */\n  mainView: XrefId;\n\n  mainSlot: SlotHandle;\n\n  /**\n   * Secondary loading block associated with this defer op.\n   */\n  loadingView: XrefId|null;\n\n  loadingSlot: SlotHandle|null;\n\n  /**\n   * Secondary placeholder block associated with this defer op.\n   */\n  placeholderView: XrefId|null;\n\n  placeholderSlot: SlotHandle|null;\n\n  /**\n   * Secondary error block associated with this defer op.\n   */\n  errorView: XrefId|null;\n\n  errorSlot: SlotHandle|null;\n\n  placeholderMinimumTime: number|null;\n  loadingMinimumTime: number|null;\n  loadingAfterTime: number|null;\n\n  placeholderConfig: o.Expression|null;\n  loadingConfig: o.Expression|null;\n\n  sourceSpan: ParseSourceSpan;\n}\n\nexport function createDeferOp(\n    xref: XrefId, main: XrefId, mainSlot: SlotHandle, sourceSpan: ParseSourceSpan): DeferOp {\n  return {\n    kind: OpKind.Defer,\n    xref,\n    handle: new SlotHandle(),\n    mainView: main,\n    mainSlot,\n    loadingView: null,\n    loadingSlot: null,\n    loadingConfig: null,\n    loadingMinimumTime: null,\n    loadingAfterTime: null,\n    placeholderView: null,\n    placeholderSlot: null,\n    placeholderConfig: null,\n    placeholderMinimumTime: null,\n    errorView: null,\n    errorSlot: null,\n    sourceSpan,\n    ...NEW_OP,\n    ...TRAIT_CONSUMES_SLOT,\n    numSlotsUsed: 2,\n  };\n}\ninterface DeferTriggerBase {\n  kind: DeferTriggerKind;\n}\n\ninterface DeferTriggerWithTargetBase extends DeferTriggerBase {\n  targetName: string|null;\n\n  /**\n   * The Xref of the targeted name. May be in a different view.\n   */\n  targetXref: XrefId|null;\n\n  /**\n   * The slot index of the named reference, inside the view provided below. This slot may not be\n   * inside the current view, and is handled specially as a result.\n   */\n  targetSlot: SlotHandle|null;\n\n  targetView: XrefId|null;\n\n  /**\n   * Number of steps to walk up or down the view tree to find the target localRef.\n   */\n  targetSlotViewSteps: number|null;\n}\n\ninterface DeferIdleTrigger extends DeferTriggerBase {\n  kind: DeferTriggerKind.Idle;\n}\n\ninterface DeferImmediateTrigger extends DeferTriggerBase {\n  kind: DeferTriggerKind.Immediate;\n}\n\ninterface DeferHoverTrigger extends DeferTriggerWithTargetBase {\n  kind: DeferTriggerKind.Hover;\n}\n\ninterface DeferTimerTrigger extends DeferTriggerBase {\n  kind: DeferTriggerKind.Timer;\n\n  delay: number;\n}\n\ninterface DeferInteractionTrigger extends DeferTriggerWithTargetBase {\n  kind: DeferTriggerKind.Interaction;\n}\n\ninterface DeferViewportTrigger extends DeferTriggerWithTargetBase {\n  kind: DeferTriggerKind.Viewport;\n}\n\n/**\n * The union type of all defer trigger interfaces.\n */\nexport type DeferTrigger = DeferIdleTrigger|DeferImmediateTrigger|DeferTimerTrigger|\n    DeferHoverTrigger|DeferInteractionTrigger|DeferViewportTrigger;\n\nexport interface DeferOnOp extends Op<CreateOp> {\n  kind: OpKind.DeferOn;\n\n  defer: XrefId;\n\n  /**\n   * The trigger for this defer op (e.g. idle, hover, etc).\n   */\n  trigger: DeferTrigger;\n\n  /**\n   * Whether to emit the prefetch version of the instruction.\n   */\n  prefetch: boolean;\n\n  sourceSpan: ParseSourceSpan;\n}\n\nexport function createDeferOnOp(\n    defer: XrefId, trigger: DeferTrigger, prefetch: boolean,\n    sourceSpan: ParseSourceSpan): DeferOnOp {\n  return {\n    kind: OpKind.DeferOn,\n    defer,\n    trigger,\n    prefetch,\n    sourceSpan,\n    ...NEW_OP,\n  };\n}\n\n/**\n * Represents a single value in an i18n param map. Each placeholder in the map may have multiple of\n * these values associated with it.\n */\nexport interface I18nParamValue {\n  /**\n   * The value.\n   */\n  value: string|number;\n\n  /**\n   * The sub-template index associated with the value.\n   */\n  subTemplateIndex: number|null;\n\n  /**\n   * Flags associated with the value.\n   */\n  flags: I18nParamValueFlags;\n}\n\n/**\n * Represents an i18n message that has been extracted for inclusion in the consts array.\n */\nexport interface ExtractedMessageOp extends Op<CreateOp> {\n  kind: OpKind.ExtractedMessage;\n\n  /**\n   * A reference to the i18n op this message was extracted from.\n   */\n  owner: XrefId;\n\n  /**\n   * The i18n message represented by this op.\n   */\n  message: i18n.Message;\n\n  /**\n   * Whether this op represents a root message (as opposed to a partial message for a sub-template\n   * in a root message).\n   */\n  isRoot: boolean;\n\n  /**\n   * The param map, with placeholders represented as an array of value objects for easy\n   * manipulation.\n   */\n  params: Map<string, I18nParamValue[]>;\n\n  /**\n   * The post-processing param map, with placeholders represented as an array of value objects for\n   * easy manipulation.\n   */\n  postprocessingParams: Map<string, I18nParamValue[]>;\n\n  /**\n   * Whether this message needs post-processing.\n   */\n  needsPostprocessing: boolean;\n\n  /**\n   * The param map, with placeholders represented as an `Expression` to facilitate extraction to the\n   * const arry.\n   */\n  formattedParams: Map<string, o.Expression>|null;\n\n  /**\n   * The post-processing param map, with placeholders represented as an `Expression` to facilitate\n   * extraction to the const arry.\n   */\n  formattedPostprocessingParams: Map<string, o.Expression>|null;\n}\n\n/**\n * Create an `ExtractedMessageOp`.\n */\nexport function createExtractedMessageOp(\n    owner: XrefId, message: i18n.Message, isRoot: boolean): ExtractedMessageOp {\n  return {\n    kind: OpKind.ExtractedMessage,\n    owner,\n    message,\n    isRoot,\n    params: new Map(),\n    postprocessingParams: new Map(),\n    needsPostprocessing: false,\n    formattedParams: null,\n    formattedPostprocessingParams: null,\n    ...NEW_OP,\n  };\n}\n\nexport interface I18nOpBase extends Op<CreateOp>, ConsumesSlotOpTrait {\n  kind: OpKind.I18nStart|OpKind.I18n;\n\n  /**\n   * `XrefId` allocated for this i18n block.\n   */\n  xref: XrefId;\n\n  /**\n   * A reference to the root i18n block that this one belongs to. For a a root i18n block, this is\n   * the same as xref.\n   */\n  root: XrefId;\n\n  /**\n   * The i18n metadata associated with this op.\n   */\n  message: i18n.Message;\n\n  /**\n   * The index in the consts array where the message i18n message is stored.\n   */\n  messageIndex: ConstIndex|null;\n\n  /**\n   * The index of this sub-block in the i18n message. For a root i18n block, this is null.\n   */\n  subTemplateIndex: number|null;\n}\n\n/**\n * Represents an empty i18n block.\n */\nexport interface I18nOp extends I18nOpBase {\n  kind: OpKind.I18n;\n}\n\n/**\n * Represents the start of an i18n block.\n */\nexport interface I18nStartOp extends I18nOpBase {\n  kind: OpKind.I18nStart;\n}\n\n/**\n * Create an `I18nStartOp`.\n */\nexport function createI18nStartOp(xref: XrefId, message: i18n.Message, root?: XrefId): I18nStartOp {\n  return {\n    kind: OpKind.I18nStart,\n    xref,\n    handle: new SlotHandle(),\n    root: root ?? xref,\n    message,\n    messageIndex: null,\n    subTemplateIndex: null,\n    ...NEW_OP,\n    ...TRAIT_CONSUMES_SLOT,\n  };\n}\n\n/**\n * Represents the end of an i18n block.\n */\nexport interface I18nEndOp extends Op<CreateOp> {\n  kind: OpKind.I18nEnd;\n\n  /**\n   * The `XrefId` of the `I18nStartOp` that created this block.\n   */\n  xref: XrefId;\n}\n\n/**\n * Create an `I18nEndOp`.\n */\nexport function createI18nEndOp(xref: XrefId): I18nEndOp {\n  return {\n    kind: OpKind.I18nEnd,\n    xref,\n    ...NEW_OP,\n  };\n}\n\n/**\n * An op that represents an ICU expression.\n */\nexport interface IcuOp extends Op<CreateOp> {\n  kind: OpKind.Icu;\n\n  /**\n   * The ID of the ICU.\n   */\n  xref: XrefId;\n\n  /**\n   * The i18n message for this ICU.\n   */\n  message: i18n.Message;\n\n  sourceSpan: ParseSourceSpan;\n}\n\n/**\n * Creates an op to create an ICU expression.\n */\nexport function createIcuOp(\n    xref: XrefId, message: i18n.Message, sourceSpan: ParseSourceSpan): IcuOp {\n  return {\n    kind: OpKind.Icu,\n    xref,\n    message,\n    sourceSpan,\n    ...NEW_OP,\n  };\n}\n\n\n/**\n * An index into the `consts` array which is shared across the compilation of all views in a\n * component.\n */\nexport type ConstIndex = number&{__brand: 'ConstIndex'};\n\nexport function literalOrArrayLiteral(value: any): o.Expression {\n  if (Array.isArray(value)) {\n    return o.literalArr(value.map(literalOrArrayLiteral));\n  }\n  return o.literal(value, o.INFERRED_TYPE);\n}\n"]}

package/esm2022/src/template/pipeline/ir/src/ops/shared.mjs

@@ -19,12 +19,13 @@ export function createStatementOp(statement) {
 /**
  * Create a `VariableOp`.
  */
-export function createVariableOp(xref, variable, initializer) {
+export function createVariableOp(xref, variable, initializer, flags) {
     return {
         kind: OpKind.Variable,
         xref,
         variable,
         initializer,
+        flags,
         ...NEW_OP,
     };
 }
@@ -39,4 +40,4 @@ export const NEW_OP = {
     prev: null,
     next: null,
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXIvc3JjL3RlbXBsYXRlL3BpcGVsaW5lL2lyL3NyYy9vcHMvc2hhcmVkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUdILE9BQU8sRUFBQyxNQUFNLEVBQWdCLE1BQU0sVUFBVSxDQUFDO0FBNEIvQzs7R0FFRztBQUNILE1BQU0sVUFBVSxpQkFBaUIsQ0FBc0IsU0FBc0I7SUFDM0UsT0FBTztRQUNMLElBQUksRUFBRSxNQUFNLENBQUMsU0FBUztRQUN0QixTQUFTO1FBQ1QsR0FBRyxNQUFNO0tBQ1YsQ0FBQztBQUNKLENBQUM7QUE0QkQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCLENBQzVCLElBQVksRUFBRSxRQUEwQixFQUFFLFdBQXlCLEVBQ25FLEtBQW9CO0lBQ3RCLE9BQU87UUFDTCxJQUFJLEVBQUUsTUFBTSxDQUFDLFFBQVE7UUFDckIsSUFBSTtRQUNKLFFBQVE7UUFDUixXQUFXO1FBQ1gsS0FBSztRQUNMLEdBQUcsTUFBTTtLQUNWLENBQUM7QUFDSixDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQStDO0lBQ2hFLFdBQVcsRUFBRSxJQUFJO0lBQ2pCLElBQUksRUFBRSxJQUFJO0lBQ1YsSUFBSSxFQUFFLElBQUk7Q0FDWCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCAqIGFzIG8gZnJvbSAnLi4vLi4vLi4vLi4vLi4vb3V0cHV0L291dHB1dF9hc3QnO1xuaW1wb3J0IHtPcEtpbmQsIFZhcmlhYmxlRmxhZ3N9IGZyb20gJy4uL2VudW1zJztcbmltcG9ydCB7T3AsIFhyZWZJZH0gZnJvbSAnLi4vb3BlcmF0aW9ucyc7XG5pbXBvcnQge1NlbWFudGljVmFyaWFibGV9IGZyb20gJy4uL3ZhcmlhYmxlJztcblxuLyoqXG4gKiBBIHNwZWNpYWwgYE9wYCB3aGljaCBpcyB1c2VkIGludGVybmFsbHkgaW4gdGhlIGBPcExpc3RgIGxpbmtlZCBsaXN0IHRvIHJlcHJlc2VudCB0aGUgaGVhZCBhbmRcbiAqIHRhaWwgbm9kZXMgb2YgdGhlIGxpc3QuXG4gKlxuICogYExpc3RFbmRPcGAgaXMgY3JlYXRlZCBpbnRlcm5hbGx5IGluIHRoZSBgT3BMaXN0YCBhbmQgc2hvdWxkIG5vdCBiZSBpbnN0YW50aWF0ZWQgZGlyZWN0bHkuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgTGlzdEVuZE9wPE9wVCBleHRlbmRzIE9wPE9wVD4+IGV4dGVuZHMgT3A8T3BUPiB7XG4gIGtpbmQ6IE9wS2luZC5MaXN0RW5kO1xufVxuXG4vKipcbiAqIEFuIGBPcGAgd2hpY2ggZGlyZWN0bHkgd3JhcHMgYW4gb3V0cHV0IGBTdGF0ZW1lbnRgLlxuICpcbiAqIE9mdGVuIGBTdGF0ZW1lbnRPcGBzIGFyZSB0aGUgZmluYWwgcmVzdWx0IG9mIElSIHByb2Nlc3NpbmcuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU3RhdGVtZW50T3A8T3BUIGV4dGVuZHMgT3A8T3BUPj4gZXh0ZW5kcyBPcDxPcFQ+IHtcbiAga2luZDogT3BLaW5kLlN0YXRlbWVudDtcblxuICAvKipcbiAgICogVGhlIG91dHB1dCBzdGF0ZW1lbnQuXG4gICAqL1xuICBzdGF0ZW1lbnQ6IG8uU3RhdGVtZW50O1xufVxuXG4vKipcbiAqIENyZWF0ZSBhIGBTdGF0ZW1lbnRPcGAuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVTdGF0ZW1lbnRPcDxPcFQgZXh0ZW5kcyBPcDxPcFQ+PihzdGF0ZW1lbnQ6IG8uU3RhdGVtZW50KTogU3RhdGVtZW50T3A8T3BUPiB7XG4gIHJldHVybiB7XG4gICAga2luZDogT3BLaW5kLlN0YXRlbWVudCxcbiAgICBzdGF0ZW1lbnQsXG4gICAgLi4uTkVXX09QLFxuICB9O1xufVxuXG4vKipcbiAqIE9wZXJhdGlvbiB3aGljaCBkZWNsYXJlcyBhbmQgaW5pdGlhbGl6ZXMgYSBgU2VtYW50aWNWYXJpYWJsZWAsIHRoYXQgaXMgdmFsaWQgZWl0aGVyIGluIGNyZWF0ZSBvclxuICogdXBkYXRlIElSLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIFZhcmlhYmxlT3A8T3BUIGV4dGVuZHMgT3A8T3BUPj4gZXh0ZW5kcyBPcDxPcFQ+IHtcbiAga2luZDogT3BLaW5kLlZhcmlhYmxlO1xuXG4gIC8qKlxuICAgKiBgWHJlZklkYCB3aGljaCBpZGVudGlmaWVzIHRoaXMgc3BlY2lmaWMgdmFyaWFibGUsIGFuZCBpcyB1c2VkIHRvIHJlZmVyZW5jZSB0aGlzIHZhcmlhYmxlIGZyb21cbiAgICogb3RoZXIgcGFydHMgb2YgdGhlIElSLlxuICAgKi9cbiAgeHJlZjogWHJlZklkO1xuXG4gIC8qKlxuICAgKiBUaGUgYFNlbWFudGljVmFyaWFibGVgIHdoaWNoIGRlc2NyaWJlcyB0aGUgbWVhbmluZyBiZWhpbmQgdGhpcyB2YXJpYWJsZS5cbiAgICovXG4gIHZhcmlhYmxlOiBTZW1hbnRpY1ZhcmlhYmxlO1xuXG4gIC8qKlxuICAgKiBFeHByZXNzaW9uIHJlcHJlc2VudGluZyB0aGUgdmFsdWUgb2YgdGhlIHZhcmlhYmxlLlxuICAgKi9cbiAgaW5pdGlhbGl6ZXI6IG8uRXhwcmVzc2lvbjtcblxuICBmbGFnczogVmFyaWFibGVGbGFncztcbn1cblxuLyoqXG4gKiBDcmVhdGUgYSBgVmFyaWFibGVPcGAuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVWYXJpYWJsZU9wPE9wVCBleHRlbmRzIE9wPE9wVD4+KFxuICAgIHhyZWY6IFhyZWZJZCwgdmFyaWFibGU6IFNlbWFudGljVmFyaWFibGUsIGluaXRpYWxpemVyOiBvLkV4cHJlc3Npb24sXG4gICAgZmxhZ3M6IFZhcmlhYmxlRmxhZ3MpOiBWYXJpYWJsZU9wPE9wVD4ge1xuICByZXR1cm4ge1xuICAgIGtpbmQ6IE9wS2luZC5WYXJpYWJsZSxcbiAgICB4cmVmLFxuICAgIHZhcmlhYmxlLFxuICAgIGluaXRpYWxpemVyLFxuICAgIGZsYWdzLFxuICAgIC4uLk5FV19PUCxcbiAgfTtcbn1cblxuLyoqXG4gKiBTdGF0aWMgc3RydWN0dXJlIHNoYXJlZCBieSBhbGwgb3BlcmF0aW9ucy5cbiAqXG4gKiBVc2VkIGFzIGEgY29udmVuaWVuY2UgdmlhIHRoZSBzcHJlYWQgb3BlcmF0b3IgKGAuLi5ORVdfT1BgKSB3aGVuIGNyZWF0aW5nIG5ldyBvcGVyYXRpb25zLCBhbmRcbiAqIGVuc3VyZXMgdGhlIGZpZWxkcyBhcmUgYWx3YXlzIGluIHRoZSBzYW1lIG9yZGVyLlxuICovXG5leHBvcnQgY29uc3QgTkVXX09QOiBQaWNrPE9wPGFueT4sICdkZWJ1Z0xpc3RJZCd8J3ByZXYnfCduZXh0Jz4gPSB7XG4gIGRlYnVnTGlzdElkOiBudWxsLFxuICBwcmV2OiBudWxsLFxuICBuZXh0OiBudWxsLFxufTtcbiJdfQ==