@angular/core 13.0.0-next.8 → 13.0.0-rc.2

package/esm2020/src/view/util.mjs

@@ -0,0 +1,369 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { devModeEqual } from '../change_detection/change_detection';
+import { SOURCE } from '../di/injector_compatibility';
+import { ViewEncapsulation } from '../metadata/view';
+import { stringify } from '../util/stringify';
+import { expressionChangedAfterItHasBeenCheckedError } from './errors';
+import { asElementData, asTextData, Services } from './types';
+export const NOOP = () => { };
+const _tokenKeyCache = new Map();
+export function tokenKey(token) {
+    let key = _tokenKeyCache.get(token);
+    if (!key) {
+        key = stringify(token) + '_' + _tokenKeyCache.size;
+        _tokenKeyCache.set(token, key);
+    }
+    return key;
+}
+const UNDEFINED_RENDERER_TYPE_ID = '$$undefined';
+const EMPTY_RENDERER_TYPE_ID = '$$empty';
+// Attention: this function is called as top level function.
+// Putting any logic in here will destroy closure tree shaking!
+export function createRendererType2(values) {
+    return {
+        id: UNDEFINED_RENDERER_TYPE_ID,
+        styles: values.styles,
+        encapsulation: values.encapsulation,
+        data: values.data
+    };
+}
+let _renderCompCount = 0;
+export function resolveRendererType2(type) {
+    if (type && type.id === UNDEFINED_RENDERER_TYPE_ID) {
+        // first time we see this RendererType2. Initialize it...
+        const isFilled = ((type.encapsulation != null && type.encapsulation !== ViewEncapsulation.None) ||
+            type.styles.length || Object.keys(type.data).length);
+        if (isFilled) {
+            type.id = `c${_renderCompCount++}`;
+        }
+        else {
+            type.id = EMPTY_RENDERER_TYPE_ID;
+        }
+    }
+    if (type && type.id === EMPTY_RENDERER_TYPE_ID) {
+        type = null;
+    }
+    return type || null;
+}
+export function checkBinding(view, def, bindingIdx, value) {
+    const oldValues = view.oldValues;
+    if ((view.state & 2 /* FirstCheck */) ||
+        !Object.is(oldValues[def.bindingIndex + bindingIdx], value)) {
+        return true;
+    }
+    return false;
+}
+export function checkAndUpdateBinding(view, def, bindingIdx, value) {
+    if (checkBinding(view, def, bindingIdx, value)) {
+        view.oldValues[def.bindingIndex + bindingIdx] = value;
+        return true;
+    }
+    return false;
+}
+export function checkBindingNoChanges(view, def, bindingIdx, value) {
+    const oldValue = view.oldValues[def.bindingIndex + bindingIdx];
+    if ((view.state & 1 /* BeforeFirstCheck */) || !devModeEqual(oldValue, value)) {
+        const bindingName = def.bindings[bindingIdx].name;
+        throw expressionChangedAfterItHasBeenCheckedError(Services.createDebugContext(view, def.nodeIndex), `${bindingName}: ${oldValue}`, `${bindingName}: ${value}`, (view.state & 1 /* BeforeFirstCheck */) !== 0);
+    }
+}
+export function markParentViewsForCheck(view) {
+    let currView = view;
+    while (currView) {
+        if (currView.def.flags & 2 /* OnPush */) {
+            currView.state |= 8 /* ChecksEnabled */;
+        }
+        currView = currView.viewContainerParent || currView.parent;
+    }
+}
+export function markParentViewsForCheckProjectedViews(view, endView) {
+    let currView = view;
+    while (currView && currView !== endView) {
+        currView.state |= 64 /* CheckProjectedViews */;
+        currView = currView.viewContainerParent || currView.parent;
+    }
+}
+export function dispatchEvent(view, nodeIndex, eventName, event) {
+    try {
+        const nodeDef = view.def.nodes[nodeIndex];
+        const startView = nodeDef.flags & 33554432 /* ComponentView */ ?
+            asElementData(view, nodeIndex).componentView :
+            view;
+        markParentViewsForCheck(startView);
+        return Services.handleEvent(view, nodeIndex, eventName, event);
+    }
+    catch (e) {
+        // Attention: Don't rethrow, as it would cancel Observable subscriptions!
+        view.root.errorHandler.handleError(e);
+    }
+}
+export function declaredViewContainer(view) {
+    if (view.parent) {
+        const parentView = view.parent;
+        return asElementData(parentView, view.parentNodeDef.nodeIndex);
+    }
+    return null;
+}
+/**
+ * for component views, this is the host element.
+ * for embedded views, this is the index of the parent node
+ * that contains the view container.
+ */
+export function viewParentEl(view) {
+    const parentView = view.parent;
+    if (parentView) {
+        return view.parentNodeDef.parent;
+    }
+    else {
+        return null;
+    }
+}
+export function renderNode(view, def) {
+    switch (def.flags & 201347067 /* Types */) {
+        case 1 /* TypeElement */:
+            return asElementData(view, def.nodeIndex).renderElement;
+        case 2 /* TypeText */:
+            return asTextData(view, def.nodeIndex).renderText;
+    }
+}
+export function elementEventFullName(target, name) {
+    return target ? `${target}:${name}` : name;
+}
+export function isComponentView(view) {
+    return !!view.parent && !!(view.parentNodeDef.flags & 32768 /* Component */);
+}
+export function isEmbeddedView(view) {
+    return !!view.parent && !(view.parentNodeDef.flags & 32768 /* Component */);
+}
+export function filterQueryId(queryId) {
+    return 1 << (queryId % 32);
+}
+export function splitMatchedQueriesDsl(matchedQueriesDsl) {
+    const matchedQueries = {};
+    let matchedQueryIds = 0;
+    const references = {};
+    if (matchedQueriesDsl) {
+        matchedQueriesDsl.forEach(([queryId, valueType]) => {
+            if (typeof queryId === 'number') {
+                matchedQueries[queryId] = valueType;
+                matchedQueryIds |= filterQueryId(queryId);
+            }
+            else {
+                references[queryId] = valueType;
+            }
+        });
+    }
+    return { matchedQueries, references, matchedQueryIds };
+}
+export function splitDepsDsl(deps, sourceName) {
+    return deps.map(value => {
+        let token;
+        let flags;
+        if (Array.isArray(value)) {
+            [flags, token] = value;
+        }
+        else {
+            flags = 0 /* None */;
+            token = value;
+        }
+        if (token && (typeof token === 'function' || typeof token === 'object') && sourceName) {
+            Object.defineProperty(token, SOURCE, { value: sourceName, configurable: true });
+        }
+        return { flags, token, tokenKey: tokenKey(token) };
+    });
+}
+export function getParentRenderElement(view, renderHost, def) {
+    let renderParent = def.renderParent;
+    if (renderParent) {
+        if ((renderParent.flags & 1 /* TypeElement */) === 0 ||
+            (renderParent.flags & 33554432 /* ComponentView */) === 0 ||
+            (renderParent.element.componentRendererType &&
+                (renderParent.element.componentRendererType.encapsulation ===
+                    ViewEncapsulation.ShadowDom ||
+                    // TODO(FW-2290): remove the `encapsulation === 1` fallback logic in v12.
+                    // @ts-ignore TODO: Remove as part of FW-2290. TS complains about us dealing with an enum
+                    // value that is not known (but previously was the value for ViewEncapsulation.Native)
+                    renderParent.element.componentRendererType.encapsulation === 1))) {
+            // only children of non components, or children of components with native encapsulation should
+            // be attached.
+            return asElementData(view, def.renderParent.nodeIndex).renderElement;
+        }
+    }
+    else {
+        return renderHost;
+    }
+}
+const DEFINITION_CACHE = new WeakMap();
+export function resolveDefinition(factory) {
+    let value = DEFINITION_CACHE.get(factory);
+    if (!value) {
+        value = factory(() => NOOP);
+        value.factory = factory;
+        DEFINITION_CACHE.set(factory, value);
+    }
+    return value;
+}
+export function rootRenderNodes(view) {
+    const renderNodes = [];
+    visitRootRenderNodes(view, 0 /* Collect */, undefined, undefined, renderNodes);
+    return renderNodes;
+}
+export function visitRootRenderNodes(view, action, parentNode, nextSibling, target) {
+    // We need to re-compute the parent node in case the nodes have been moved around manually
+    if (action === 3 /* RemoveChild */) {
+        parentNode = view.renderer.parentNode(renderNode(view, view.def.lastRenderRootNode));
+    }
+    visitSiblingRenderNodes(view, action, 0, view.def.nodes.length - 1, parentNode, nextSibling, target);
+}
+export function visitSiblingRenderNodes(view, action, startIndex, endIndex, parentNode, nextSibling, target) {
+    for (let i = startIndex; i <= endIndex; i++) {
+        const nodeDef = view.def.nodes[i];
+        if (nodeDef.flags & (1 /* TypeElement */ | 2 /* TypeText */ | 8 /* TypeNgContent */)) {
+            visitRenderNode(view, nodeDef, action, parentNode, nextSibling, target);
+        }
+        // jump to next sibling
+        i += nodeDef.childCount;
+    }
+}
+export function visitProjectedRenderNodes(view, ngContentIndex, action, parentNode, nextSibling, target) {
+    let compView = view;
+    while (compView && !isComponentView(compView)) {
+        compView = compView.parent;
+    }
+    const hostView = compView.parent;
+    const hostElDef = viewParentEl(compView);
+    const startIndex = hostElDef.nodeIndex + 1;
+    const endIndex = hostElDef.nodeIndex + hostElDef.childCount;
+    for (let i = startIndex; i <= endIndex; i++) {
+        const nodeDef = hostView.def.nodes[i];
+        if (nodeDef.ngContentIndex === ngContentIndex) {
+            visitRenderNode(hostView, nodeDef, action, parentNode, nextSibling, target);
+        }
+        // jump to next sibling
+        i += nodeDef.childCount;
+    }
+    if (!hostView.parent) {
+        // a root view
+        const projectedNodes = view.root.projectableNodes[ngContentIndex];
+        if (projectedNodes) {
+            for (let i = 0; i < projectedNodes.length; i++) {
+                execRenderNodeAction(view, projectedNodes[i], action, parentNode, nextSibling, target);
+            }
+        }
+    }
+}
+function visitRenderNode(view, nodeDef, action, parentNode, nextSibling, target) {
+    if (nodeDef.flags & 8 /* TypeNgContent */) {
+        visitProjectedRenderNodes(view, nodeDef.ngContent.index, action, parentNode, nextSibling, target);
+    }
+    else {
+        const rn = renderNode(view, nodeDef);
+        if (action === 3 /* RemoveChild */ && (nodeDef.flags & 33554432 /* ComponentView */) &&
+            (nodeDef.bindingFlags & 48 /* CatSyntheticProperty */)) {
+            // Note: we might need to do both actions.
+            if (nodeDef.bindingFlags & (16 /* SyntheticProperty */)) {
+                execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);
+            }
+            if (nodeDef.bindingFlags & (32 /* SyntheticHostProperty */)) {
+                const compView = asElementData(view, nodeDef.nodeIndex).componentView;
+                execRenderNodeAction(compView, rn, action, parentNode, nextSibling, target);
+            }
+        }
+        else {
+            execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);
+        }
+        if (nodeDef.flags & 16777216 /* EmbeddedViews */) {
+            const embeddedViews = asElementData(view, nodeDef.nodeIndex).viewContainer._embeddedViews;
+            for (let k = 0; k < embeddedViews.length; k++) {
+                visitRootRenderNodes(embeddedViews[k], action, parentNode, nextSibling, target);
+            }
+        }
+        if (nodeDef.flags & 1 /* TypeElement */ && !nodeDef.element.name) {
+            visitSiblingRenderNodes(view, action, nodeDef.nodeIndex + 1, nodeDef.nodeIndex + nodeDef.childCount, parentNode, nextSibling, target);
+        }
+    }
+}
+function execRenderNodeAction(view, renderNode, action, parentNode, nextSibling, target) {
+    const renderer = view.renderer;
+    switch (action) {
+        case 1 /* AppendChild */:
+            renderer.appendChild(parentNode, renderNode);
+            break;
+        case 2 /* InsertBefore */:
+            renderer.insertBefore(parentNode, renderNode, nextSibling);
+            break;
+        case 3 /* RemoveChild */:
+            renderer.removeChild(parentNode, renderNode);
+            break;
+        case 0 /* Collect */:
+            target.push(renderNode);
+            break;
+    }
+}
+const NS_PREFIX_RE = /^:([^:]+):(.+)$/;
+export function splitNamespace(name) {
+    if (name[0] === ':') {
+        const match = name.match(NS_PREFIX_RE);
+        return [match[1], match[2]];
+    }
+    return ['', name];
+}
+export function calcBindingFlags(bindings) {
+    let flags = 0;
+    for (let i = 0; i < bindings.length; i++) {
+        flags |= bindings[i].flags;
+    }
+    return flags;
+}
+export function interpolate(valueCount, constAndInterp) {
+    let result = '';
+    for (let i = 0; i < valueCount * 2; i = i + 2) {
+        result = result + constAndInterp[i] + _toStringWithNull(constAndInterp[i + 1]);
+    }
+    return result + constAndInterp[valueCount * 2];
+}
+export function inlineInterpolate(valueCount, c0, a1, c1, a2, c2, a3, c3, a4, c4, a5, c5, a6, c6, a7, c7, a8, c8, a9, c9) {
+    switch (valueCount) {
+        case 1:
+            return c0 + _toStringWithNull(a1) + c1;
+        case 2:
+            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2;
+        case 3:
+            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+                c3;
+        case 4:
+            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+                c3 + _toStringWithNull(a4) + c4;
+        case 5:
+            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5;
+        case 6:
+            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) + c6;
+        case 7:
+            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
+                c6 + _toStringWithNull(a7) + c7;
+        case 8:
+            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
+                c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8;
+        case 9:
+            return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +
+                c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +
+                c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8 + _toStringWithNull(a9) + c9;
+        default:
+            throw new Error(`Does not support more than 9 expressions`);
+    }
+}
+function _toStringWithNull(v) {
+    return v != null ? v.toString() : '';
+}
+export const EMPTY_MAP = {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/view/util.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 {devModeEqual} from '../change_detection/change_detection';\nimport {SOURCE} from '../di/injector_compatibility';\nimport {ViewEncapsulation} from '../metadata/view';\nimport {RendererType2} from '../render/api_flags';\nimport {stringify} from '../util/stringify';\n\nimport {expressionChangedAfterItHasBeenCheckedError} from './errors';\nimport {asElementData, asTextData, BindingDef, BindingFlags, Definition, DefinitionFactory, DepDef, DepFlags, ElementData, NodeDef, NodeFlags, QueryValueType, Services, ViewData, ViewDefinition, ViewDefinitionFactory, ViewFlags, ViewState} from './types';\n\nexport const NOOP: any = () => {};\n\nconst _tokenKeyCache = new Map<any, string>();\n\nexport function tokenKey(token: any): string {\n  let key = _tokenKeyCache.get(token);\n  if (!key) {\n    key = stringify(token) + '_' + _tokenKeyCache.size;\n    _tokenKeyCache.set(token, key);\n  }\n  return key;\n}\n\nconst UNDEFINED_RENDERER_TYPE_ID = '$$undefined';\nconst EMPTY_RENDERER_TYPE_ID = '$$empty';\n\n// Attention: this function is called as top level function.\n// Putting any logic in here will destroy closure tree shaking!\nexport function createRendererType2(values: {\n  styles: (string|any[])[],\n  encapsulation: ViewEncapsulation,\n  data: {[kind: string]: any[]}\n}): RendererType2 {\n  return {\n    id: UNDEFINED_RENDERER_TYPE_ID,\n    styles: values.styles,\n    encapsulation: values.encapsulation,\n    data: values.data\n  };\n}\n\nlet _renderCompCount = 0;\n\nexport function resolveRendererType2(type?: RendererType2|null): RendererType2|null {\n  if (type && type.id === UNDEFINED_RENDERER_TYPE_ID) {\n    // first time we see this RendererType2. Initialize it...\n    const isFilled =\n        ((type.encapsulation != null && type.encapsulation !== ViewEncapsulation.None) ||\n         type.styles.length || Object.keys(type.data).length);\n    if (isFilled) {\n      type.id = `c${_renderCompCount++}`;\n    } else {\n      type.id = EMPTY_RENDERER_TYPE_ID;\n    }\n  }\n  if (type && type.id === EMPTY_RENDERER_TYPE_ID) {\n    type = null;\n  }\n  return type || null;\n}\n\nexport function checkBinding(\n    view: ViewData, def: NodeDef, bindingIdx: number, value: any): boolean {\n  const oldValues = view.oldValues;\n  if ((view.state & ViewState.FirstCheck) ||\n      !Object.is(oldValues[def.bindingIndex + bindingIdx], value)) {\n    return true;\n  }\n  return false;\n}\n\nexport function checkAndUpdateBinding(\n    view: ViewData, def: NodeDef, bindingIdx: number, value: any): boolean {\n  if (checkBinding(view, def, bindingIdx, value)) {\n    view.oldValues[def.bindingIndex + bindingIdx] = value;\n    return true;\n  }\n  return false;\n}\n\nexport function checkBindingNoChanges(\n    view: ViewData, def: NodeDef, bindingIdx: number, value: any) {\n  const oldValue = view.oldValues[def.bindingIndex + bindingIdx];\n  if ((view.state & ViewState.BeforeFirstCheck) || !devModeEqual(oldValue, value)) {\n    const bindingName = def.bindings[bindingIdx].name;\n    throw expressionChangedAfterItHasBeenCheckedError(\n        Services.createDebugContext(view, def.nodeIndex), `${bindingName}: ${oldValue}`,\n        `${bindingName}: ${value}`, (view.state & ViewState.BeforeFirstCheck) !== 0);\n  }\n}\n\nexport function markParentViewsForCheck(view: ViewData) {\n  let currView: ViewData|null = view;\n  while (currView) {\n    if (currView.def.flags & ViewFlags.OnPush) {\n      currView.state |= ViewState.ChecksEnabled;\n    }\n    currView = currView.viewContainerParent || currView.parent;\n  }\n}\n\nexport function markParentViewsForCheckProjectedViews(view: ViewData, endView: ViewData) {\n  let currView: ViewData|null = view;\n  while (currView && currView !== endView) {\n    currView.state |= ViewState.CheckProjectedViews;\n    currView = currView.viewContainerParent || currView.parent;\n  }\n}\n\nexport function dispatchEvent(\n    view: ViewData, nodeIndex: number, eventName: string, event: any): boolean|undefined {\n  try {\n    const nodeDef = view.def.nodes[nodeIndex];\n    const startView = nodeDef.flags & NodeFlags.ComponentView ?\n        asElementData(view, nodeIndex).componentView :\n        view;\n    markParentViewsForCheck(startView);\n    return Services.handleEvent(view, nodeIndex, eventName, event);\n  } catch (e) {\n    // Attention: Don't rethrow, as it would cancel Observable subscriptions!\n    view.root.errorHandler.handleError(e);\n  }\n}\n\nexport function declaredViewContainer(view: ViewData): ElementData|null {\n  if (view.parent) {\n    const parentView = view.parent;\n    return asElementData(parentView, view.parentNodeDef!.nodeIndex);\n  }\n  return null;\n}\n\n/**\n * for component views, this is the host element.\n * for embedded views, this is the index of the parent node\n * that contains the view container.\n */\nexport function viewParentEl(view: ViewData): NodeDef|null {\n  const parentView = view.parent;\n  if (parentView) {\n    return view.parentNodeDef!.parent;\n  } else {\n    return null;\n  }\n}\n\nexport function renderNode(view: ViewData, def: NodeDef): any {\n  switch (def.flags & NodeFlags.Types) {\n    case NodeFlags.TypeElement:\n      return asElementData(view, def.nodeIndex).renderElement;\n    case NodeFlags.TypeText:\n      return asTextData(view, def.nodeIndex).renderText;\n  }\n}\n\nexport function elementEventFullName(target: string|null, name: string): string {\n  return target ? `${target}:${name}` : name;\n}\n\nexport function isComponentView(view: ViewData): boolean {\n  return !!view.parent && !!(view.parentNodeDef!.flags & NodeFlags.Component);\n}\n\nexport function isEmbeddedView(view: ViewData): boolean {\n  return !!view.parent && !(view.parentNodeDef!.flags & NodeFlags.Component);\n}\n\nexport function filterQueryId(queryId: number): number {\n  return 1 << (queryId % 32);\n}\n\nexport function splitMatchedQueriesDsl(matchedQueriesDsl: [string|number, QueryValueType][]|null): {\n  matchedQueries: {[queryId: string]: QueryValueType},\n  references: {[refId: string]: QueryValueType},\n  matchedQueryIds: number\n} {\n  const matchedQueries: {[queryId: string]: QueryValueType} = {};\n  let matchedQueryIds = 0;\n  const references: {[refId: string]: QueryValueType} = {};\n  if (matchedQueriesDsl) {\n    matchedQueriesDsl.forEach(([queryId, valueType]) => {\n      if (typeof queryId === 'number') {\n        matchedQueries[queryId] = valueType;\n        matchedQueryIds |= filterQueryId(queryId);\n      } else {\n        references[queryId] = valueType;\n      }\n    });\n  }\n  return {matchedQueries, references, matchedQueryIds};\n}\n\nexport function splitDepsDsl(deps: ([DepFlags, any]|any)[], sourceName?: string): DepDef[] {\n  return deps.map(value => {\n    let token: any;\n    let flags: DepFlags;\n    if (Array.isArray(value)) {\n      [flags, token] = value;\n    } else {\n      flags = DepFlags.None;\n      token = value;\n    }\n    if (token && (typeof token === 'function' || typeof token === 'object') && sourceName) {\n      Object.defineProperty(token, SOURCE, {value: sourceName, configurable: true});\n    }\n    return {flags, token, tokenKey: tokenKey(token)};\n  });\n}\n\nexport function getParentRenderElement(view: ViewData, renderHost: any, def: NodeDef): any {\n  let renderParent = def.renderParent;\n  if (renderParent) {\n    if ((renderParent.flags & NodeFlags.TypeElement) === 0 ||\n        (renderParent.flags & NodeFlags.ComponentView) === 0 ||\n        (renderParent.element!.componentRendererType &&\n         (renderParent.element!.componentRendererType!.encapsulation ===\n              ViewEncapsulation.ShadowDom ||\n          // TODO(FW-2290): remove the `encapsulation === 1` fallback logic in v12.\n          // @ts-ignore TODO: Remove as part of FW-2290. TS complains about us dealing with an enum\n          // value that is not known (but previously was the value for ViewEncapsulation.Native)\n          renderParent.element!.componentRendererType!.encapsulation === 1))) {\n      // only children of non components, or children of components with native encapsulation should\n      // be attached.\n      return asElementData(view, def.renderParent!.nodeIndex).renderElement;\n    }\n  } else {\n    return renderHost;\n  }\n}\n\nconst DEFINITION_CACHE = new WeakMap<any, Definition<any>>();\n\nexport function resolveDefinition<D extends Definition<any>>(factory: DefinitionFactory<D>): D {\n  let value = DEFINITION_CACHE.get(factory)! as D;\n  if (!value) {\n    value = factory(() => NOOP);\n    value.factory = factory;\n    DEFINITION_CACHE.set(factory, value);\n  }\n  return value;\n}\n\nexport function rootRenderNodes(view: ViewData): any[] {\n  const renderNodes: any[] = [];\n  visitRootRenderNodes(view, RenderNodeAction.Collect, undefined, undefined, renderNodes);\n  return renderNodes;\n}\n\nexport const enum RenderNodeAction {\n  Collect,\n  AppendChild,\n  InsertBefore,\n  RemoveChild\n}\n\nexport function visitRootRenderNodes(\n    view: ViewData, action: RenderNodeAction, parentNode: any, nextSibling: any, target?: any[]) {\n  // We need to re-compute the parent node in case the nodes have been moved around manually\n  if (action === RenderNodeAction.RemoveChild) {\n    parentNode = view.renderer.parentNode(renderNode(view, view.def.lastRenderRootNode!));\n  }\n  visitSiblingRenderNodes(\n      view, action, 0, view.def.nodes.length - 1, parentNode, nextSibling, target);\n}\n\nexport function visitSiblingRenderNodes(\n    view: ViewData, action: RenderNodeAction, startIndex: number, endIndex: number, parentNode: any,\n    nextSibling: any, target?: any[]) {\n  for (let i = startIndex; i <= endIndex; i++) {\n    const nodeDef = view.def.nodes[i];\n    if (nodeDef.flags & (NodeFlags.TypeElement | NodeFlags.TypeText | NodeFlags.TypeNgContent)) {\n      visitRenderNode(view, nodeDef, action, parentNode, nextSibling, target);\n    }\n    // jump to next sibling\n    i += nodeDef.childCount;\n  }\n}\n\nexport function visitProjectedRenderNodes(\n    view: ViewData, ngContentIndex: number, action: RenderNodeAction, parentNode: any,\n    nextSibling: any, target?: any[]) {\n  let compView: ViewData|null = view;\n  while (compView && !isComponentView(compView)) {\n    compView = compView.parent;\n  }\n  const hostView = compView!.parent;\n  const hostElDef = viewParentEl(compView!);\n  const startIndex = hostElDef!.nodeIndex + 1;\n  const endIndex = hostElDef!.nodeIndex + hostElDef!.childCount;\n  for (let i = startIndex; i <= endIndex; i++) {\n    const nodeDef = hostView!.def.nodes[i];\n    if (nodeDef.ngContentIndex === ngContentIndex) {\n      visitRenderNode(hostView!, nodeDef, action, parentNode, nextSibling, target);\n    }\n    // jump to next sibling\n    i += nodeDef.childCount;\n  }\n  if (!hostView!.parent) {\n    // a root view\n    const projectedNodes = view.root.projectableNodes[ngContentIndex];\n    if (projectedNodes) {\n      for (let i = 0; i < projectedNodes.length; i++) {\n        execRenderNodeAction(view, projectedNodes[i], action, parentNode, nextSibling, target);\n      }\n    }\n  }\n}\n\nfunction visitRenderNode(\n    view: ViewData, nodeDef: NodeDef, action: RenderNodeAction, parentNode: any, nextSibling: any,\n    target?: any[]) {\n  if (nodeDef.flags & NodeFlags.TypeNgContent) {\n    visitProjectedRenderNodes(\n        view, nodeDef.ngContent!.index, action, parentNode, nextSibling, target);\n  } else {\n    const rn = renderNode(view, nodeDef);\n    if (action === RenderNodeAction.RemoveChild && (nodeDef.flags & NodeFlags.ComponentView) &&\n        (nodeDef.bindingFlags & BindingFlags.CatSyntheticProperty)) {\n      // Note: we might need to do both actions.\n      if (nodeDef.bindingFlags & (BindingFlags.SyntheticProperty)) {\n        execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);\n      }\n      if (nodeDef.bindingFlags & (BindingFlags.SyntheticHostProperty)) {\n        const compView = asElementData(view, nodeDef.nodeIndex).componentView;\n        execRenderNodeAction(compView, rn, action, parentNode, nextSibling, target);\n      }\n    } else {\n      execRenderNodeAction(view, rn, action, parentNode, nextSibling, target);\n    }\n    if (nodeDef.flags & NodeFlags.EmbeddedViews) {\n      const embeddedViews = asElementData(view, nodeDef.nodeIndex).viewContainer!._embeddedViews;\n      for (let k = 0; k < embeddedViews.length; k++) {\n        visitRootRenderNodes(embeddedViews[k], action, parentNode, nextSibling, target);\n      }\n    }\n    if (nodeDef.flags & NodeFlags.TypeElement && !nodeDef.element!.name) {\n      visitSiblingRenderNodes(\n          view, action, nodeDef.nodeIndex + 1, nodeDef.nodeIndex + nodeDef.childCount, parentNode,\n          nextSibling, target);\n    }\n  }\n}\n\nfunction execRenderNodeAction(\n    view: ViewData, renderNode: any, action: RenderNodeAction, parentNode: any, nextSibling: any,\n    target?: any[]) {\n  const renderer = view.renderer;\n  switch (action) {\n    case RenderNodeAction.AppendChild:\n      renderer.appendChild(parentNode, renderNode);\n      break;\n    case RenderNodeAction.InsertBefore:\n      renderer.insertBefore(parentNode, renderNode, nextSibling);\n      break;\n    case RenderNodeAction.RemoveChild:\n      renderer.removeChild(parentNode, renderNode);\n      break;\n    case RenderNodeAction.Collect:\n      target!.push(renderNode);\n      break;\n  }\n}\n\nconst NS_PREFIX_RE = /^:([^:]+):(.+)$/;\n\nexport function splitNamespace(name: string): string[] {\n  if (name[0] === ':') {\n    const match = name.match(NS_PREFIX_RE)!;\n    return [match[1], match[2]];\n  }\n  return ['', name];\n}\n\nexport function calcBindingFlags(bindings: BindingDef[]): BindingFlags {\n  let flags = 0;\n  for (let i = 0; i < bindings.length; i++) {\n    flags |= bindings[i].flags;\n  }\n  return flags;\n}\n\nexport function interpolate(valueCount: number, constAndInterp: string[]): string {\n  let result = '';\n  for (let i = 0; i < valueCount * 2; i = i + 2) {\n    result = result + constAndInterp[i] + _toStringWithNull(constAndInterp[i + 1]);\n  }\n  return result + constAndInterp[valueCount * 2];\n}\n\nexport function inlineInterpolate(\n    valueCount: number, c0: string, a1: any, c1: string, a2?: any, c2?: string, a3?: any,\n    c3?: string, a4?: any, c4?: string, a5?: any, c5?: string, a6?: any, c6?: string, a7?: any,\n    c7?: string, a8?: any, c8?: string, a9?: any, c9?: string): string {\n  switch (valueCount) {\n    case 1:\n      return c0 + _toStringWithNull(a1) + c1;\n    case 2:\n      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2;\n    case 3:\n      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n          c3;\n    case 4:\n      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n          c3 + _toStringWithNull(a4) + c4;\n    case 5:\n      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5;\n    case 6:\n      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) + c6;\n    case 7:\n      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +\n          c6 + _toStringWithNull(a7) + c7;\n    case 8:\n      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +\n          c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8;\n    case 9:\n      return c0 + _toStringWithNull(a1) + c1 + _toStringWithNull(a2) + c2 + _toStringWithNull(a3) +\n          c3 + _toStringWithNull(a4) + c4 + _toStringWithNull(a5) + c5 + _toStringWithNull(a6) +\n          c6 + _toStringWithNull(a7) + c7 + _toStringWithNull(a8) + c8 + _toStringWithNull(a9) + c9;\n    default:\n      throw new Error(`Does not support more than 9 expressions`);\n  }\n}\n\nfunction _toStringWithNull(v: any): string {\n  return v != null ? v.toString() : '';\n}\n\nexport const EMPTY_MAP: {[key: string]: any} = {};\n"]}

package/esm2020/testing/src/logger.mjs

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class Log {
+    constructor() {
+        this.logItems = [];
+    }
+    add(value /** TODO #9100 */) {
+        this.logItems.push(value);
+    }
+    fn(value /** TODO #9100 */) {
+        return (a1 = null, a2 = null, a3 = null, a4 = null, a5 = null) => {
+            this.logItems.push(value);
+        };
+    }
+    clear() {
+        this.logItems = [];
+    }
+    result() {
+        return this.logItems.join('; ');
+    }
+}
+Log.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.2", ngImport: i0, type: Log, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+Log.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-rc.2", ngImport: i0, type: Log });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.2", ngImport: i0, type: Log, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/testing/src/ng_zone_mock.mjs

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { EventEmitter, Injectable, NgZone } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A mock implementation of {@link NgZone}.
+ */
+export class MockNgZone extends NgZone {
+    constructor() {
+        super({ enableLongStackTrace: false, shouldCoalesceEventChangeDetection: false });
+        this.onStable = new EventEmitter(false);
+    }
+    run(fn) {
+        return fn();
+    }
+    runOutsideAngular(fn) {
+        return fn();
+    }
+    simulateZoneExit() {
+        this.onStable.emit(null);
+    }
+}
+MockNgZone.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.2", ngImport: i0, type: MockNgZone, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MockNgZone.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0-rc.2", ngImport: i0, type: MockNgZone });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.2", ngImport: i0, type: MockNgZone, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmdfem9uZV9tb2NrLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS90ZXN0aW5nL3NyYy9uZ196b25lX21vY2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsT0FBTyxFQUFDLFlBQVksRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFDLE1BQU0sZUFBZSxDQUFDOztBQUcvRDs7R0FFRztBQUVILE1BQU0sT0FBTyxVQUFXLFNBQVEsTUFBTTtJQUdwQztRQUNFLEtBQUssQ0FBQyxFQUFDLG9CQUFvQixFQUFFLEtBQUssRUFBRSxrQ0FBa0MsRUFBRSxLQUFLLEVBQUMsQ0FBQyxDQUFDO1FBSHpFLGFBQVEsR0FBc0IsSUFBSSxZQUFZLENBQUMsS0FBSyxDQUFDLENBQUM7SUFJL0QsQ0FBQztJQUVRLEdBQUcsQ0FBQyxFQUFZO1FBQ3ZCLE9BQU8sRUFBRSxFQUFFLENBQUM7SUFDZCxDQUFDO0lBRVEsaUJBQWlCLENBQUMsRUFBWTtRQUNyQyxPQUFPLEVBQUUsRUFBRSxDQUFDO0lBQ2QsQ0FBQztJQUVELGdCQUFnQjtRQUNkLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQzNCLENBQUM7O2tIQWpCVSxVQUFVO3NIQUFWLFVBQVU7c0dBQVYsVUFBVTtrQkFEdEIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge0V2ZW50RW1pdHRlciwgSW5qZWN0YWJsZSwgTmdab25lfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuXG4vKipcbiAqIEEgbW9jayBpbXBsZW1lbnRhdGlvbiBvZiB7QGxpbmsgTmdab25lfS5cbiAqL1xuQEluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIE1vY2tOZ1pvbmUgZXh0ZW5kcyBOZ1pvbmUge1xuICBvdmVycmlkZSBvblN0YWJsZTogRXZlbnRFbWl0dGVyPGFueT4gPSBuZXcgRXZlbnRFbWl0dGVyKGZhbHNlKTtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgICBzdXBlcih7ZW5hYmxlTG9uZ1N0YWNrVHJhY2U6IGZhbHNlLCBzaG91bGRDb2FsZXNjZUV2ZW50Q2hhbmdlRGV0ZWN0aW9uOiBmYWxzZX0pO1xuICB9XG5cbiAgb3ZlcnJpZGUgcnVuKGZuOiBGdW5jdGlvbik6IGFueSB7XG4gICAgcmV0dXJuIGZuKCk7XG4gIH1cblxuICBvdmVycmlkZSBydW5PdXRzaWRlQW5ndWxhcihmbjogRnVuY3Rpb24pOiBhbnkge1xuICAgIHJldHVybiBmbigpO1xuICB9XG5cbiAgc2ltdWxhdGVab25lRXhpdCgpOiB2b2lkIHtcbiAgICB0aGlzLm9uU3RhYmxlLmVtaXQobnVsbCk7XG4gIH1cbn1cbiJdfQ==