@angular/core 16.0.0-rc.1 → 16.0.0-rc.3

package/esm2022/src/render3/instructions/render.mjs

@@ -0,0 +1,125 @@
+/**
+ * @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 { retrieveHydrationInfo } from '../../hydration/utils';
+import { assertEqual } from '../../util/assert';
+import { CONTEXT, FLAGS, HOST, HYDRATION, INJECTOR, TVIEW } from '../interfaces/view';
+import { enterView, leaveView } from '../state';
+import { getComponentLViewByIndex, isCreationMode } from '../util/view_utils';
+import { executeTemplate, executeViewQueryFn, refreshContentQueries } from './shared';
+export function renderComponent(hostLView, componentHostIdx) {
+    ngDevMode && assertEqual(isCreationMode(hostLView), true, 'Should be run in creation mode');
+    const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);
+    const componentTView = componentView[TVIEW];
+    syncViewWithBlueprint(componentTView, componentView);
+    const hostRNode = componentView[HOST];
+    // Populate an LView with hydration info retrieved from the DOM via TransferState.
+    if (hostRNode !== null && componentView[HYDRATION] === null) {
+        componentView[HYDRATION] = retrieveHydrationInfo(hostRNode, componentView[INJECTOR]);
+    }
+    renderView(componentTView, componentView, componentView[CONTEXT]);
+}
+/**
+ * Syncs an LView instance with its blueprint if they have gotten out of sync.
+ *
+ * Typically, blueprints and their view instances should always be in sync, so the loop here
+ * will be skipped. However, consider this case of two components side-by-side:
+ *
+ * App template:
+ * ```
+ * <comp></comp>
+ * <comp></comp>
+ * ```
+ *
+ * The following will happen:
+ * 1. App template begins processing.
+ * 2. First <comp> is matched as a component and its LView is created.
+ * 3. Second <comp> is matched as a component and its LView is created.
+ * 4. App template completes processing, so it's time to check child templates.
+ * 5. First <comp> template is checked. It has a directive, so its def is pushed to blueprint.
+ * 6. Second <comp> template is checked. Its blueprint has been updated by the first
+ * <comp> template, but its LView was created before this update, so it is out of sync.
+ *
+ * Note that embedded views inside ngFor loops will never be out of sync because these views
+ * are processed as soon as they are created.
+ *
+ * @param tView The `TView` that contains the blueprint for syncing
+ * @param lView The view to sync
+ */
+export function syncViewWithBlueprint(tView, lView) {
+    for (let i = lView.length; i < tView.blueprint.length; i++) {
+        lView.push(tView.blueprint[i]);
+    }
+}
+/**
+ * Processes a view in the creation mode. This includes a number of steps in a specific order:
+ * - creating view query functions (if any);
+ * - executing a template function in the creation mode;
+ * - updating static queries (if any);
+ * - creating child components defined in a given view.
+ */
+export function renderView(tView, lView, context) {
+    ngDevMode && assertEqual(isCreationMode(lView), true, 'Should be run in creation mode');
+    enterView(lView);
+    try {
+        const viewQuery = tView.viewQuery;
+        if (viewQuery !== null) {
+            executeViewQueryFn(1 /* RenderFlags.Create */, viewQuery, context);
+        }
+        // Execute a template associated with this view, if it exists. A template function might not be
+        // defined for the root component views.
+        const templateFn = tView.template;
+        if (templateFn !== null) {
+            executeTemplate(tView, lView, templateFn, 1 /* RenderFlags.Create */, context);
+        }
+        // This needs to be set before children are processed to support recursive components.
+        // This must be set to false immediately after the first creation run because in an
+        // ngFor loop, all the views will be created together before update mode runs and turns
+        // off firstCreatePass. If we don't set it here, instances will perform directive
+        // matching, etc again and again.
+        if (tView.firstCreatePass) {
+            tView.firstCreatePass = false;
+        }
+        // We resolve content queries specifically marked as `static` in creation mode. Dynamic
+        // content queries are resolved during change detection (i.e. update mode), after embedded
+        // views are refreshed (see block above).
+        if (tView.staticContentQueries) {
+            refreshContentQueries(tView, lView);
+        }
+        // We must materialize query results before child components are processed
+        // in case a child component has projected a container. The LContainer needs
+        // to exist so the embedded views are properly attached by the container.
+        if (tView.staticViewQueries) {
+            executeViewQueryFn(2 /* RenderFlags.Update */, tView.viewQuery, context);
+        }
+        // Render child component views.
+        const components = tView.components;
+        if (components !== null) {
+            renderChildComponents(lView, components);
+        }
+    }
+    catch (error) {
+        // If we didn't manage to get past the first template pass due to
+        // an error, mark the view as corrupted so we can try to recover.
+        if (tView.firstCreatePass) {
+            tView.incompleteFirstPass = true;
+            tView.firstCreatePass = false;
+        }
+        throw error;
+    }
+    finally {
+        lView[FLAGS] &= ~4 /* LViewFlags.CreationMode */;
+        leaveView();
+    }
+}
+/** Renders child components in the current view (creation mode). */
+function renderChildComponents(hostLView, components) {
+    for (let i = 0; i < components.length; i++) {
+        renderComponent(hostLView, components[i]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"render.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/render.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAE9C,OAAO,EAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAqB,KAAK,EAAQ,MAAM,oBAAoB,CAAC;AAC9G,OAAO,EAAC,SAAS,EAAE,SAAS,EAAC,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAC,wBAAwB,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAE5E,OAAO,EAAC,eAAe,EAAE,kBAAkB,EAAE,qBAAqB,EAAC,MAAM,UAAU,CAAC;AAEpF,MAAM,UAAU,eAAe,CAAC,SAAgB,EAAE,gBAAwB;IACxE,SAAS,IAAI,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,gCAAgC,CAAC,CAAC;IAC5F,MAAM,aAAa,GAAG,wBAAwB,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;IAC5E,MAAM,cAAc,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IAC5C,qBAAqB,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC;IAErD,MAAM,SAAS,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IACtC,kFAAkF;IAClF,IAAI,SAAS,KAAK,IAAI,IAAI,aAAa,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;QAC3D,aAAa,CAAC,SAAS,CAAC,GAAG,qBAAqB,CAAC,SAAS,EAAE,aAAa,CAAC,QAAQ,CAAE,CAAC,CAAC;KACvF;IAED,UAAU,CAAC,cAAc,EAAE,aAAa,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC;AACpE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAY,EAAE,KAAY;IAC9D,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAC1D,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;KAChC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CAAI,KAAY,EAAE,KAAe,EAAE,OAAU;IACrE,SAAS,IAAI,WAAW,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,gCAAgC,CAAC,CAAC;IACxF,SAAS,CAAC,KAAK,CAAC,CAAC;IACjB,IAAI;QACF,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;QAClC,IAAI,SAAS,KAAK,IAAI,EAAE;YACtB,kBAAkB,6BAAwB,SAAS,EAAE,OAAO,CAAC,CAAC;SAC/D;QAED,+FAA+F;QAC/F,wCAAwC;QACxC,MAAM,UAAU,GAAG,KAAK,CAAC,QAAQ,CAAC;QAClC,IAAI,UAAU,KAAK,IAAI,EAAE;YACvB,eAAe,CAAI,KAAK,EAAE,KAAK,EAAE,UAAU,8BAAsB,OAAO,CAAC,CAAC;SAC3E;QAED,sFAAsF;QACtF,mFAAmF;QACnF,uFAAuF;QACvF,iFAAiF;QACjF,iCAAiC;QACjC,IAAI,KAAK,CAAC,eAAe,EAAE;YACzB,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC;SAC/B;QAED,uFAAuF;QACvF,0FAA0F;QAC1F,yCAAyC;QACzC,IAAI,KAAK,CAAC,oBAAoB,EAAE;YAC9B,qBAAqB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SACrC;QAED,0EAA0E;QAC1E,4EAA4E;QAC5E,yEAAyE;QACzE,IAAI,KAAK,CAAC,iBAAiB,EAAE;YAC3B,kBAAkB,6BAAwB,KAAK,CAAC,SAAU,EAAE,OAAO,CAAC,CAAC;SACtE;QAED,gCAAgC;QAChC,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QACpC,IAAI,UAAU,KAAK,IAAI,EAAE;YACvB,qBAAqB,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;SAC1C;KAEF;IAAC,OAAO,KAAK,EAAE;QACd,iEAAiE;QACjE,iEAAiE;QACjE,IAAI,KAAK,CAAC,eAAe,EAAE;YACzB,KAAK,CAAC,mBAAmB,GAAG,IAAI,CAAC;YACjC,KAAK,CAAC,eAAe,GAAG,KAAK,CAAC;SAC/B;QAED,MAAM,KAAK,CAAC;KACb;YAAS;QACR,KAAK,CAAC,KAAK,CAAC,IAAI,gCAAwB,CAAC;QACzC,SAAS,EAAE,CAAC;KACb;AACH,CAAC;AAED,oEAAoE;AACpE,SAAS,qBAAqB,CAAC,SAAgB,EAAE,UAAoB;IACnE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAC1C,eAAe,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;KAC3C;AACH,CAAC","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {retrieveHydrationInfo} from '../../hydration/utils';\nimport {assertEqual} from '../../util/assert';\nimport {RenderFlags} from '../interfaces/definition';\nimport {CONTEXT, FLAGS, HOST, HYDRATION, INJECTOR, LView, LViewFlags, TVIEW, TView} from '../interfaces/view';\nimport {enterView, leaveView} from '../state';\nimport {getComponentLViewByIndex, isCreationMode} from '../util/view_utils';\n\nimport {executeTemplate, executeViewQueryFn, refreshContentQueries} from './shared';\n\nexport function renderComponent(hostLView: LView, componentHostIdx: number) {\n  ngDevMode && assertEqual(isCreationMode(hostLView), true, 'Should be run in creation mode');\n  const componentView = getComponentLViewByIndex(componentHostIdx, hostLView);\n  const componentTView = componentView[TVIEW];\n  syncViewWithBlueprint(componentTView, componentView);\n\n  const hostRNode = componentView[HOST];\n  // Populate an LView with hydration info retrieved from the DOM via TransferState.\n  if (hostRNode !== null && componentView[HYDRATION] === null) {\n    componentView[HYDRATION] = retrieveHydrationInfo(hostRNode, componentView[INJECTOR]!);\n  }\n\n  renderView(componentTView, componentView, componentView[CONTEXT]);\n}\n\n/**\n * Syncs an LView instance with its blueprint if they have gotten out of sync.\n *\n * Typically, blueprints and their view instances should always be in sync, so the loop here\n * will be skipped. However, consider this case of two components side-by-side:\n *\n * App template:\n * ```\n * <comp></comp>\n * <comp></comp>\n * ```\n *\n * The following will happen:\n * 1. App template begins processing.\n * 2. First <comp> is matched as a component and its LView is created.\n * 3. Second <comp> is matched as a component and its LView is created.\n * 4. App template completes processing, so it's time to check child templates.\n * 5. First <comp> template is checked. It has a directive, so its def is pushed to blueprint.\n * 6. Second <comp> template is checked. Its blueprint has been updated by the first\n * <comp> template, but its LView was created before this update, so it is out of sync.\n *\n * Note that embedded views inside ngFor loops will never be out of sync because these views\n * are processed as soon as they are created.\n *\n * @param tView The `TView` that contains the blueprint for syncing\n * @param lView The view to sync\n */\nexport function syncViewWithBlueprint(tView: TView, lView: LView) {\n  for (let i = lView.length; i < tView.blueprint.length; i++) {\n    lView.push(tView.blueprint[i]);\n  }\n}\n\n/**\n * Processes a view in the creation mode. This includes a number of steps in a specific order:\n * - creating view query functions (if any);\n * - executing a template function in the creation mode;\n * - updating static queries (if any);\n * - creating child components defined in a given view.\n */\nexport function renderView<T>(tView: TView, lView: LView<T>, context: T): void {\n  ngDevMode && assertEqual(isCreationMode(lView), true, 'Should be run in creation mode');\n  enterView(lView);\n  try {\n    const viewQuery = tView.viewQuery;\n    if (viewQuery !== null) {\n      executeViewQueryFn<T>(RenderFlags.Create, viewQuery, context);\n    }\n\n    // Execute a template associated with this view, if it exists. A template function might not be\n    // defined for the root component views.\n    const templateFn = tView.template;\n    if (templateFn !== null) {\n      executeTemplate<T>(tView, lView, templateFn, RenderFlags.Create, context);\n    }\n\n    // This needs to be set before children are processed to support recursive components.\n    // This must be set to false immediately after the first creation run because in an\n    // ngFor loop, all the views will be created together before update mode runs and turns\n    // off firstCreatePass. If we don't set it here, instances will perform directive\n    // matching, etc again and again.\n    if (tView.firstCreatePass) {\n      tView.firstCreatePass = false;\n    }\n\n    // We resolve content queries specifically marked as `static` in creation mode. Dynamic\n    // content queries are resolved during change detection (i.e. update mode), after embedded\n    // views are refreshed (see block above).\n    if (tView.staticContentQueries) {\n      refreshContentQueries(tView, lView);\n    }\n\n    // We must materialize query results before child components are processed\n    // in case a child component has projected a container. The LContainer needs\n    // to exist so the embedded views are properly attached by the container.\n    if (tView.staticViewQueries) {\n      executeViewQueryFn<T>(RenderFlags.Update, tView.viewQuery!, context);\n    }\n\n    // Render child component views.\n    const components = tView.components;\n    if (components !== null) {\n      renderChildComponents(lView, components);\n    }\n\n  } catch (error) {\n    // If we didn't manage to get past the first template pass due to\n    // an error, mark the view as corrupted so we can try to recover.\n    if (tView.firstCreatePass) {\n      tView.incompleteFirstPass = true;\n      tView.firstCreatePass = false;\n    }\n\n    throw error;\n  } finally {\n    lView[FLAGS] &= ~LViewFlags.CreationMode;\n    leaveView();\n  }\n}\n\n/** Renders child components in the current view (creation mode). */\nfunction renderChildComponents(hostLView: LView, components: number[]): void {\n  for (let i = 0; i < components.length; i++) {\n    renderComponent(hostLView, components[i]);\n  }\n}\n"]}