@angular/core 16.0.0-next.0 → 16.0.0-next.2

package/esm2020/src/hydration/api.mjs

@@ -0,0 +1,120 @@
+/**
+ * @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 { PLATFORM_ID } from '../application_tokens';
+import { ENVIRONMENT_INITIALIZER, makeEnvironmentProviders } from '../di';
+import { inject } from '../di/injector_compatibility';
+import { enableLocateOrCreateElementNodeImpl } from '../render3/instructions/element';
+import { enableLocateOrCreateElementContainerNodeImpl } from '../render3/instructions/element_container';
+import { enableLocateOrCreateTextNodeImpl } from '../render3/instructions/text';
+import { IS_HYDRATION_FEATURE_ENABLED, PRESERVE_HOST_CONTENT } from './tokens';
+import { enableRetrieveHydrationInfoImpl } from './utils';
+/**
+ * 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();
+    }
+}
+/**
+ * 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(),
+        }
+    ]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/error_handling.mjs

@@ -0,0 +1,29 @@
+/**
+ * @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
+ */
+/**
+ * Verifies whether a given node matches an expected criteria,
+ * based on internal data structure state.
+ */
+export function validateMatchingNode(node, nodeType, tagName, lView, tNode) {
+    if (node.nodeType !== nodeType ||
+        (node.nodeType === Node.ELEMENT_NODE &&
+            node.tagName.toLowerCase() !== tagName?.toLowerCase())) {
+        // TODO: improve error message and use RuntimeError instead.
+        throw new Error(`Unexpected node found during hydration.`);
+    }
+}
+/**
+ * Verifies whether next sibling node exists.
+ */
+export function validateSiblingNodeExists(node) {
+    if (!node.nextSibling) {
+        // TODO: improve error message and use RuntimeError instead.
+        throw new Error(`Unexpected state: insufficient number of sibling nodes.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JfaGFuZGxpbmcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9oeWRyYXRpb24vZXJyb3JfaGFuZGxpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBS0g7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQixDQUNoQyxJQUFVLEVBQUUsUUFBZ0IsRUFBRSxPQUFvQixFQUFFLEtBQVksRUFBRSxLQUFZO0lBQ2hGLElBQUksSUFBSSxDQUFDLFFBQVEsS0FBSyxRQUFRO1FBQzFCLENBQUMsSUFBSSxDQUFDLFFBQVEsS0FBSyxJQUFJLENBQUMsWUFBWTtZQUNsQyxJQUFvQixDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsS0FBSyxPQUFPLEVBQUUsV0FBVyxFQUFFLENBQUMsRUFBRTtRQUM1RSw0REFBNEQ7UUFDNUQsTUFBTSxJQUFJLEtBQUssQ0FBQyx5Q0FBeUMsQ0FBQyxDQUFDO0tBQzVEO0FBQ0gsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLHlCQUF5QixDQUFDLElBQVU7SUFDbEQsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUU7UUFDckIsNERBQTREO1FBQzVELE1BQU0sSUFBSSxLQUFLLENBQUMseURBQXlELENBQUMsQ0FBQztLQUM1RTtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtUTm9kZX0gZnJvbSAnLi4vcmVuZGVyMy9pbnRlcmZhY2VzL25vZGUnO1xuaW1wb3J0IHtMVmlld30gZnJvbSAnLi4vcmVuZGVyMy9pbnRlcmZhY2VzL3ZpZXcnO1xuXG4vKipcbiAqIFZlcmlmaWVzIHdoZXRoZXIgYSBnaXZlbiBub2RlIG1hdGNoZXMgYW4gZXhwZWN0ZWQgY3JpdGVyaWEsXG4gKiBiYXNlZCBvbiBpbnRlcm5hbCBkYXRhIHN0cnVjdHVyZSBzdGF0ZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHZhbGlkYXRlTWF0Y2hpbmdOb2RlKFxuICAgIG5vZGU6IE5vZGUsIG5vZGVUeXBlOiBudW1iZXIsIHRhZ05hbWU6IHN0cmluZ3xudWxsLCBsVmlldzogTFZpZXcsIHROb2RlOiBUTm9kZSk6IHZvaWQge1xuICBpZiAobm9kZS5ub2RlVHlwZSAhPT0gbm9kZVR5cGUgfHxcbiAgICAgIChub2RlLm5vZGVUeXBlID09PSBOb2RlLkVMRU1FTlRfTk9ERSAmJlxuICAgICAgIChub2RlIGFzIEhUTUxFbGVtZW50KS50YWdOYW1lLnRvTG93ZXJDYXNlKCkgIT09IHRhZ05hbWU/LnRvTG93ZXJDYXNlKCkpKSB7XG4gICAgLy8gVE9ETzogaW1wcm92ZSBlcnJvciBtZXNzYWdlIGFuZCB1c2UgUnVudGltZUVycm9yIGluc3RlYWQuXG4gICAgdGhyb3cgbmV3IEVycm9yKGBVbmV4cGVjdGVkIG5vZGUgZm91bmQgZHVyaW5nIGh5ZHJhdGlvbi5gKTtcbiAgfVxufVxuXG4vKipcbiAqIFZlcmlmaWVzIHdoZXRoZXIgbmV4dCBzaWJsaW5nIG5vZGUgZXhpc3RzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdmFsaWRhdGVTaWJsaW5nTm9kZUV4aXN0cyhub2RlOiBOb2RlKTogdm9pZCB7XG4gIGlmICghbm9kZS5uZXh0U2libGluZykge1xuICAgIC8vIFRPRE86IGltcHJvdmUgZXJyb3IgbWVzc2FnZSBhbmQgdXNlIFJ1bnRpbWVFcnJvciBpbnN0ZWFkLlxuICAgIHRocm93IG5ldyBFcnJvcihgVW5leHBlY3RlZCBzdGF0ZTogaW5zdWZmaWNpZW50IG51bWJlciBvZiBzaWJsaW5nIG5vZGVzLmApO1xuICB9XG59XG4iXX0=

package/esm2020/src/hydration/interfaces.mjs

@@ -0,0 +1,10 @@
+/**
+ * @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
+ */
+/* Represents a key in NghDom that holds information about <ng-container>s. */
+export const ELEMENT_CONTAINERS = 'e';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/node_lookup_utils.mjs

@@ -0,0 +1,75 @@
+/**
+ * @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 { HEADER_OFFSET } from '../render3/interfaces/view';
+import { getNativeByTNode } from '../render3/util/view_utils';
+import { assertDefined } from '../util/assert';
+import { validateSiblingNodeExists } from './error_handling';
+/** Whether current TNode is a first node in an <ng-container>. */
+function isFirstElementInNgContainer(tNode) {
+    return !tNode.prev && tNode.parent?.type === 8 /* TNodeType.ElementContainer */;
+}
+/** Returns first element from a DOM segment that corresponds to this <ng-container>. */
+function getDehydratedNgContainer(hydrationInfo, tContainerNode) {
+    const noOffsetIndex = tContainerNode.index - HEADER_OFFSET;
+    const ngContainer = hydrationInfo.ngContainers?.[noOffsetIndex];
+    ngDevMode &&
+        assertDefined(ngContainer, 'Unexpected state: no hydration info available for a given TNode, ' +
+            'which represents an element container.');
+    return ngContainer;
+}
+/**
+ * Locate a node in DOM tree that corresponds to a given TNode.
+ *
+ * @param hydrationInfo The hydration annotation data
+ * @param tView the current tView
+ * @param lView the current lView
+ * @param tNode the current tNode
+ * @returns an RNode that represents a given tNode
+ */
+export function locateNextRNode(hydrationInfo, tView, lView, tNode) {
+    let native = null;
+    if (tView.firstChild === tNode) {
+        // We create a first node in this view, so we use a reference
+        // to the first child in this DOM segment.
+        native = hydrationInfo.firstChild;
+    }
+    else {
+        // Locate a node based on a previous sibling or a parent node.
+        const previousTNodeParent = tNode.prev === null;
+        const previousTNode = (tNode.prev ?? tNode.parent);
+        ngDevMode &&
+            assertDefined(previousTNode, 'Unexpected state: current TNode does not have a connection ' +
+                'to the previous node or a parent node.');
+        const previousRElement = getNativeByTNode(previousTNode, lView);
+        if (isFirstElementInNgContainer(tNode)) {
+            const ngContainer = getDehydratedNgContainer(hydrationInfo, tNode.parent);
+            native = ngContainer.firstChild ?? null;
+        }
+        else {
+            if (previousTNodeParent) {
+                native = previousRElement.firstChild;
+            }
+            else {
+                native = previousRElement.nextSibling;
+            }
+        }
+    }
+    return native;
+}
+/**
+ * Skips over a specified number of nodes and returns the next sibling node after that.
+ */
+export function siblingAfter(skip, from) {
+    let currentNode = from;
+    for (let i = 0; i < skip; i++) {
+        ngDevMode && validateSiblingNodeExists(currentNode);
+        currentNode = currentNode.nextSibling;
+    }
+    return currentNode;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/skip_hydration.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
+ */
+/**
+ * The name of an attribute that can be added to the hydration boundary node
+ * (component host node) to disable hydration for the content within that boundary.
+ */
+export const SKIP_HYDRATION_ATTR_NAME = 'ngSkipHydration';
+/**
+ * Helper function to check if a given node has the 'ngSkipHydration' attribute
+ */
+export function hasNgSkipHydrationAttr(tNode) {
+    const SKIP_HYDRATION_ATTR_NAME_LOWER_CASE = SKIP_HYDRATION_ATTR_NAME.toLowerCase();
+    const attrs = tNode.mergedAttrs;
+    if (attrs === null)
+        return false;
+    // only ever look at the attribute name and skip the values
+    for (let i = 0; i < attrs.length; i += 2) {
+        const value = attrs[i];
+        // This is a marker, which means that the static attributes section is over,
+        // so we can exit early.
+        if (typeof value === 'number')
+            return false;
+        if (typeof value === 'string' && value.toLowerCase() === SKIP_HYDRATION_ATTR_NAME_LOWER_CASE) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/tokens.mjs

@@ -0,0 +1,25 @@
+/**
+ * @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 { InjectionToken } from '../di/injection_token';
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || !!ngDevMode;
+/**
+ * Internal token that specifies whether hydration is enabled.
+ */
+export const IS_HYDRATION_FEATURE_ENABLED = new InjectionToken(NG_DEV_MODE ? 'IS_HYDRATION_FEATURE_ENABLED' : '');
+// By default (in client rendering mode), we remove all the contents
+// of the host element and render an application after that.
+export const PRESERVE_HOST_CONTENT_DEFAULT = false;
+/**
+ * Internal token that indicates whether host element content should be
+ * retained during the bootstrap.
+ */
+export const PRESERVE_HOST_CONTENT = new InjectionToken(NG_DEV_MODE ? 'PRESERVE_HOST_CONTENT' : '', {
+    providedIn: 'root',
+    factory: () => PRESERVE_HOST_CONTENT_DEFAULT,
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/hydration/utils.mjs

@@ -0,0 +1,131 @@
+/**
+ * @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 { isRootView } from '../render3/interfaces/type_checks';
+import { HEADER_OFFSET, TVIEW } from '../render3/interfaces/view';
+import { makeStateKey, TransferState } from '../transfer_state';
+import { assertDefined } from '../util/assert';
+import { ELEMENT_CONTAINERS } from './interfaces';
+/**
+ * The name of the key used in the TransferState collection,
+ * where hydration information is located.
+ */
+const TRANSFER_STATE_TOKEN_ID = '__ɵnghData__';
+/**
+ * Lookup key used to reference DOM hydration data (ngh) in `TransferState`.
+ */
+export const NGH_DATA_KEY = makeStateKey(TRANSFER_STATE_TOKEN_ID);
+/**
+ * The name of the attribute that would be added to host component
+ * nodes and contain a reference to a particular slot in transferred
+ * state that contains the necessary hydration info for this component.
+ */
+export const NGH_ATTR_NAME = 'ngh';
+/**
+ * Reference to a function that reads `ngh` attribute value from a given RNode
+ * and retrieves hydration information from the TransferState using that value
+ * as an index. Returns `null` by default, when hydration is not enabled.
+ *
+ * @param rNode Component's host element.
+ * @param injector Injector that this component has access to.
+ */
+let _retrieveHydrationInfoImpl = (rNode, injector) => null;
+export function retrieveHydrationInfoImpl(rNode, injector) {
+    const nghAttrValue = rNode.getAttribute(NGH_ATTR_NAME);
+    if (nghAttrValue == null)
+        return null;
+    let data = {};
+    // An element might have an empty `ngh` attribute value (e.g. `<comp ngh="" />`),
+    // which means that no special annotations are required. Do not attempt to read
+    // from the TransferState in this case.
+    if (nghAttrValue !== '') {
+        const transferState = injector.get(TransferState, null, { optional: true });
+        if (transferState !== null) {
+            const nghData = transferState.get(NGH_DATA_KEY, []);
+            // The nghAttrValue is always a number referencing an index
+            // in the hydration TransferState data.
+            data = nghData[Number(nghAttrValue)];
+            // If the `ngh` attribute exists and has a non-empty value,
+            // the hydration info *must* be present in the TransferState.
+            // If there is no data for some reasons, this is an error.
+            ngDevMode && assertDefined(data, 'Unable to retrieve hydration info from the TransferState.');
+        }
+    }
+    const dehydratedView = {
+        data,
+        firstChild: rNode.firstChild ?? null,
+    };
+    // The `ngh` attribute is cleared from the DOM node now
+    // that the data has been retrieved.
+    rNode.removeAttribute(NGH_ATTR_NAME);
+    // Note: don't check whether this node was claimed for hydration,
+    // because this node might've been previously claimed while processing
+    // template instructions.
+    ngDevMode && markRNodeAsClaimedByHydration(rNode, /* checkIfAlreadyClaimed */ false);
+    ngDevMode && ngDevMode.hydratedComponents++;
+    return dehydratedView;
+}
+/**
+ * Sets the implementation for the `retrieveNghInfo` function.
+ */
+export function enableRetrieveHydrationInfoImpl() {
+    _retrieveHydrationInfoImpl = retrieveHydrationInfoImpl;
+}
+/**
+ * Retrieves hydration info by reading the value from the `ngh` attribute
+ * and accessing a corresponding slot in TransferState storage.
+ */
+export function retrieveHydrationInfo(rNode, injector) {
+    return _retrieveHydrationInfoImpl(rNode, injector);
+}
+/**
+ * Retrieves an instance of a component LView from a given ViewRef.
+ * Returns an instance of a component LView or `null` in case of an embedded view.
+ */
+export function getComponentLViewForHydration(viewRef) {
+    // Reading an internal field from `ViewRef` instance.
+    let lView = viewRef._lView;
+    const tView = lView[TVIEW];
+    // A registered ViewRef might represent an instance of an
+    // embedded view, in which case we do not need to annotate it.
+    if (tView.type === 2 /* TViewType.Embedded */) {
+        return null;
+    }
+    // Check if it's a root view and if so, retrieve component's
+    // LView from the first slot after the header.
+    if (isRootView(lView)) {
+        lView = lView[HEADER_OFFSET];
+    }
+    return lView;
+}
+/**
+ * Marks a node as "claimed" by hydration process.
+ * This is needed to make assessments in tests whether
+ * the hydration process handled all nodes.
+ */
+export function markRNodeAsClaimedByHydration(node, checkIfAlreadyClaimed = true) {
+    if (!ngDevMode) {
+        throw new Error('Calling `markRNodeAsClaimedByHydration` in prod mode ' +
+            'is not supported and likely a mistake.');
+    }
+    if (checkIfAlreadyClaimed && isRNodeClaimedForHydration(node)) {
+        throw new Error('Trying to claim a node, which was claimed already.');
+    }
+    node.__claimed = true;
+    ngDevMode.hydratedNodes++;
+}
+export function isRNodeClaimedForHydration(node) {
+    return !!node.__claimed;
+}
+export function storeNgContainerInfo(hydrationInfo, index, firstChild) {
+    hydrationInfo.ngContainers ?? (hydrationInfo.ngContainers = {});
+    hydrationInfo.ngContainers[index] = { firstChild };
+}
+export function getNgContainerSize(hydrationInfo, index) {
+    return hydrationInfo.data[ELEMENT_CONTAINERS]?.[index] ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/utils.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAKH,OAAO,EAAC,UAAU,EAAC,MAAM,mCAAmC,CAAC;AAC7D,OAAO,EAAC,aAAa,EAAS,KAAK,EAAY,MAAM,4BAA4B,CAAC;AAClF,OAAO,EAAC,YAAY,EAAE,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAC,aAAa,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAiB,kBAAkB,EAAiB,MAAM,cAAc,CAAC;AAEhF;;;GAGG;AACH,MAAM,uBAAuB,GAAG,cAAc,CAAC;AAE/C;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,YAAY,CAAwB,uBAAuB,CAAC,CAAC;AAEzF;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAC;AAEnC;;;;;;;GAOG;AACH,IAAI,0BAA0B,GAC1B,CAAC,KAAe,EAAE,QAAkB,EAAE,EAAE,CAAC,IAAI,CAAC;AAElD,MAAM,UAAU,yBAAyB,CAAC,KAAe,EAAE,QAAkB;IAE3E,MAAM,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IACvD,IAAI,YAAY,IAAI,IAAI;QAAE,OAAO,IAAI,CAAC;IAEtC,IAAI,IAAI,GAAmB,EAAE,CAAC;IAC9B,iFAAiF;IACjF,+EAA+E;IAC/E,uCAAuC;IACvC,IAAI,YAAY,KAAK,EAAE,EAAE;QACvB,MAAM,aAAa,GAAG,QAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,IAAI,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QAC1E,IAAI,aAAa,KAAK,IAAI,EAAE;YAC1B,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;YAEpD,2DAA2D;YAC3D,uCAAuC;YACvC,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;YAErC,2DAA2D;YAC3D,6DAA6D;YAC7D,0DAA0D;YAC1D,SAAS,IAAI,aAAa,CAAC,IAAI,EAAE,2DAA2D,CAAC,CAAC;SAC/F;KACF;IACD,MAAM,cAAc,GAAmB;QACrC,IAAI;QACJ,UAAU,EAAE,KAAK,CAAC,UAAU,IAAI,IAAI;KACrC,CAAC;IACF,uDAAuD;IACvD,oCAAoC;IACpC,KAAK,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;IAErC,iEAAiE;IACjE,sEAAsE;IACtE,yBAAyB;IACzB,SAAS,IAAI,6BAA6B,CAAC,KAAK,EAAE,2BAA2B,CAAC,KAAK,CAAC,CAAC;IACrF,SAAS,IAAI,SAAS,CAAC,kBAAkB,EAAE,CAAC;IAE5C,OAAO,cAAc,CAAC;AACxB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,+BAA+B;IAC7C,0BAA0B,GAAG,yBAAyB,CAAC;AACzD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAe,EAAE,QAAkB;IACvE,OAAO,0BAA0B,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;AACrD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,6BAA6B,CAAC,OAAgB;IAC5D,qDAAqD;IACrD,IAAI,KAAK,GAAI,OAAe,CAAC,MAAe,CAAC;IAC7C,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAC3B,yDAAyD;IACzD,8DAA8D;IAC9D,IAAI,KAAK,CAAC,IAAI,+BAAuB,EAAE;QACrC,OAAO,IAAI,CAAC;KACb;IACD,4DAA4D;IAC5D,8CAA8C;IAC9C,IAAI,UAAU,CAAC,KAAK,CAAC,EAAE;QACrB,KAAK,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC;KAC9B;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAUD;;;;GAIG;AACH,MAAM,UAAU,6BAA6B,CAAC,IAAW,EAAE,qBAAqB,GAAG,IAAI;IACrF,IAAI,CAAC,SAAS,EAAE;QACd,MAAM,IAAI,KAAK,CACX,uDAAuD;YACvD,wCAAwC,CAAC,CAAC;KAC/C;IACD,IAAI,qBAAqB,IAAI,0BAA0B,CAAC,IAAI,CAAC,EAAE;QAC7D,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;KACvE;IACA,IAAoB,CAAC,SAAS,GAAG,IAAI,CAAC;IACvC,SAAS,CAAC,aAAa,EAAE,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,IAAW;IACpD,OAAO,CAAC,CAAE,IAAoB,CAAC,SAAS,CAAC;AAC3C,CAAC;AAED,MAAM,UAAU,oBAAoB,CAChC,aAA6B,EAAE,KAAa,EAAE,UAAiB;IACjE,aAAa,CAAC,YAAY,KAA1B,aAAa,CAAC,YAAY,GAAK,EAAE,EAAC;IAClC,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,EAAC,UAAU,EAAC,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,kBAAkB,CAAC,aAA6B,EAAE,KAAa;IAC7E,OAAO,aAAa,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC;AACjE,CAAC","sourcesContent":["\n/**\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 {Injector} from '../di/injector';\nimport {ViewRef} from '../linker/view_ref';\nimport {RElement, RNode} from '../render3/interfaces/renderer_dom';\nimport {isRootView} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, LView, TVIEW, TViewType} from '../render3/interfaces/view';\nimport {makeStateKey, TransferState} from '../transfer_state';\nimport {assertDefined} from '../util/assert';\n\nimport {DehydratedView, ELEMENT_CONTAINERS, SerializedView} from './interfaces';\n\n/**\n * The name of the key used in the TransferState collection,\n * where hydration information is located.\n */\nconst TRANSFER_STATE_TOKEN_ID = '__ɵnghData__';\n\n/**\n * Lookup key used to reference DOM hydration data (ngh) in `TransferState`.\n */\nexport const NGH_DATA_KEY = makeStateKey<Array<SerializedView>>(TRANSFER_STATE_TOKEN_ID);\n\n/**\n * The name of the attribute that would be added to host component\n * nodes and contain a reference to a particular slot in transferred\n * state that contains the necessary hydration info for this component.\n */\nexport const NGH_ATTR_NAME = 'ngh';\n\n/**\n * Reference to a function that reads `ngh` attribute value from a given RNode\n * and retrieves hydration information from the TransferState using that value\n * as an index. Returns `null` by default, when hydration is not enabled.\n *\n * @param rNode Component's host element.\n * @param injector Injector that this component has access to.\n */\nlet _retrieveHydrationInfoImpl: typeof retrieveHydrationInfoImpl =\n    (rNode: RElement, injector: Injector) => null;\n\nexport function retrieveHydrationInfoImpl(rNode: RElement, injector: Injector): DehydratedView|\n    null {\n  const nghAttrValue = rNode.getAttribute(NGH_ATTR_NAME);\n  if (nghAttrValue == null) return null;\n\n  let data: SerializedView = {};\n  // An element might have an empty `ngh` attribute value (e.g. `<comp ngh=\"\" />`),\n  // which means that no special annotations are required. Do not attempt to read\n  // from the TransferState in this case.\n  if (nghAttrValue !== '') {\n    const transferState = injector.get(TransferState, null, {optional: true});\n    if (transferState !== null) {\n      const nghData = transferState.get(NGH_DATA_KEY, []);\n\n      // The nghAttrValue is always a number referencing an index\n      // in the hydration TransferState data.\n      data = nghData[Number(nghAttrValue)];\n\n      // If the `ngh` attribute exists and has a non-empty value,\n      // the hydration info *must* be present in the TransferState.\n      // If there is no data for some reasons, this is an error.\n      ngDevMode && assertDefined(data, 'Unable to retrieve hydration info from the TransferState.');\n    }\n  }\n  const dehydratedView: DehydratedView = {\n    data,\n    firstChild: rNode.firstChild ?? null,\n  };\n  // The `ngh` attribute is cleared from the DOM node now\n  // that the data has been retrieved.\n  rNode.removeAttribute(NGH_ATTR_NAME);\n\n  // Note: don't check whether this node was claimed for hydration,\n  // because this node might've been previously claimed while processing\n  // template instructions.\n  ngDevMode && markRNodeAsClaimedByHydration(rNode, /* checkIfAlreadyClaimed */ false);\n  ngDevMode && ngDevMode.hydratedComponents++;\n\n  return dehydratedView;\n}\n\n/**\n * Sets the implementation for the `retrieveNghInfo` function.\n */\nexport function enableRetrieveHydrationInfoImpl() {\n  _retrieveHydrationInfoImpl = retrieveHydrationInfoImpl;\n}\n\n/**\n * Retrieves hydration info by reading the value from the `ngh` attribute\n * and accessing a corresponding slot in TransferState storage.\n */\nexport function retrieveHydrationInfo(rNode: RElement, injector: Injector): DehydratedView|null {\n  return _retrieveHydrationInfoImpl(rNode, injector);\n}\n\n/**\n * Retrieves an instance of a component LView from a given ViewRef.\n * Returns an instance of a component LView or `null` in case of an embedded view.\n */\nexport function getComponentLViewForHydration(viewRef: ViewRef): LView|null {\n  // Reading an internal field from `ViewRef` instance.\n  let lView = (viewRef as any)._lView as LView;\n  const tView = lView[TVIEW];\n  // A registered ViewRef might represent an instance of an\n  // embedded view, in which case we do not need to annotate it.\n  if (tView.type === TViewType.Embedded) {\n    return null;\n  }\n  // Check if it's a root view and if so, retrieve component's\n  // LView from the first slot after the header.\n  if (isRootView(lView)) {\n    lView = lView[HEADER_OFFSET];\n  }\n  return lView;\n}\n\n/**\n * Internal type that represents a claimed node.\n * Only used in dev mode.\n */\ntype ClaimedNode = {\n  __claimed?: boolean;\n};\n\n/**\n * Marks a node as \"claimed\" by hydration process.\n * This is needed to make assessments in tests whether\n * the hydration process handled all nodes.\n */\nexport function markRNodeAsClaimedByHydration(node: RNode, checkIfAlreadyClaimed = true) {\n  if (!ngDevMode) {\n    throw new Error(\n        'Calling `markRNodeAsClaimedByHydration` in prod mode ' +\n        'is not supported and likely a mistake.');\n  }\n  if (checkIfAlreadyClaimed && isRNodeClaimedForHydration(node)) {\n    throw new Error('Trying to claim a node, which was claimed already.');\n  }\n  (node as ClaimedNode).__claimed = true;\n  ngDevMode.hydratedNodes++;\n}\n\nexport function isRNodeClaimedForHydration(node: RNode): boolean {\n  return !!(node as ClaimedNode).__claimed;\n}\n\nexport function storeNgContainerInfo(\n    hydrationInfo: DehydratedView, index: number, firstChild: RNode): void {\n  hydrationInfo.ngContainers ??= {};\n  hydrationInfo.ngContainers[index] = {firstChild};\n}\n\nexport function getNgContainerSize(hydrationInfo: DehydratedView, index: number): number|null {\n  return hydrationInfo.data[ELEMENT_CONTAINERS]?.[index] ?? null;\n}\n"]}

package/esm2020/src/linker/compiler.mjs

@@ -44,7 +44,7 @@ export class ModuleWithComponentFactories {
  * See [JIT API changes due to ViewEngine deprecation](guide/deprecations#jit-api-changes) for
  * additional context.
  */
-export class Compiler {
+class Compiler {
     /**
      * Compiles the given NgModule and all of its components. All templates of the components listed
      * in `entryComponents` have to be inlined.
@@ -95,6 +95,7 @@ export class Compiler {
 }
 Compiler.ɵfac = function Compiler_Factory(t) { return new (t || Compiler)(); };
 Compiler.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: Compiler, factory: Compiler.ɵfac, providedIn: 'root' });
+export { Compiler };
 (function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.setClassMetadata(Compiler, [{
         type: Injectable,
         args: [{ providedIn: 'root' }]
@@ -117,4 +118,4 @@ export const COMPILER_OPTIONS = new InjectionToken('compilerOptions');
  */
 export class CompilerFactory {
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/compiler.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAKrD,OAAO,EAAC,gBAAgB,IAAI,kBAAkB,EAAC,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAAC,eAAe,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAC,eAAe,IAAI,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;;AAKzD;;;;;;;;;GASG;AACH,MAAM,OAAO,4BAA4B;IACvC,YACW,eAAmC,EACnC,kBAA2C;QAD3C,oBAAe,GAAf,eAAe,CAAoB;QACnC,uBAAkB,GAAlB,kBAAkB,CAAyB;IAAG,CAAC;CAC3D;AAED;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,OAAO,QAAQ;IACnB;;;OAGG;IACH,iBAAiB,CAAI,UAAmB;QACtC,OAAO,IAAI,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAI,UAAmB;QACvC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACH,iCAAiC,CAAI,UAAmB;QACtD,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC3D,MAAM,SAAS,GAAG,cAAc,CAAC,UAAU,CAAE,CAAC;QAC9C,MAAM,kBAAkB,GACpB,aAAa,CAAC,SAAS,CAAC,YAAY,CAAC;aAChC,MAAM,CAAC,CAAC,SAAkC,EAAE,WAAsB,EAAE,EAAE;YACrE,MAAM,YAAY,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC;YAClD,YAAY,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,YAAY,CAAC,CAAC,CAAC;YACrE,OAAO,SAAS,CAAC;QACnB,CAAC,EAAE,EAA6B,CAAC,CAAC;QAC1C,OAAO,IAAI,4BAA4B,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAC;IAC/E,CAAC;IAED;;OAEG;IACH,kCAAkC,CAAI,UAAmB;QAEvD,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iCAAiC,CAAC,UAAU,CAAC,CAAC,CAAC;IAC7E,CAAC;IAED;;OAEG;IACH,UAAU,KAAU,CAAC;IAErB;;OAEG;IACH,aAAa,CAAC,IAAe,IAAG,CAAC;IAEjC;;OAEG;IACH,WAAW,CAAC,UAAqB;QAC/B,OAAO,SAAS,CAAC;IACnB,CAAC;;gEAvDU,QAAQ;8DAAR,QAAQ,WAAR,QAAQ,mBADI,MAAM;sFAClB,QAAQ;cADpB,UAAU;eAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;AAiFhC;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,cAAc,CAAoB,iBAAiB,CAAC,CAAC;AAEzF;;;;;;;;;GASG;AACH,MAAM,OAAgB,eAAe;CAEpC","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 {Injectable} from '../di/injectable';\nimport {InjectionToken} from '../di/injection_token';\nimport {StaticProvider} from '../di/interface/provider';\nimport {MissingTranslationStrategy} from '../i18n/tokens';\nimport {Type} from '../interface/type';\nimport {ViewEncapsulation} from '../metadata/view';\nimport {ComponentFactory as ComponentFactoryR3} from '../render3/component_ref';\nimport {getComponentDef, getNgModuleDef} from '../render3/definition';\nimport {NgModuleFactory as NgModuleFactoryR3} from '../render3/ng_module_ref';\nimport {maybeUnwrapFn} from '../render3/util/misc_utils';\n\nimport {ComponentFactory} from './component_factory';\nimport {NgModuleFactory} from './ng_module_factory';\n\n/**\n * Combination of NgModuleFactory and ComponentFactories.\n *\n * @publicApi\n *\n * @deprecated\n * Ivy JIT mode doesn't require accessing this symbol.\n * See [JIT API changes due to ViewEngine deprecation](guide/deprecations#jit-api-changes) for\n * additional context.\n */\nexport class ModuleWithComponentFactories<T> {\n  constructor(\n      public ngModuleFactory: NgModuleFactory<T>,\n      public componentFactories: ComponentFactory<any>[]) {}\n}\n\n/**\n * Low-level service for running the angular compiler during runtime\n * to create {@link ComponentFactory}s, which\n * can later be used to create and render a Component instance.\n *\n * Each `@NgModule` provides an own `Compiler` to its injector,\n * that will use the directives/pipes of the ng module for compilation\n * of components.\n *\n * @publicApi\n *\n * @deprecated\n * Ivy JIT mode doesn't require accessing this symbol.\n * See [JIT API changes due to ViewEngine deprecation](guide/deprecations#jit-api-changes) for\n * additional context.\n */\n@Injectable({providedIn: 'root'})\nexport class Compiler {\n  /**\n   * Compiles the given NgModule and all of its components. All templates of the components listed\n   * in `entryComponents` have to be inlined.\n   */\n  compileModuleSync<T>(moduleType: Type<T>): NgModuleFactory<T> {\n    return new NgModuleFactoryR3(moduleType);\n  }\n\n  /**\n   * Compiles the given NgModule and all of its components\n   */\n  compileModuleAsync<T>(moduleType: Type<T>): Promise<NgModuleFactory<T>> {\n    return Promise.resolve(this.compileModuleSync(moduleType));\n  }\n\n  /**\n   * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsSync<T>(moduleType: Type<T>): ModuleWithComponentFactories<T> {\n    const ngModuleFactory = this.compileModuleSync(moduleType);\n    const moduleDef = getNgModuleDef(moduleType)!;\n    const componentFactories =\n        maybeUnwrapFn(moduleDef.declarations)\n            .reduce((factories: ComponentFactory<any>[], declaration: Type<any>) => {\n              const componentDef = getComponentDef(declaration);\n              componentDef && factories.push(new ComponentFactoryR3(componentDef));\n              return factories;\n            }, [] as ComponentFactory<any>[]);\n    return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);\n  }\n\n  /**\n   * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsAsync<T>(moduleType: Type<T>):\n      Promise<ModuleWithComponentFactories<T>> {\n    return Promise.resolve(this.compileModuleAndAllComponentsSync(moduleType));\n  }\n\n  /**\n   * Clears all caches.\n   */\n  clearCache(): void {}\n\n  /**\n   * Clears the cache for the given component/ngModule.\n   */\n  clearCacheFor(type: Type<any>) {}\n\n  /**\n   * Returns the id for a given NgModule, if one is defined and known to the compiler.\n   */\n  getModuleId(moduleType: Type<any>): string|undefined {\n    return undefined;\n  }\n}\n\n/**\n * Options for creating a compiler.\n *\n * Note: the `useJit` and `missingTranslation` config options are not used in Ivy, passing them has\n * no effect. Those config options are deprecated since v13.\n *\n * @publicApi\n */\nexport type CompilerOptions = {\n  /**\n   * @deprecated not used at all in Ivy, providing this config option has no effect.\n   */\n  useJit?: boolean,\n  defaultEncapsulation?: ViewEncapsulation,\n  providers?: StaticProvider[],\n  /**\n   * @deprecated not used at all in Ivy, providing this config option has no effect.\n   */\n  missingTranslation?: MissingTranslationStrategy,\n  preserveWhitespaces?: boolean,\n};\n\n/**\n * Token to provide CompilerOptions in the platform injector.\n *\n * @publicApi\n */\nexport const COMPILER_OPTIONS = new InjectionToken<CompilerOptions[]>('compilerOptions');\n\n/**\n * A factory for creating a Compiler\n *\n * @publicApi\n *\n * @deprecated\n * Ivy JIT mode doesn't require accessing this symbol.\n * See [JIT API changes due to ViewEngine deprecation](guide/deprecations#jit-api-changes) for\n * additional context.\n */\nexport abstract class CompilerFactory {\n  abstract createCompiler(options?: CompilerOptions[]): Compiler;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compiler.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/linker/compiler.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAKrD,OAAO,EAAC,gBAAgB,IAAI,kBAAkB,EAAC,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAAC,eAAe,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAC,eAAe,IAAI,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAAC,aAAa,EAAC,MAAM,4BAA4B,CAAC;;AAKzD;;;;;;;;;GASG;AACH,MAAM,OAAO,4BAA4B;IACvC,YACW,eAAmC,EACnC,kBAA2C;QAD3C,oBAAe,GAAf,eAAe,CAAoB;QACnC,uBAAkB,GAAlB,kBAAkB,CAAyB;IAAG,CAAC;CAC3D;AAED;;;;;;;;;;;;;;;GAeG;AACH,MACa,QAAQ;IACnB;;;OAGG;IACH,iBAAiB,CAAI,UAAmB;QACtC,OAAO,IAAI,iBAAiB,CAAC,UAAU,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,kBAAkB,CAAI,UAAmB;QACvC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACH,iCAAiC,CAAI,UAAmB;QACtD,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC3D,MAAM,SAAS,GAAG,cAAc,CAAC,UAAU,CAAE,CAAC;QAC9C,MAAM,kBAAkB,GACpB,aAAa,CAAC,SAAS,CAAC,YAAY,CAAC;aAChC,MAAM,CAAC,CAAC,SAAkC,EAAE,WAAsB,EAAE,EAAE;YACrE,MAAM,YAAY,GAAG,eAAe,CAAC,WAAW,CAAC,CAAC;YAClD,YAAY,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,kBAAkB,CAAC,YAAY,CAAC,CAAC,CAAC;YACrE,OAAO,SAAS,CAAC;QACnB,CAAC,EAAE,EAA6B,CAAC,CAAC;QAC1C,OAAO,IAAI,4BAA4B,CAAC,eAAe,EAAE,kBAAkB,CAAC,CAAC;IAC/E,CAAC;IAED;;OAEG;IACH,kCAAkC,CAAI,UAAmB;QAEvD,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,iCAAiC,CAAC,UAAU,CAAC,CAAC,CAAC;IAC7E,CAAC;IAED;;OAEG;IACH,UAAU,KAAU,CAAC;IAErB;;OAEG;IACH,aAAa,CAAC,IAAe,IAAG,CAAC;IAEjC;;OAEG;IACH,WAAW,CAAC,UAAqB;QAC/B,OAAO,SAAS,CAAC;IACnB,CAAC;;gEAvDU,QAAQ;8DAAR,QAAQ,WAAR,QAAQ,mBADI,MAAM;SAClB,QAAQ;sFAAR,QAAQ;cADpB,UAAU;eAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;AAiFhC;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,cAAc,CAAoB,iBAAiB,CAAC,CAAC;AAEzF;;;;;;;;;GASG;AACH,MAAM,OAAgB,eAAe;CAEpC","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 {Injectable} from '../di/injectable';\nimport {InjectionToken} from '../di/injection_token';\nimport {StaticProvider} from '../di/interface/provider';\nimport {MissingTranslationStrategy} from '../i18n/tokens';\nimport {Type} from '../interface/type';\nimport {ViewEncapsulation} from '../metadata/view';\nimport {ComponentFactory as ComponentFactoryR3} from '../render3/component_ref';\nimport {getComponentDef, getNgModuleDef} from '../render3/definition';\nimport {NgModuleFactory as NgModuleFactoryR3} from '../render3/ng_module_ref';\nimport {maybeUnwrapFn} from '../render3/util/misc_utils';\n\nimport {ComponentFactory} from './component_factory';\nimport {NgModuleFactory} from './ng_module_factory';\n\n/**\n * Combination of NgModuleFactory and ComponentFactories.\n *\n * @publicApi\n *\n * @deprecated\n * Ivy JIT mode doesn't require accessing this symbol.\n * See [JIT API changes due to ViewEngine deprecation](guide/deprecations#jit-api-changes) for\n * additional context.\n */\nexport class ModuleWithComponentFactories<T> {\n  constructor(\n      public ngModuleFactory: NgModuleFactory<T>,\n      public componentFactories: ComponentFactory<any>[]) {}\n}\n\n/**\n * Low-level service for running the angular compiler during runtime\n * to create {@link ComponentFactory}s, which\n * can later be used to create and render a Component instance.\n *\n * Each `@NgModule` provides an own `Compiler` to its injector,\n * that will use the directives/pipes of the ng module for compilation\n * of components.\n *\n * @publicApi\n *\n * @deprecated\n * Ivy JIT mode doesn't require accessing this symbol.\n * See [JIT API changes due to ViewEngine deprecation](guide/deprecations#jit-api-changes) for\n * additional context.\n */\n@Injectable({providedIn: 'root'})\nexport class Compiler {\n  /**\n   * Compiles the given NgModule and all of its components. All templates of the components listed\n   * in `entryComponents` have to be inlined.\n   */\n  compileModuleSync<T>(moduleType: Type<T>): NgModuleFactory<T> {\n    return new NgModuleFactoryR3(moduleType);\n  }\n\n  /**\n   * Compiles the given NgModule and all of its components\n   */\n  compileModuleAsync<T>(moduleType: Type<T>): Promise<NgModuleFactory<T>> {\n    return Promise.resolve(this.compileModuleSync(moduleType));\n  }\n\n  /**\n   * Same as {@link #compileModuleSync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsSync<T>(moduleType: Type<T>): ModuleWithComponentFactories<T> {\n    const ngModuleFactory = this.compileModuleSync(moduleType);\n    const moduleDef = getNgModuleDef(moduleType)!;\n    const componentFactories =\n        maybeUnwrapFn(moduleDef.declarations)\n            .reduce((factories: ComponentFactory<any>[], declaration: Type<any>) => {\n              const componentDef = getComponentDef(declaration);\n              componentDef && factories.push(new ComponentFactoryR3(componentDef));\n              return factories;\n            }, [] as ComponentFactory<any>[]);\n    return new ModuleWithComponentFactories(ngModuleFactory, componentFactories);\n  }\n\n  /**\n   * Same as {@link #compileModuleAsync} but also creates ComponentFactories for all components.\n   */\n  compileModuleAndAllComponentsAsync<T>(moduleType: Type<T>):\n      Promise<ModuleWithComponentFactories<T>> {\n    return Promise.resolve(this.compileModuleAndAllComponentsSync(moduleType));\n  }\n\n  /**\n   * Clears all caches.\n   */\n  clearCache(): void {}\n\n  /**\n   * Clears the cache for the given component/ngModule.\n   */\n  clearCacheFor(type: Type<any>) {}\n\n  /**\n   * Returns the id for a given NgModule, if one is defined and known to the compiler.\n   */\n  getModuleId(moduleType: Type<any>): string|undefined {\n    return undefined;\n  }\n}\n\n/**\n * Options for creating a compiler.\n *\n * Note: the `useJit` and `missingTranslation` config options are not used in Ivy, passing them has\n * no effect. Those config options are deprecated since v13.\n *\n * @publicApi\n */\nexport type CompilerOptions = {\n  /**\n   * @deprecated not used at all in Ivy, providing this config option has no effect.\n   */\n  useJit?: boolean,\n  defaultEncapsulation?: ViewEncapsulation,\n  providers?: StaticProvider[],\n  /**\n   * @deprecated not used at all in Ivy, providing this config option has no effect.\n   */\n  missingTranslation?: MissingTranslationStrategy,\n  preserveWhitespaces?: boolean,\n};\n\n/**\n * Token to provide CompilerOptions in the platform injector.\n *\n * @publicApi\n */\nexport const COMPILER_OPTIONS = new InjectionToken<CompilerOptions[]>('compilerOptions');\n\n/**\n * A factory for creating a Compiler\n *\n * @publicApi\n *\n * @deprecated\n * Ivy JIT mode doesn't require accessing this symbol.\n * See [JIT API changes due to ViewEngine deprecation](guide/deprecations#jit-api-changes) for\n * additional context.\n */\nexport abstract class CompilerFactory {\n  abstract createCompiler(options?: CompilerOptions[]): Compiler;\n}\n"]}

package/esm2020/src/linker/component_factory_resolver.mjs

@@ -35,7 +35,8 @@ class _NullComponentFactoryResolver {
  * @deprecated Angular no longer requires Component factories. Please use other APIs where
  *     Component class can be used directly.
  */
-export class ComponentFactoryResolver {
+class ComponentFactoryResolver {
 }
 ComponentFactoryResolver.NULL = ( /* @__PURE__ */new _NullComponentFactoryResolver());
-//# sourceMappingURL=data:application/json;base64,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
+export { ComponentFactoryResolver };
+//# sourceMappingURL=data:application/json;base64,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