@angular/core 16.0.0-next.3 → 16.0.0-next.5

package/esm2022/src/hydration/api.mjs

@@ -0,0 +1,143 @@
+/**
+ * @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 { APP_BOOTSTRAP_LISTENER, ApplicationRef } from '../application_ref';
+import { PLATFORM_ID } from '../application_tokens';
+import { ENVIRONMENT_INITIALIZER, makeEnvironmentProviders } from '../di';
+import { inject } from '../di/injector_compatibility';
+import { InitialRenderPendingTasks } from '../initial_render_pending_tasks';
+import { enableLocateOrCreateContainerRefImpl } from '../linker/view_container_ref';
+import { enableLocateOrCreateElementNodeImpl } from '../render3/instructions/element';
+import { enableLocateOrCreateElementContainerNodeImpl } from '../render3/instructions/element_container';
+import { enableApplyRootElementTransformImpl } from '../render3/instructions/shared';
+import { enableLocateOrCreateContainerAnchorImpl } from '../render3/instructions/template';
+import { enableLocateOrCreateTextNodeImpl } from '../render3/instructions/text';
+import { cleanupDehydratedViews } from './cleanup';
+import { IS_HYDRATION_FEATURE_ENABLED, PRESERVE_HOST_CONTENT } from './tokens';
+import { enableRetrieveHydrationInfoImpl } from './utils';
+import { enableFindMatchingDehydratedViewImpl } from './views';
+/**
+ * Indicates whether the hydration-related code was added,
+ * prevents adding it multiple times.
+ */
+let isHydrationSupportEnabled = false;
+/**
+ * Brings the necessary hydration code in tree-shakable manner.
+ * The code is only present when the `provideHydrationSupport` is
+ * invoked. Otherwise, this code is tree-shaken away during the
+ * build optimization step.
+ *
+ * This technique allows us to swap implementations of methods so
+ * tree shaking works appropriately when hydration is disabled or
+ * enabled. It brings in the appropriate version of the method that
+ * supports hydration only when enabled.
+ */
+function enableHydrationRuntimeSupport() {
+    if (!isHydrationSupportEnabled) {
+        isHydrationSupportEnabled = true;
+        enableRetrieveHydrationInfoImpl();
+        enableLocateOrCreateElementNodeImpl();
+        enableLocateOrCreateTextNodeImpl();
+        enableLocateOrCreateElementContainerNodeImpl();
+        enableLocateOrCreateContainerAnchorImpl();
+        enableLocateOrCreateContainerRefImpl();
+        enableFindMatchingDehydratedViewImpl();
+        enableApplyRootElementTransformImpl();
+    }
+}
+/**
+ * Detects whether the code is invoked in a browser.
+ * Later on, this check should be replaced with a tree-shakable
+ * flag (e.g. `!isServer`).
+ */
+function isBrowser() {
+    return inject(PLATFORM_ID) === 'browser';
+}
+/**
+ * Returns a set of providers required to setup hydration support
+ * for an application that is server side rendered.
+ *
+ * ## NgModule-based bootstrap
+ *
+ * You can add the function call to the root AppModule of an application:
+ * ```
+ * import {provideHydrationSupport} from '@angular/core';
+ *
+ * @NgModule({
+ *   providers: [
+ *     // ... other providers ...
+ *     provideHydrationSupport()
+ *   ],
+ *   declarations: [AppComponent],
+ *   bootstrap: [AppComponent]
+ * })
+ * class AppModule {}
+ * ```
+ *
+ * ## Standalone-based bootstrap
+ *
+ * Add the function to the `bootstrapApplication` call:
+ * ```
+ * import {provideHydrationSupport} from '@angular/core';
+ *
+ * bootstrapApplication(RootComponent, {
+ *   providers: [
+ *     // ... other providers ...
+ *     provideHydrationSupport()
+ *   ]
+ * });
+ * ```
+ *
+ * The function sets up an internal flag that would be recognized during
+ * the server side rendering time as well, so there is no need to
+ * configure or change anything in NgUniversal to enable the feature.
+ *
+ * @publicApi
+ * @developerPreview
+ */
+export function provideHydrationSupport() {
+    return makeEnvironmentProviders([
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            useValue: () => {
+                // Since this function is used across both server and client,
+                // make sure that the runtime code is only added when invoked
+                // on the client. Moving forward, the `isBrowser` check should
+                // be replaced with a tree-shakable alternative (e.g. `isServer`
+                // flag).
+                if (isBrowser()) {
+                    enableHydrationRuntimeSupport();
+                }
+            },
+            multi: true,
+        },
+        {
+            provide: IS_HYDRATION_FEATURE_ENABLED,
+            useValue: true,
+        },
+        {
+            provide: PRESERVE_HOST_CONTENT,
+            // Preserve host element content only in a browser
+            // environment. On a server, an application is rendered
+            // from scratch, so the host content needs to be empty.
+            useFactory: () => isBrowser(),
+        },
+        {
+            provide: APP_BOOTSTRAP_LISTENER,
+            useFactory: () => {
+                if (isBrowser()) {
+                    const appRef = inject(ApplicationRef);
+                    const pendingTasks = inject(InitialRenderPendingTasks);
+                    return () => cleanupDehydratedViews(appRef, pendingTasks);
+                }
+                return () => { }; // noop
+            },
+            multi: true,
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,sBAAsB,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAAC,WAAW,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAC,uBAAuB,EAAwB,wBAAwB,EAAC,MAAM,OAAO,CAAC;AAC9F,OAAO,EAAC,MAAM,EAAC,MAAM,8BAA8B,CAAC;AACpD,OAAO,EAAC,yBAAyB,EAAC,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAC,oCAAoC,EAAC,MAAM,8BAA8B,CAAC;AAClF,OAAO,EAAC,mCAAmC,EAAC,MAAM,iCAAiC,CAAC;AACpF,OAAO,EAAC,4CAA4C,EAAC,MAAM,2CAA2C,CAAC;AACvG,OAAO,EAAC,mCAAmC,EAAC,MAAM,gCAAgC,CAAC;AACnF,OAAO,EAAC,uCAAuC,EAAC,MAAM,kCAAkC,CAAC;AACzF,OAAO,EAAC,gCAAgC,EAAC,MAAM,8BAA8B,CAAC;AAE9E,OAAO,EAAC,sBAAsB,EAAC,MAAM,WAAW,CAAC;AACjD,OAAO,EAAC,4BAA4B,EAAE,qBAAqB,EAAC,MAAM,UAAU,CAAC;AAC7E,OAAO,EAAC,+BAA+B,EAAC,MAAM,SAAS,CAAC;AACxD,OAAO,EAAC,oCAAoC,EAAC,MAAM,SAAS,CAAC;AAG7D;;;GAGG;AACH,IAAI,yBAAyB,GAAG,KAAK,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,SAAS,6BAA6B;IACpC,IAAI,CAAC,yBAAyB,EAAE;QAC9B,yBAAyB,GAAG,IAAI,CAAC;QACjC,+BAA+B,EAAE,CAAC;QAClC,mCAAmC,EAAE,CAAC;QACtC,gCAAgC,EAAE,CAAC;QACnC,4CAA4C,EAAE,CAAC;QAC/C,uCAAuC,EAAE,CAAC;QAC1C,oCAAoC,EAAE,CAAC;QACvC,oCAAoC,EAAE,CAAC;QACvC,mCAAmC,EAAE,CAAC;KACvC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,SAAS;IAChB,OAAO,MAAM,CAAC,WAAW,CAAC,KAAK,SAAS,CAAC;AAC3C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO,wBAAwB,CAAC;QAC9B;YACE,OAAO,EAAE,uBAAuB;YAChC,QAAQ,EAAE,GAAG,EAAE;gBACb,6DAA6D;gBAC7D,6DAA6D;gBAC7D,8DAA8D;gBAC9D,gEAAgE;gBAChE,SAAS;gBACT,IAAI,SAAS,EAAE,EAAE;oBACf,6BAA6B,EAAE,CAAC;iBACjC;YACH,CAAC;YACD,KAAK,EAAE,IAAI;SACZ;QACD;YACE,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,IAAI;SACf;QACD;YACE,OAAO,EAAE,qBAAqB;YAC9B,kDAAkD;YAClD,uDAAuD;YACvD,uDAAuD;YACvD,UAAU,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE;SAC9B;QACD;YACE,OAAO,EAAE,sBAAsB;YAC/B,UAAU,EAAE,GAAG,EAAE;gBACf,IAAI,SAAS,EAAE,EAAE;oBACf,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;oBACtC,MAAM,YAAY,GAAG,MAAM,CAAC,yBAAyB,CAAC,CAAC;oBACvD,OAAO,GAAG,EAAE,CAAC,sBAAsB,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;iBAC3D;gBACD,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC,CAAE,OAAO;YAC3B,CAAC;YACD,KAAK,EAAE,IAAI;SACZ;KACF,CAAC,CAAC;AACL,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 {APP_BOOTSTRAP_LISTENER, ApplicationRef} from '../application_ref';\nimport {PLATFORM_ID} from '../application_tokens';\nimport {ENVIRONMENT_INITIALIZER, EnvironmentProviders, makeEnvironmentProviders} from '../di';\nimport {inject} from '../di/injector_compatibility';\nimport {InitialRenderPendingTasks} from '../initial_render_pending_tasks';\nimport {enableLocateOrCreateContainerRefImpl} from '../linker/view_container_ref';\nimport {enableLocateOrCreateElementNodeImpl} from '../render3/instructions/element';\nimport {enableLocateOrCreateElementContainerNodeImpl} from '../render3/instructions/element_container';\nimport {enableApplyRootElementTransformImpl} from '../render3/instructions/shared';\nimport {enableLocateOrCreateContainerAnchorImpl} from '../render3/instructions/template';\nimport {enableLocateOrCreateTextNodeImpl} from '../render3/instructions/text';\n\nimport {cleanupDehydratedViews} from './cleanup';\nimport {IS_HYDRATION_FEATURE_ENABLED, PRESERVE_HOST_CONTENT} from './tokens';\nimport {enableRetrieveHydrationInfoImpl} from './utils';\nimport {enableFindMatchingDehydratedViewImpl} from './views';\n\n\n/**\n * Indicates whether the hydration-related code was added,\n * prevents adding it multiple times.\n */\nlet isHydrationSupportEnabled = false;\n\n/**\n * Brings the necessary hydration code in tree-shakable manner.\n * The code is only present when the `provideHydrationSupport` is\n * invoked. Otherwise, this code is tree-shaken away during the\n * build optimization step.\n *\n * This technique allows us to swap implementations of methods so\n * tree shaking works appropriately when hydration is disabled or\n * enabled. It brings in the appropriate version of the method that\n * supports hydration only when enabled.\n */\nfunction enableHydrationRuntimeSupport() {\n  if (!isHydrationSupportEnabled) {\n    isHydrationSupportEnabled = true;\n    enableRetrieveHydrationInfoImpl();\n    enableLocateOrCreateElementNodeImpl();\n    enableLocateOrCreateTextNodeImpl();\n    enableLocateOrCreateElementContainerNodeImpl();\n    enableLocateOrCreateContainerAnchorImpl();\n    enableLocateOrCreateContainerRefImpl();\n    enableFindMatchingDehydratedViewImpl();\n    enableApplyRootElementTransformImpl();\n  }\n}\n\n/**\n * Detects whether the code is invoked in a browser.\n * Later on, this check should be replaced with a tree-shakable\n * flag (e.g. `!isServer`).\n */\nfunction isBrowser(): boolean {\n  return inject(PLATFORM_ID) === 'browser';\n}\n\n/**\n * Returns a set of providers required to setup hydration support\n * for an application that is server side rendered.\n *\n * ## NgModule-based bootstrap\n *\n * You can add the function call to the root AppModule of an application:\n * ```\n * import {provideHydrationSupport} from '@angular/core';\n *\n * @NgModule({\n *   providers: [\n *     // ... other providers ...\n *     provideHydrationSupport()\n *   ],\n *   declarations: [AppComponent],\n *   bootstrap: [AppComponent]\n * })\n * class AppModule {}\n * ```\n *\n * ## Standalone-based bootstrap\n *\n * Add the function to the `bootstrapApplication` call:\n * ```\n * import {provideHydrationSupport} from '@angular/core';\n *\n * bootstrapApplication(RootComponent, {\n *   providers: [\n *     // ... other providers ...\n *     provideHydrationSupport()\n *   ]\n * });\n * ```\n *\n * The function sets up an internal flag that would be recognized during\n * the server side rendering time as well, so there is no need to\n * configure or change anything in NgUniversal to enable the feature.\n *\n * @publicApi\n * @developerPreview\n */\nexport function provideHydrationSupport(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {\n      provide: ENVIRONMENT_INITIALIZER,\n      useValue: () => {\n        // Since this function is used across both server and client,\n        // make sure that the runtime code is only added when invoked\n        // on the client. Moving forward, the `isBrowser` check should\n        // be replaced with a tree-shakable alternative (e.g. `isServer`\n        // flag).\n        if (isBrowser()) {\n          enableHydrationRuntimeSupport();\n        }\n      },\n      multi: true,\n    },\n    {\n      provide: IS_HYDRATION_FEATURE_ENABLED,\n      useValue: true,\n    },\n    {\n      provide: PRESERVE_HOST_CONTENT,\n      // Preserve host element content only in a browser\n      // environment. On a server, an application is rendered\n      // from scratch, so the host content needs to be empty.\n      useFactory: () => isBrowser(),\n    },\n    {\n      provide: APP_BOOTSTRAP_LISTENER,\n      useFactory: () => {\n        if (isBrowser()) {\n          const appRef = inject(ApplicationRef);\n          const pendingTasks = inject(InitialRenderPendingTasks);\n          return () => cleanupDehydratedViews(appRef, pendingTasks);\n        }\n        return () => {};  // noop\n      },\n      multi: true,\n    }\n  ]);\n}\n"]}

package/esm2022/src/hydration/cleanup.mjs

@@ -0,0 +1,103 @@
+/**
+ * @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 { first } from 'rxjs/operators';
+import { CONTAINER_HEADER_OFFSET, DEHYDRATED_VIEWS } from '../render3/interfaces/container';
+import { isLContainer } from '../render3/interfaces/type_checks';
+import { HEADER_OFFSET, HOST, PARENT, RENDERER, TVIEW } from '../render3/interfaces/view';
+import { nativeRemoveNode } from '../render3/node_manipulation';
+import { EMPTY_ARRAY } from '../util/empty';
+import { validateSiblingNodeExists } from './error_handling';
+import { NUM_ROOT_NODES } from './interfaces';
+import { getComponentLViewForHydration } from './utils';
+/**
+ * Removes all dehydrated views from a given LContainer:
+ * both in internal data structure, as well as removing
+ * corresponding DOM nodes that belong to that dehydrated view.
+ */
+export function removeDehydratedViews(lContainer) {
+    const views = lContainer[DEHYDRATED_VIEWS] ?? [];
+    const parentLView = lContainer[PARENT];
+    const renderer = parentLView[RENDERER];
+    for (const view of views) {
+        removeDehydratedView(view, renderer);
+        ngDevMode && ngDevMode.dehydratedViewsRemoved++;
+    }
+    // Reset the value to an empty array to indicate that no
+    // further processing of dehydrated views is needed for
+    // this view container (i.e. do not trigger the lookup process
+    // once again in case a `ViewContainerRef` is created later).
+    lContainer[DEHYDRATED_VIEWS] = EMPTY_ARRAY;
+}
+/**
+ * Helper function to remove all nodes from a dehydrated view.
+ */
+function removeDehydratedView(dehydratedView, renderer) {
+    let nodesRemoved = 0;
+    let currentRNode = dehydratedView.firstChild;
+    if (currentRNode) {
+        const numNodes = dehydratedView.data[NUM_ROOT_NODES];
+        while (nodesRemoved < numNodes) {
+            ngDevMode && validateSiblingNodeExists(currentRNode);
+            const nextSibling = currentRNode.nextSibling;
+            nativeRemoveNode(renderer, currentRNode, false);
+            currentRNode = nextSibling;
+            nodesRemoved++;
+        }
+    }
+}
+/**
+ * Walks over all views within this LContainer invokes dehydrated views
+ * cleanup function for each one.
+ */
+function cleanupLContainer(lContainer) {
+    removeDehydratedViews(lContainer);
+    for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+        cleanupLView(lContainer[i]);
+    }
+}
+/**
+ * Walks over `LContainer`s and components registered within
+ * this LView and invokes dehydrated views cleanup function for each one.
+ */
+function cleanupLView(lView) {
+    const tView = lView[TVIEW];
+    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+        if (isLContainer(lView[i])) {
+            const lContainer = lView[i];
+            cleanupLContainer(lContainer);
+        }
+        else if (Array.isArray(lView[i])) {
+            // This is a component, enter the `cleanupLView` recursively.
+            cleanupLView(lView[i]);
+        }
+    }
+}
+/**
+ * Walks over all views registered within the ApplicationRef and removes
+ * all dehydrated views from all `LContainer`s along the way.
+ */
+export function cleanupDehydratedViews(appRef, pendingTasks) {
+    // Wait once an app becomes stable and cleanup all views that
+    // were not claimed during the application bootstrap process.
+    // The timing is similar to when we kick off serialization on the server.
+    const isStablePromise = appRef.isStable.pipe(first((isStable) => isStable)).toPromise();
+    const pendingTasksPromise = pendingTasks.whenAllTasksComplete;
+    return Promise.allSettled([isStablePromise, pendingTasksPromise]).then(() => {
+        const viewRefs = appRef._views;
+        for (const viewRef of viewRefs) {
+            const lView = getComponentLViewForHydration(viewRef);
+            // An `lView` might be `null` if a `ViewRef` represents
+            // an embedded view (not a component view).
+            if (lView !== null && lView[HOST] !== null) {
+                cleanupLView(lView);
+                ngDevMode && ngDevMode.dehydratedViewsCleanupRuns++;
+            }
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cleanup.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/cleanup.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,KAAK,EAAC,MAAM,gBAAgB,CAAC;AAIrC,OAAO,EAAC,uBAAuB,EAAE,gBAAgB,EAAa,MAAM,iCAAiC,CAAC;AAGtG,OAAO,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAC/D,OAAO,EAAC,aAAa,EAAE,IAAI,EAAS,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAC,MAAM,4BAA4B,CAAC;AAC/F,OAAO,EAAC,gBAAgB,EAAC,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAC,yBAAyB,EAAC,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAA0B,cAAc,EAAC,MAAM,cAAc,CAAC;AACrE,OAAO,EAAC,6BAA6B,EAAC,MAAM,SAAS,CAAC;AAEtD;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,UAAsB;IAC1D,MAAM,KAAK,GAAG,UAAU,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;IACjD,MAAM,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;IACvC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;QACxB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACrC,SAAS,IAAI,SAAS,CAAC,sBAAsB,EAAE,CAAC;KACjD;IACD,wDAAwD;IACxD,uDAAuD;IACvD,8DAA8D;IAC9D,6DAA6D;IAC7D,UAAU,CAAC,gBAAgB,CAAC,GAAG,WAAW,CAAC;AAC7C,CAAC;AAED;;GAEG;AACH,SAAS,oBAAoB,CAAC,cAAuC,EAAE,QAAkB;IACvF,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,YAAY,GAAG,cAAc,CAAC,UAAU,CAAC;IAC7C,IAAI,YAAY,EAAE;QAChB,MAAM,QAAQ,GAAG,cAAc,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QACrD,OAAO,YAAY,GAAG,QAAQ,EAAE;YAC9B,SAAS,IAAI,yBAAyB,CAAC,YAAY,CAAC,CAAC;YACrD,MAAM,WAAW,GAAU,YAAY,CAAC,WAAY,CAAC;YACrD,gBAAgB,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK,CAAC,CAAC;YAChD,YAAY,GAAG,WAAW,CAAC;YAC3B,YAAY,EAAE,CAAC;SAChB;KACF;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,iBAAiB,CAAC,UAAsB;IAC/C,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAClC,KAAK,IAAI,CAAC,GAAG,uBAAuB,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QAChE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAU,CAAC,CAAC;KACtC;AACH,CAAC;AAED;;;GAGG;AACH,SAAS,YAAY,CAAC,KAAY;IAChC,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,KAAK,IAAI,CAAC,GAAG,aAAa,EAAE,CAAC,GAAG,KAAK,CAAC,iBAAiB,EAAE,CAAC,EAAE,EAAE;QAC5D,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE;YAC1B,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YAC5B,iBAAiB,CAAC,UAAU,CAAC,CAAC;SAC/B;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE;YAClC,6DAA6D;YAC7D,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;SACxB;KACF;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAClC,MAAsB,EAAE,YAAuC;IACjE,6DAA6D;IAC7D,6DAA6D;IAC7D,yEAAyE;IACzE,MAAM,eAAe,GAAG,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAiB,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;IACjG,MAAM,mBAAmB,GAAG,YAAY,CAAC,oBAAoB,CAAC;IAC9D,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;QAC1E,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC;QAC/B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;YAC9B,MAAM,KAAK,GAAG,6BAA6B,CAAC,OAAO,CAAC,CAAC;YACrD,uDAAuD;YACvD,2CAA2C;YAC3C,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE;gBAC1C,YAAY,CAAC,KAAK,CAAC,CAAC;gBACpB,SAAS,IAAI,SAAS,CAAC,0BAA0B,EAAE,CAAC;aACrD;SACF;IACH,CAAC,CAAC,CAAC;AACL,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 {first} from 'rxjs/operators';\n\nimport {ApplicationRef} from '../application_ref';\nimport {InitialRenderPendingTasks} from '../initial_render_pending_tasks';\nimport {CONTAINER_HEADER_OFFSET, DEHYDRATED_VIEWS, LContainer} from '../render3/interfaces/container';\nimport {Renderer} from '../render3/interfaces/renderer';\nimport {RNode} from '../render3/interfaces/renderer_dom';\nimport {isLContainer} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, HOST, LView, PARENT, RENDERER, TVIEW} from '../render3/interfaces/view';\nimport {nativeRemoveNode} from '../render3/node_manipulation';\nimport {EMPTY_ARRAY} from '../util/empty';\n\nimport {validateSiblingNodeExists} from './error_handling';\nimport {DehydratedContainerView, NUM_ROOT_NODES} from './interfaces';\nimport {getComponentLViewForHydration} from './utils';\n\n/**\n * Removes all dehydrated views from a given LContainer:\n * both in internal data structure, as well as removing\n * corresponding DOM nodes that belong to that dehydrated view.\n */\nexport function removeDehydratedViews(lContainer: LContainer) {\n  const views = lContainer[DEHYDRATED_VIEWS] ?? [];\n  const parentLView = lContainer[PARENT];\n  const renderer = parentLView[RENDERER];\n  for (const view of views) {\n    removeDehydratedView(view, renderer);\n    ngDevMode && ngDevMode.dehydratedViewsRemoved++;\n  }\n  // Reset the value to an empty array to indicate that no\n  // further processing of dehydrated views is needed for\n  // this view container (i.e. do not trigger the lookup process\n  // once again in case a `ViewContainerRef` is created later).\n  lContainer[DEHYDRATED_VIEWS] = EMPTY_ARRAY;\n}\n\n/**\n * Helper function to remove all nodes from a dehydrated view.\n */\nfunction removeDehydratedView(dehydratedView: DehydratedContainerView, renderer: Renderer) {\n  let nodesRemoved = 0;\n  let currentRNode = dehydratedView.firstChild;\n  if (currentRNode) {\n    const numNodes = dehydratedView.data[NUM_ROOT_NODES];\n    while (nodesRemoved < numNodes) {\n      ngDevMode && validateSiblingNodeExists(currentRNode);\n      const nextSibling: RNode = currentRNode.nextSibling!;\n      nativeRemoveNode(renderer, currentRNode, false);\n      currentRNode = nextSibling;\n      nodesRemoved++;\n    }\n  }\n}\n\n/**\n * Walks over all views within this LContainer invokes dehydrated views\n * cleanup function for each one.\n */\nfunction cleanupLContainer(lContainer: LContainer) {\n  removeDehydratedViews(lContainer);\n  for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {\n    cleanupLView(lContainer[i] as LView);\n  }\n}\n\n/**\n * Walks over `LContainer`s and components registered within\n * this LView and invokes dehydrated views cleanup function for each one.\n */\nfunction cleanupLView(lView: LView) {\n  const tView = lView[TVIEW];\n  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {\n    if (isLContainer(lView[i])) {\n      const lContainer = lView[i];\n      cleanupLContainer(lContainer);\n    } else if (Array.isArray(lView[i])) {\n      // This is a component, enter the `cleanupLView` recursively.\n      cleanupLView(lView[i]);\n    }\n  }\n}\n\n/**\n * Walks over all views registered within the ApplicationRef and removes\n * all dehydrated views from all `LContainer`s along the way.\n */\nexport function cleanupDehydratedViews(\n    appRef: ApplicationRef, pendingTasks: InitialRenderPendingTasks) {\n  // Wait once an app becomes stable and cleanup all views that\n  // were not claimed during the application bootstrap process.\n  // The timing is similar to when we kick off serialization on the server.\n  const isStablePromise = appRef.isStable.pipe(first((isStable: boolean) => isStable)).toPromise();\n  const pendingTasksPromise = pendingTasks.whenAllTasksComplete;\n  return Promise.allSettled([isStablePromise, pendingTasksPromise]).then(() => {\n    const viewRefs = appRef._views;\n    for (const viewRef of viewRefs) {\n      const lView = getComponentLViewForHydration(viewRef);\n      // An `lView` might be `null` if a `ViewRef` represents\n      // an embedded view (not a component view).\n      if (lView !== null && lView[HOST] !== null) {\n        cleanupLView(lView);\n        ngDevMode && ngDevMode.dehydratedViewsCleanupRuns++;\n      }\n    }\n  });\n}\n"]}

package/esm2022/src/hydration/compression.mjs

@@ -0,0 +1,69 @@
+/**
+ * @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 { REFERENCE_NODE_BODY, REFERENCE_NODE_HOST } from './interfaces';
+/**
+ * Regexp that extracts a reference node information from the compressed node location.
+ * The reference node is represented as either:
+ *  - a number which points to an LView slot
+ *  - the `b` char which indicates that the lookup should start from the `document.body`
+ *  - the `h` char to start lookup from the component host node (`lView[HOST]`)
+ */
+const REF_EXTRACTOR_REGEXP = new RegExp(`^(\\d+)*(${REFERENCE_NODE_BODY}|${REFERENCE_NODE_HOST})*(.*)`);
+/**
+ * Helper function that takes a reference node location and a set of navigation steps
+ * (from the reference node) to a target node and outputs a string that represents
+ * a location.
+ *
+ * For example, given: referenceNode = 'b' (body) and path = ['firstChild', 'firstChild',
+ * 'nextSibling'], the function returns: `bf2n`.
+ */
+export function compressNodeLocation(referenceNode, path) {
+    const result = [referenceNode];
+    for (const segment of path) {
+        const lastIdx = result.length - 1;
+        if (lastIdx > 0 && result[lastIdx - 1] === segment) {
+            // An empty string in a count slot represents 1 occurrence of an instruction.
+            const value = (result[lastIdx] || 1);
+            result[lastIdx] = value + 1;
+        }
+        else {
+            // Adding a new segment to the path.
+            // Using an empty string in a counter field to avoid encoding `1`s
+            // into the path, since they are implicit (e.g. `f1n1` vs `fn`), so
+            // it's enough to have a single char in this case.
+            result.push(segment, '');
+        }
+    }
+    return result.join('');
+}
+/**
+ * Helper function that reverts the `compressNodeLocation` and transforms a given
+ * string into an array where at 0th position there is a reference node info and
+ * after that it contains information (in pairs) about a navigation step and the
+ * number of repetitions.
+ *
+ * For example, the path like 'bf2n' will be transformed to:
+ * ['b', 'firstChild', 2, 'nextSibling', 1].
+ *
+ * This information is later consumed by the code that navigates the DOM to find
+ * a given node by its location.
+ */
+export function decompressNodeLocation(path) {
+    const matches = path.match(REF_EXTRACTOR_REGEXP);
+    const [_, refNodeId, refNodeName, rest] = matches;
+    // If a reference node is represented by an index, transform it to a number.
+    const ref = refNodeId ? parseInt(refNodeId, 10) : refNodeName;
+    const steps = [];
+    // Match all segments in a path.
+    for (const [_, step, count] of rest.matchAll(/(f|n)(\d*)/g)) {
+        const repeat = parseInt(count, 10) || 1;
+        steps.push(step, repeat);
+    }
+    return [ref, ...steps];
+}
+//# sourceMappingURL=data:application/json;base64,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