@angular/core 17.3.0-next.1 → 17.3.0

package/esm2022/src/authoring/model/model.mjs

@@ -5,12 +5,15 @@
  * 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 { assertInInjectionContext } from '../../di';
 import { REQUIRED_UNSET_VALUE } from '../input/input_signal_node';
 import { createModelSignal } from './model_signal';
 export function modelFunction(initialValue) {
+    ngDevMode && assertInInjectionContext(model);
     return createModelSignal(initialValue);
 }
 export function modelRequiredFunction() {
+    ngDevMode && assertInInjectionContext(model);
     return createModelSignal(REQUIRED_UNSET_VALUE);
 }
 /**
@@ -47,4 +50,4 @@ export const model = (() => {
     modelFunction.required = modelRequiredFunction;
     return modelFunction;
 })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/model/model_signal.mjs

@@ -7,8 +7,10 @@
  */
 import { producerAccessed, SIGNAL, signalSetFn } from '@angular/core/primitives/signals';
 import { RuntimeError } from '../../errors';
+import { signalAsReadonlyFn } from '../../render3/reactivity/signal';
 import { ɵINPUT_SIGNAL_BRAND_READ_TYPE, ɵINPUT_SIGNAL_BRAND_WRITE_TYPE } from '../input/input_signal';
 import { INPUT_SIGNAL_NODE, REQUIRED_UNSET_VALUE } from '../input/input_signal_node';
+import { OutputEmitterRef } from '../output/output_emitter_ref';
 /**
  * Creates a model signal.
  *
@@ -17,40 +19,29 @@ import { INPUT_SIGNAL_NODE, REQUIRED_UNSET_VALUE } from '../input/input_signal_n
  * @param options Additional options for the model.
  */
 export function createModelSignal(initialValue) {
-    const subscriptions = [];
     const node = Object.create(INPUT_SIGNAL_NODE);
+    const emitterRef = new OutputEmitterRef();
     node.value = initialValue;
     function getter() {
         producerAccessed(node);
         assertModelSet(node.value);
         return node.value;
     }
-    function notifySubscribers(value) {
-        for (let i = 0; i < subscriptions.length; i++) {
-            subscriptions[i](value);
-        }
-    }
     getter[SIGNAL] = node;
-    getter.asReadonly = (() => getter());
+    getter.asReadonly = signalAsReadonlyFn.bind(getter);
+    // TODO: Should we throw an error when updating a destroyed model?
     getter.set = (newValue) => {
         if (!node.equal(node.value, newValue)) {
             signalSetFn(node, newValue);
-            notifySubscribers(newValue);
+            emitterRef.emit(newValue);
         }
     };
     getter.update = (updateFn) => {
         assertModelSet(node.value);
         getter.set(updateFn(node.value));
     };
-    getter.subscribe = (callback) => {
-        subscriptions.push(callback);
-        return () => {
-            const index = subscriptions.indexOf(callback);
-            if (index > -1) {
-                subscriptions.splice(index, 1);
-            }
-        };
-    };
+    getter.subscribe = emitterRef.subscribe.bind(emitterRef);
+    getter.destroyRef = emitterRef.destroyRef;
     if (ngDevMode) {
         getter.toString = () => `[Model Signal: ${getter()}]`;
     }
@@ -62,4 +53,4 @@ function assertModelSet(value) {
         throw new RuntimeError(-952 /* RuntimeErrorCode.REQUIRED_MODEL_NO_VALUE */, ngDevMode && 'Model is required but no value is available yet.');
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/output/output.mjs

@@ -0,0 +1,35 @@
+/**
+ * @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 { assertInInjectionContext } from '../../di';
+import { OutputEmitterRef } from './output_emitter_ref';
+/**
+ * The `output` function allows declaration of outputs in directives and
+ * components.
+ *
+ * Initializes an output that can emit values to consumers of your
+ * directive/component.
+ *
+ * @usageNotes
+ * Initialize an output in your directive by declaring a
+ * class field and initializing it with the `output()` function.
+ *
+ * ```ts
+ * @Directive({..})
+ * export class MyDir {
+ *   nameChange = output<string>();     // OutputEmitterRef<string>
+ *   onClick = output();                // OutputEmitterRef<void>
+ * }
+ * ```
+ *
+ * @developerPreview
+ */
+export function output(opts) {
+    ngDevMode && assertInInjectionContext(output);
+    return new OutputEmitterRef();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/output/output_emitter_ref.mjs

@@ -0,0 +1,85 @@
+/**
+ * @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 { setActiveConsumer } from '@angular/core/primitives/signals';
+import { inject } from '../../di/injector_compatibility';
+import { ErrorHandler } from '../../error_handler';
+import { RuntimeError } from '../../errors';
+import { DestroyRef } from '../../linker/destroy_ref';
+/**
+ * An `OutputEmitterRef` is created by the `output()` function and can be
+ * used to emit values to consumers of your directive or component.
+ *
+ * Consumers of your directive/component can bind to the output and
+ * subscribe to changes via the bound event syntax. For example:
+ *
+ * ```html
+ * <my-comp (valueChange)="processNewValue($event)" />
+ * ```
+ *
+ * @developerPreview
+ */
+export class OutputEmitterRef {
+    constructor() {
+        this.destroyed = false;
+        this.listeners = null;
+        this.errorHandler = inject(ErrorHandler, { optional: true });
+        /** @internal */
+        this.destroyRef = inject(DestroyRef);
+        // Clean-up all listeners and mark as destroyed upon destroy.
+        this.destroyRef.onDestroy(() => {
+            this.destroyed = true;
+            this.listeners = null;
+        });
+    }
+    subscribe(callback) {
+        if (this.destroyed) {
+            throw new RuntimeError(953 /* RuntimeErrorCode.OUTPUT_REF_DESTROYED */, ngDevMode &&
+                'Unexpected subscription to destroyed `OutputRef`. ' +
+                    'The owning directive/component is destroyed.');
+        }
+        (this.listeners ??= []).push(callback);
+        return {
+            unsubscribe: () => {
+                const idx = this.listeners?.indexOf(callback);
+                if (idx !== undefined && idx !== -1) {
+                    this.listeners?.splice(idx, 1);
+                }
+            }
+        };
+    }
+    /** Emits a new value to the output. */
+    emit(value) {
+        if (this.destroyed) {
+            throw new RuntimeError(953 /* RuntimeErrorCode.OUTPUT_REF_DESTROYED */, ngDevMode &&
+                'Unexpected emit for destroyed `OutputRef`. ' +
+                    'The owning directive/component is destroyed.');
+        }
+        if (this.listeners === null) {
+            return;
+        }
+        const previousConsumer = setActiveConsumer(null);
+        try {
+            for (const listenerFn of this.listeners) {
+                try {
+                    listenerFn(value);
+                }
+                catch (err) {
+                    this.errorHandler?.handleError(err);
+                }
+            }
+        }
+        finally {
+            setActiveConsumer(previousConsumer);
+        }
+    }
+}
+/** Gets the owning `DestroyRef` for the given output. */
+export function getOutputDestroyRef(ref) {
+    return ref.destroyRef;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/output/output_ref.mjs

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/authoring/queries.mjs

@@ -5,11 +5,14 @@
  * 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 { assertInInjectionContext } from '../di';
 import { createMultiResultQuerySignalFn, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn } from '../render3/query_reactive';
 function viewChildFn(locator, opts) {
+    ngDevMode && assertInInjectionContext(viewChild);
     return createSingleResultOptionalQuerySignalFn();
 }
 function viewChildRequiredFn(locator, opts) {
+    ngDevMode && assertInInjectionContext(viewChild);
     return createSingleResultRequiredQuerySignalFn();
 }
 /**
@@ -58,12 +61,15 @@ export const viewChild = (() => {
  * ```
  */
 export function viewChildren(locator, opts) {
+    ngDevMode && assertInInjectionContext(viewChildren);
     return createMultiResultQuerySignalFn();
 }
 export function contentChildFn(locator, opts) {
+    ngDevMode && assertInInjectionContext(contentChild);
     return createSingleResultOptionalQuerySignalFn();
 }
 function contentChildRequiredFn(locator, opts) {
+    ngDevMode && assertInInjectionContext(contentChildren);
     return createSingleResultRequiredQuerySignalFn();
 }
 /**
@@ -111,4 +117,4 @@ export const contentChild = (() => {
 export function contentChildren(locator, opts) {
     return createMultiResultQuerySignalFn();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/authoring/queries.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAC,8BAA8B,EAAE,uCAAuC,EAAE,uCAAuC,EAAC,MAAM,2BAA2B,CAAC;AAG3J,SAAS,WAAW,CAChB,OAAuC,EACvC,IAAoC;IACtC,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,mBAAmB,CACxB,OAAuC,EAAE,IAAoC;IAC/E,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAkCD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAsB,CAAC,GAAG,EAAE;IAChD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,WAAmB,CAAC,QAAQ,GAAG,mBAAmB,CAAC;IACpD,OAAO,WAA0E,CAAC;AACpF,CAAC,CAAC,EAAE,CAAC;AAQL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CACxB,OAAuC,EACvC,IAAoC;IACtC,OAAO,8BAA8B,EAAS,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,cAAc,CAC1B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,sBAAsB,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AA2CD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAyB,CAAC,GAAG,EAAE;IACtD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,cAAsB,CAAC,QAAQ,GAAG,sBAAsB,CAAC;IAC1D,OAAO,cAAmF,CAAC;AAC7F,CAAC,CAAC,EAAE,CAAC;AAUL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,8BAA8B,EAAS,CAAC;AACjD,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 {ProviderToken} from '../di/provider_token';\nimport {createMultiResultQuerySignalFn, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn} from '../render3/query_reactive';\nimport {Signal} from '../render3/reactivity/api';\n\nfunction viewChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction viewChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string, opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `viewChild` function. The viewChild function creates a singular view query.\n *\n * It is a special function that also provides access to required query results via the `.required`\n * property.\n *\n * @developerPreview\n */\nexport interface ViewChildFunction {\n  /**\n   * Initializes a view child query. Consider using `viewChild.required` for queries that should\n   * always match.\n   *\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT|undefined>;\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n      Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a view child query that is expected to always match an element.\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n        Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a view child query.\n *\n * Consider using `viewChild.required` for queries that should always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `viewChild()` function.\n *\n * ```ts\n * @Component({template: '<div #el></div><my-component #cmp />'})\n * export class TestComponent {\n *   divEl = viewChild<ElementRef>('el');                   // Signal<ElementRef|undefined>\n *   divElRequired = viewChild.required<ElementRef>('el');  // Signal<ElementRef>\n *   cmp = viewChild(MyComponent);                          // Signal<MyComponent|undefined>\n *   cmpRequired = viewChild.required(MyComponent);         // Signal<MyComponent>\n * }\n * ```\n *\n * @developerPreview\n */\nexport const viewChild: ViewChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (viewChildFn as any).required = viewChildRequiredFn;\n  return viewChildFn as (typeof viewChildFn&{required: typeof viewChildRequiredFn});\n})();\n\nexport function viewChildren<LocatorT>(locator: ProviderToken<LocatorT>|\n                                       string): Signal<ReadonlyArray<LocatorT>>;\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a view children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `viewChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   divEls = viewChildren<ElementRef>('el');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n\nexport function contentChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction contentChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `contentChild` function.\n *\n * The contentChild function creates a singular content query. It is a special function that also\n * provides access to required query results via the `.required` property.\n *\n * @developerPreview\n */\nexport interface ContentChildFunction {\n  /**\n   * Initializes a content child query.\n   *\n   * Consider using `contentChild.required` for queries that should always match.\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n    descendants?: boolean,\n    read?: undefined\n  }): Signal<LocatorT|undefined>;\n\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {\n    descendants?: boolean, read: ProviderToken<ReadT>\n  }): Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a content child query that is always expected to match.\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n      descendants?: boolean,\n      read?: undefined,\n    }): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(\n        locator: ProviderToken<LocatorT>|string,\n        opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a content child query. Consider using `contentChild.required` for queries that should\n * always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `contentChild()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChild<ElementRef>('h');                    // Signal<ElementRef|undefined>\n *   headerElElRequired = contentChild.required<ElementRef>('h'); // Signal<ElementRef>\n *   header = contentChild(MyHeader);                             // Signal<MyHeader|undefined>\n *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>\n * }\n * ```\n */\nexport const contentChild: ContentChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (contentChildFn as any).required = contentChildRequiredFn;\n  return contentChildFn as (typeof contentChildFn&{required: typeof contentChildRequiredFn});\n})();\n\n\nexport function contentChildren<LocatorT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: undefined}): Signal<ReadonlyArray<LocatorT>>;\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a content children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `contentChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChildren<ElementRef>('h');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/authoring/queries.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,wBAAwB,EAAC,MAAM,OAAO,CAAC;AAE/C,OAAO,EAAC,8BAA8B,EAAE,uCAAuC,EAAE,uCAAuC,EAAC,MAAM,2BAA2B,CAAC;AAG3J,SAAS,WAAW,CAChB,OAAuC,EACvC,IAAoC;IACtC,SAAS,IAAI,wBAAwB,CAAC,SAAS,CAAC,CAAC;IACjD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,mBAAmB,CACxB,OAAuC,EAAE,IAAoC;IAC/E,SAAS,IAAI,wBAAwB,CAAC,SAAS,CAAC,CAAC;IACjD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAkCD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAsB,CAAC,GAAG,EAAE;IAChD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,WAAmB,CAAC,QAAQ,GAAG,mBAAmB,CAAC;IACpD,OAAO,WAA0E,CAAC;AACpF,CAAC,CAAC,EAAE,CAAC;AAQL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CACxB,OAAuC,EACvC,IAAoC;IACtC,SAAS,IAAI,wBAAwB,CAAC,YAAY,CAAC,CAAC;IACpD,OAAO,8BAA8B,EAAS,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,cAAc,CAC1B,OAAuC,EACvC,IAA2D;IAC7D,SAAS,IAAI,wBAAwB,CAAC,YAAY,CAAC,CAAC;IACpD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AAED,SAAS,sBAAsB,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,SAAS,IAAI,wBAAwB,CAAC,eAAe,CAAC,CAAC;IACvD,OAAO,uCAAuC,EAAS,CAAC;AAC1D,CAAC;AA2CD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAyB,CAAC,GAAG,EAAE;IACtD,yEAAyE;IACzE,+EAA+E;IAC/E,kFAAkF;IACjF,cAAsB,CAAC,QAAQ,GAAG,sBAAsB,CAAC;IAC1D,OAAO,cAAmF,CAAC;AAC7F,CAAC,CAAC,EAAE,CAAC;AAUL;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC3B,OAAuC,EACvC,IAA2D;IAC7D,OAAO,8BAA8B,EAAS,CAAC;AACjD,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 {assertInInjectionContext} from '../di';\nimport {ProviderToken} from '../di/provider_token';\nimport {createMultiResultQuerySignalFn, createSingleResultOptionalQuerySignalFn, createSingleResultRequiredQuerySignalFn} from '../render3/query_reactive';\nimport {Signal} from '../render3/reactivity/api';\n\nfunction viewChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  ngDevMode && assertInInjectionContext(viewChild);\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction viewChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string, opts?: {read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  ngDevMode && assertInInjectionContext(viewChild);\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `viewChild` function. The viewChild function creates a singular view query.\n *\n * It is a special function that also provides access to required query results via the `.required`\n * property.\n *\n * @developerPreview\n */\nexport interface ViewChildFunction {\n  /**\n   * Initializes a view child query. Consider using `viewChild.required` for queries that should\n   * always match.\n   *\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT|undefined>;\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n      Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a view child query that is expected to always match an element.\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {read: ProviderToken<ReadT>}):\n        Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a view child query.\n *\n * Consider using `viewChild.required` for queries that should always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `viewChild()` function.\n *\n * ```ts\n * @Component({template: '<div #el></div><my-component #cmp />'})\n * export class TestComponent {\n *   divEl = viewChild<ElementRef>('el');                   // Signal<ElementRef|undefined>\n *   divElRequired = viewChild.required<ElementRef>('el');  // Signal<ElementRef>\n *   cmp = viewChild(MyComponent);                          // Signal<MyComponent|undefined>\n *   cmpRequired = viewChild.required(MyComponent);         // Signal<MyComponent>\n * }\n * ```\n *\n * @developerPreview\n */\nexport const viewChild: ViewChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (viewChildFn as any).required = viewChildRequiredFn;\n  return viewChildFn as (typeof viewChildFn&{required: typeof viewChildRequiredFn});\n})();\n\nexport function viewChildren<LocatorT>(locator: ProviderToken<LocatorT>|\n                                       string): Signal<ReadonlyArray<LocatorT>>;\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a view children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `viewChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   divEls = viewChildren<ElementRef>('el');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function viewChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  ngDevMode && assertInInjectionContext(viewChildren);\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n\nexport function contentChildFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT|undefined> {\n  ngDevMode && assertInInjectionContext(contentChild);\n  return createSingleResultOptionalQuerySignalFn<ReadT>();\n}\n\nfunction contentChildRequiredFn<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadT> {\n  ngDevMode && assertInInjectionContext(contentChildren);\n  return createSingleResultRequiredQuerySignalFn<ReadT>();\n}\n\n/**\n * Type of the `contentChild` function.\n *\n * The contentChild function creates a singular content query. It is a special function that also\n * provides access to required query results via the `.required` property.\n *\n * @developerPreview\n */\nexport interface ContentChildFunction {\n  /**\n   * Initializes a content child query.\n   *\n   * Consider using `contentChild.required` for queries that should always match.\n   * @developerPreview\n   */\n  <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n    descendants?: boolean,\n    read?: undefined\n  }): Signal<LocatorT|undefined>;\n\n  <LocatorT, ReadT>(locator: ProviderToken<LocatorT>|string, opts: {\n    descendants?: boolean, read: ProviderToken<ReadT>\n  }): Signal<ReadT|undefined>;\n\n  /**\n   * Initializes a content child query that is always expected to match.\n   *\n   * @developerPreview\n   */\n  required: {\n    <LocatorT>(locator: ProviderToken<LocatorT>|string, opts?: {\n      descendants?: boolean,\n      read?: undefined,\n    }): Signal<LocatorT>;\n\n    <LocatorT, ReadT>(\n        locator: ProviderToken<LocatorT>|string,\n        opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadT>;\n  };\n}\n\n/**\n * Initializes a content child query. Consider using `contentChild.required` for queries that should\n * always match.\n *\n * @usageNotes\n * Create a child query in your component by declaring a\n * class field and initializing it with the `contentChild()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChild<ElementRef>('h');                    // Signal<ElementRef|undefined>\n *   headerElElRequired = contentChild.required<ElementRef>('h'); // Signal<ElementRef>\n *   header = contentChild(MyHeader);                             // Signal<MyHeader|undefined>\n *   headerRequired = contentChild.required(MyHeader);            // Signal<MyHeader>\n * }\n * ```\n */\nexport const contentChild: ContentChildFunction = (() => {\n  // Note: This may be considered a side-effect, but nothing will depend on\n  // this assignment, unless this `viewChild` constant export is accessed. It's a\n  // self-contained side effect that is local to the user facing `viewChild` export.\n  (contentChildFn as any).required = contentChildRequiredFn;\n  return contentChildFn as (typeof contentChildFn&{required: typeof contentChildRequiredFn});\n})();\n\n\nexport function contentChildren<LocatorT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: undefined}): Signal<ReadonlyArray<LocatorT>>;\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts: {descendants?: boolean, read: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>>;\n\n/**\n * Initializes a content children query.\n *\n * Query results are represented as a signal of a read-only collection containing all matched\n * elements.\n *\n * @usageNotes\n * Create a children query in your component by declaring a\n * class field and initializing it with the `contentChildren()` function.\n *\n * ```ts\n * @Component({...})\n * export class TestComponent {\n *   headerEl = contentChildren<ElementRef>('h');   // Signal<ReadonlyArray<ElementRef>>\n * }\n * ```\n */\nexport function contentChildren<LocatorT, ReadT>(\n    locator: ProviderToken<LocatorT>|string,\n    opts?: {descendants?: boolean, read?: ProviderToken<ReadT>}): Signal<ReadonlyArray<ReadT>> {\n  return createMultiResultQuerySignalFn<ReadT>();\n}\n"]}

package/esm2022/src/authoring.mjs

@@ -6,5 +6,6 @@
  * found in the LICENSE file at https://angular.io/license
  */
 export { ɵINPUT_SIGNAL_BRAND_WRITE_TYPE } from './authoring/input/input_signal';
-export { output as ɵoutput } from './authoring/output';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aG9yaW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvYXV0aG9yaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQU1ILE9BQU8sRUFBK0csOEJBQThCLEVBQUMsTUFBTSxnQ0FBZ0MsQ0FBQztBQUk1TCxPQUFPLEVBQUMsTUFBTSxJQUFJLE9BQU8sRUFBbUUsTUFBTSxvQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vLyBOb3RlOiBgaW5wdXRgIGFuZCBgbW9kZWxgIGFyZSBleHBvcnRlZCBpbiBgY29yZS50c2AgZHVlIHRvOlxuLy8gaHR0cHM6Ly9kb2NzLmdvb2dsZS5jb20vZG9jdW1lbnQvZC8xUlhiMXdZd3NiSm90TzFLQmdTRHNBdEtwZHVHbUlIb2Q5QUR4dVhjQXZWNC9lZGl0P3RhYj10LjAuXG5cbmV4cG9ydCB7SW5wdXRGdW5jdGlvbn0gZnJvbSAnLi9hdXRob3JpbmcvaW5wdXQvaW5wdXQnO1xuZXhwb3J0IHtJbnB1dE9wdGlvbnMsIElucHV0T3B0aW9uc1dpdGhvdXRUcmFuc2Zvcm0sIElucHV0T3B0aW9uc1dpdGhUcmFuc2Zvcm0sIElucHV0U2lnbmFsLCBJbnB1dFNpZ25hbFdpdGhUcmFuc2Zvcm0sIMm1SU5QVVRfU0lHTkFMX0JSQU5EX1dSSVRFX1RZUEV9IGZyb20gJy4vYXV0aG9yaW5nL2lucHV0L2lucHV0X3NpZ25hbCc7XG5leHBvcnQge8m1VW53cmFwRGlyZWN0aXZlU2lnbmFsSW5wdXRzfSBmcm9tICcuL2F1dGhvcmluZy9pbnB1dC9pbnB1dF90eXBlX2NoZWNraW5nJztcbmV4cG9ydCB7TW9kZWxGdW5jdGlvbn0gZnJvbSAnLi9hdXRob3JpbmcvbW9kZWwvbW9kZWwnO1xuZXhwb3J0IHtNb2RlbE9wdGlvbnMsIE1vZGVsU2lnbmFsfSBmcm9tICcuL2F1dGhvcmluZy9tb2RlbC9tb2RlbF9zaWduYWwnO1xuZXhwb3J0IHtvdXRwdXQgYXMgybVvdXRwdXQsIE91dHB1dEVtaXR0ZXIgYXMgybVPdXRwdXRFbWl0dGVyLCBPdXRwdXRPcHRpb25zIGFzIMm1T3V0cHV0T3B0aW9uc30gZnJvbSAnLi9hdXRob3Jpbmcvb3V0cHV0JztcbmV4cG9ydCB7Q29udGVudENoaWxkRnVuY3Rpb24sIFZpZXdDaGlsZEZ1bmN0aW9ufSBmcm9tICcuL2F1dGhvcmluZy9xdWVyaWVzJztcbiJdfQ==
+export { output } from './authoring/output/output';
+export { getOutputDestroyRef as ɵgetOutputDestroyRef, OutputEmitterRef } from './authoring/output/output_emitter_ref';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/change_detection/scheduling/zoneless_scheduling.mjs

@@ -10,4 +10,4 @@
  */
 export class ChangeDetectionScheduler {
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiem9uZWxlc3Nfc2NoZWR1bGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL2NoYW5nZV9kZXRlY3Rpb24vc2NoZWR1bGluZy96b25lbGVzc19zY2hlZHVsaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOztHQUVHO0FBQ0gsTUFBTSxPQUFnQix3QkFBd0I7Q0FFN0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuLyoqXG4gKiBJbmplY3RhYmxlIHRoYXQgaXMgbm90aWZpZWQgd2hlbiBhbiBgTFZpZXdgIGlzIG1hZGUgYXdhcmUgb2YgY2hhbmdlcyB0byBhcHBsaWNhdGlvbiBzdGF0ZS5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIENoYW5nZURldGVjdGlvblNjaGVkdWxlciB7XG4gIGFic3RyYWN0IG5vdGlmeSgpOiB2b2lkO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiem9uZWxlc3Nfc2NoZWR1bGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL2NoYW5nZV9kZXRlY3Rpb24vc2NoZWR1bGluZy96b25lbGVzc19zY2hlZHVsaW5nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQU9IOztHQUVHO0FBQ0gsTUFBTSxPQUFnQix3QkFBd0I7Q0FFN0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuZXhwb3J0IGNvbnN0IGVudW0gTm90aWZpY2F0aW9uVHlwZSB7XG4gIFJlZnJlc2hWaWV3cyxcbiAgQWZ0ZXJSZW5kZXJIb29rcyxcbn1cblxuLyoqXG4gKiBJbmplY3RhYmxlIHRoYXQgaXMgbm90aWZpZWQgd2hlbiBhbiBgTFZpZXdgIGlzIG1hZGUgYXdhcmUgb2YgY2hhbmdlcyB0byBhcHBsaWNhdGlvbiBzdGF0ZS5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIENoYW5nZURldGVjdGlvblNjaGVkdWxlciB7XG4gIGFic3RyYWN0IG5vdGlmeShzb3VyY2U/OiBOb3RpZmljYXRpb25UeXBlKTogdm9pZDtcbn1cbiJdfQ==

package/esm2022/src/change_detection/scheduling/zoneless_scheduling_impl.mjs

@@ -17,10 +17,15 @@ class ChangeDetectionSchedulerImpl {
         this.appRef = inject(ApplicationRef);
         this.taskService = inject(PendingTasks);
         this.pendingRenderTaskId = null;
+        this.shouldRefreshViews = false;
     }
-    notify() {
-        if (this.pendingRenderTaskId !== null)
+    notify(type = 0 /* NotificationType.RefreshViews */) {
+        // When the only source of notification is an afterRender hook will skip straight to the hooks
+        // rather than refreshing views in ApplicationRef.tick
+        this.shouldRefreshViews ||= type === 0 /* NotificationType.RefreshViews */;
+        if (this.pendingRenderTaskId !== null) {
             return;
+        }
         this.pendingRenderTaskId = this.taskService.add();
         this.raceTimeoutAndRequestAnimationFrame();
     }
@@ -58,10 +63,11 @@ class ChangeDetectionSchedulerImpl {
     tick() {
         try {
             if (!this.appRef.destroyed) {
-                this.appRef.tick();
+                this.appRef._tick(this.shouldRefreshViews);
             }
         }
         finally {
+            this.shouldRefreshViews = false;
             // If this is the last task, the service will synchronously emit a stable notification. If
             // there is a subscriber that then acts in a way that tries to notify the scheduler again,
             // we need to be able to respond to schedule a new change detection. Therefore, we should
@@ -86,4 +92,4 @@ export function provideZonelessChangeDetection() {
         { provide: NgZone, useClass: NoopNgZone },
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zoneless_scheduling_impl.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/change_detection/scheduling/zoneless_scheduling_impl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,cAAc,EAAC,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAuB,MAAM,EAAE,UAAU,EAAE,wBAAwB,EAAC,MAAM,UAAU,CAAC;AAC5F,OAAO,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAC,MAAM,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAC,wBAAwB,EAAC,MAAM,uBAAuB,CAAC;;AAE/D,MACM,4BAA4B;IADlC;QAEU,WAAM,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QAChC,gBAAW,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QACnC,wBAAmB,GAAgB,IAAI,CAAC;KA2DjD;IAzDC,MAAM;QACJ,IAAI,IAAI,CAAC,mBAAmB,KAAK,IAAI;YAAE,OAAO;QAE9C,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC;QAClD,IAAI,CAAC,mCAAmC,EAAE,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACK,KAAK,CAAC,mCAAmC;QAC/C,MAAM,OAAO,GAAG,IAAI,OAAO,CAAO,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;QAClE,MAAM,GAAG,GAAG,OAAO,MAAM,CAAC,uBAAuB,CAAC,KAAK,UAAU,CAAC,CAAC;YAC/D,IAAI,OAAO,CAAO,OAAO,CAAC,EAAE,CAAC,qBAAqB,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;YACtE,IAAI,CAAC;QACT,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;QAEnC,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAEO,IAAI;QACV,IAAI,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;gBAC3B,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YACrB,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,0FAA0F;YAC1F,0FAA0F;YAC1F,yFAAyF;YACzF,2FAA2F;YAC3F,2FAA2F;YAC3F,6BAA6B;YAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAoB,CAAC;YACzC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAChC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;6FA7DG,4BAA4B;uEAA5B,4BAA4B,WAA5B,4BAA4B,mBADT,MAAM;;gFACzB,4BAA4B;cADjC,UAAU;eAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;AAiEhC,MAAM,UAAU,8BAA8B;IAC5C,OAAO,wBAAwB,CAAC;QAC9B,EAAC,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,4BAA4B,EAAC;QAC9E,EAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAC;KACxC,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 {ApplicationRef} from '../../application/application_ref';\nimport {EnvironmentProviders, inject, Injectable, makeEnvironmentProviders} from '../../di';\nimport {PendingTasks} from '../../pending_tasks';\nimport {global} from '../../util/global';\nimport {NgZone, NoopNgZone} from '../../zone/ng_zone';\n\nimport {ChangeDetectionScheduler} from './zoneless_scheduling';\n\n@Injectable({providedIn: 'root'})\nclass ChangeDetectionSchedulerImpl implements ChangeDetectionScheduler {\n  private appRef = inject(ApplicationRef);\n  private taskService = inject(PendingTasks);\n  private pendingRenderTaskId: number|null = null;\n\n  notify(): void {\n    if (this.pendingRenderTaskId !== null) return;\n\n    this.pendingRenderTaskId = this.taskService.add();\n    this.raceTimeoutAndRequestAnimationFrame();\n  }\n\n  /**\n   * Run change detection after the first of setTimeout and requestAnimationFrame resolves.\n   *\n   * - `requestAnimationFrame` ensures that change detection runs ahead of a browser repaint.\n   * This ensures that the create and update passes of a change detection always happen\n   * in the same frame.\n   * - When the browser is resource-starved, `rAF` can execute _before_ a `setTimeout` because\n   * rendering is a very high priority process. This means that `setTimeout` cannot guarantee\n   * same-frame create and update pass, when `setTimeout` is used to schedule the update phase.\n   * - While `rAF` gives us the desirable same-frame updates, it has two limitations that\n   * prevent it from being used alone. First, it does not run in background tabs, which would\n   * prevent Angular from initializing an application when opened in a new tab (for example).\n   * Second, repeated calls to requestAnimationFrame will execute at the refresh rate of the\n   * hardware (~16ms for a 60Hz display). This would cause significant slowdown of tests that\n   * are written with several updates and asserts in the form of \"update; await stable; assert;\".\n   * - Both `setTimeout` and `rAF` are able to \"coalesce\" several events from a single user\n   * interaction into a single change detection. Importantly, this reduces view tree traversals when\n   * compared to an alternative timing mechanism like `queueMicrotask`, where change detection would\n   * then be interleaves between each event.\n   *\n   * By running change detection after the first of `setTimeout` and `rAF` to execute, we get the\n   * best of both worlds.\n   */\n  private async raceTimeoutAndRequestAnimationFrame() {\n    const timeout = new Promise<void>(resolve => setTimeout(resolve));\n    const rAF = typeof global['requestAnimationFrame'] === 'function' ?\n        new Promise<void>(resolve => requestAnimationFrame(() => resolve())) :\n        null;\n    await Promise.race([timeout, rAF]);\n\n    this.tick();\n  }\n\n  private tick() {\n    try {\n      if (!this.appRef.destroyed) {\n        this.appRef.tick();\n      }\n    } finally {\n      // If this is the last task, the service will synchronously emit a stable notification. If\n      // there is a subscriber that then acts in a way that tries to notify the scheduler again,\n      // we need to be able to respond to schedule a new change detection. Therefore, we should\n      // clear the task ID before removing it from the pending tasks (or the tasks service should\n      // not synchronously emit stable, similar to how Zone stableness only happens if it's still\n      // stable after a microtask).\n      const taskId = this.pendingRenderTaskId!;\n      this.pendingRenderTaskId = null;\n      this.taskService.remove(taskId);\n    }\n  }\n}\n\nexport function provideZonelessChangeDetection(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {provide: ChangeDetectionScheduler, useExisting: ChangeDetectionSchedulerImpl},\n    {provide: NgZone, useClass: NoopNgZone},\n  ]);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zoneless_scheduling_impl.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/change_detection/scheduling/zoneless_scheduling_impl.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,cAAc,EAAC,MAAM,mCAAmC,CAAC;AACjE,OAAO,EAAuB,MAAM,EAAE,UAAU,EAAE,wBAAwB,EAAC,MAAM,UAAU,CAAC;AAC5F,OAAO,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAC,MAAM,EAAE,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAC,wBAAwB,EAAmB,MAAM,uBAAuB,CAAC;;AAEjF,MACM,4BAA4B;IADlC;QAEU,WAAM,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;QAChC,gBAAW,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QACnC,wBAAmB,GAAgB,IAAI,CAAC;QACxC,uBAAkB,GAAG,KAAK,CAAC;KAiEpC;IA/DC,MAAM,CAAC,IAAI,wCAAgC;QACzC,8FAA8F;QAC9F,sDAAsD;QACtD,IAAI,CAAC,kBAAkB,KAAK,IAAI,0CAAkC,CAAC;QACnE,IAAI,IAAI,CAAC,mBAAmB,KAAK,IAAI,EAAE,CAAC;YACtC,OAAO;QACT,CAAC;QAED,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC;QAClD,IAAI,CAAC,mCAAmC,EAAE,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACK,KAAK,CAAC,mCAAmC;QAC/C,MAAM,OAAO,GAAG,IAAI,OAAO,CAAO,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;QAClE,MAAM,GAAG,GAAG,OAAO,MAAM,CAAC,uBAAuB,CAAC,KAAK,UAAU,CAAC,CAAC;YAC/D,IAAI,OAAO,CAAO,OAAO,CAAC,EAAE,CAAC,qBAAqB,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;YACtE,IAAI,CAAC;QACT,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;QAEnC,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAEO,IAAI;QACV,IAAI,CAAC;YACH,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;gBAC3B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;YAC7C,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;YAChC,0FAA0F;YAC1F,0FAA0F;YAC1F,yFAAyF;YACzF,2FAA2F;YAC3F,2FAA2F;YAC3F,6BAA6B;YAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAoB,CAAC;YACzC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;YAChC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;6FApEG,4BAA4B;uEAA5B,4BAA4B,WAA5B,4BAA4B,mBADT,MAAM;;gFACzB,4BAA4B;cADjC,UAAU;eAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;AAwEhC,MAAM,UAAU,8BAA8B;IAC5C,OAAO,wBAAwB,CAAC;QAC9B,EAAC,OAAO,EAAE,wBAAwB,EAAE,WAAW,EAAE,4BAA4B,EAAC;QAC9E,EAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAC;KACxC,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 {ApplicationRef} from '../../application/application_ref';\nimport {EnvironmentProviders, inject, Injectable, makeEnvironmentProviders} from '../../di';\nimport {PendingTasks} from '../../pending_tasks';\nimport {global} from '../../util/global';\nimport {NgZone, NoopNgZone} from '../../zone/ng_zone';\n\nimport {ChangeDetectionScheduler, NotificationType} from './zoneless_scheduling';\n\n@Injectable({providedIn: 'root'})\nclass ChangeDetectionSchedulerImpl implements ChangeDetectionScheduler {\n  private appRef = inject(ApplicationRef);\n  private taskService = inject(PendingTasks);\n  private pendingRenderTaskId: number|null = null;\n  private shouldRefreshViews = false;\n\n  notify(type = NotificationType.RefreshViews): void {\n    // When the only source of notification is an afterRender hook will skip straight to the hooks\n    // rather than refreshing views in ApplicationRef.tick\n    this.shouldRefreshViews ||= type === NotificationType.RefreshViews;\n    if (this.pendingRenderTaskId !== null) {\n      return;\n    }\n\n    this.pendingRenderTaskId = this.taskService.add();\n    this.raceTimeoutAndRequestAnimationFrame();\n  }\n\n  /**\n   * Run change detection after the first of setTimeout and requestAnimationFrame resolves.\n   *\n   * - `requestAnimationFrame` ensures that change detection runs ahead of a browser repaint.\n   * This ensures that the create and update passes of a change detection always happen\n   * in the same frame.\n   * - When the browser is resource-starved, `rAF` can execute _before_ a `setTimeout` because\n   * rendering is a very high priority process. This means that `setTimeout` cannot guarantee\n   * same-frame create and update pass, when `setTimeout` is used to schedule the update phase.\n   * - While `rAF` gives us the desirable same-frame updates, it has two limitations that\n   * prevent it from being used alone. First, it does not run in background tabs, which would\n   * prevent Angular from initializing an application when opened in a new tab (for example).\n   * Second, repeated calls to requestAnimationFrame will execute at the refresh rate of the\n   * hardware (~16ms for a 60Hz display). This would cause significant slowdown of tests that\n   * are written with several updates and asserts in the form of \"update; await stable; assert;\".\n   * - Both `setTimeout` and `rAF` are able to \"coalesce\" several events from a single user\n   * interaction into a single change detection. Importantly, this reduces view tree traversals when\n   * compared to an alternative timing mechanism like `queueMicrotask`, where change detection would\n   * then be interleaves between each event.\n   *\n   * By running change detection after the first of `setTimeout` and `rAF` to execute, we get the\n   * best of both worlds.\n   */\n  private async raceTimeoutAndRequestAnimationFrame() {\n    const timeout = new Promise<void>(resolve => setTimeout(resolve));\n    const rAF = typeof global['requestAnimationFrame'] === 'function' ?\n        new Promise<void>(resolve => requestAnimationFrame(() => resolve())) :\n        null;\n    await Promise.race([timeout, rAF]);\n\n    this.tick();\n  }\n\n  private tick() {\n    try {\n      if (!this.appRef.destroyed) {\n        this.appRef._tick(this.shouldRefreshViews);\n      }\n    } finally {\n      this.shouldRefreshViews = false;\n      // If this is the last task, the service will synchronously emit a stable notification. If\n      // there is a subscriber that then acts in a way that tries to notify the scheduler again,\n      // we need to be able to respond to schedule a new change detection. Therefore, we should\n      // clear the task ID before removing it from the pending tasks (or the tasks service should\n      // not synchronously emit stable, similar to how Zone stableness only happens if it's still\n      // stable after a microtask).\n      const taskId = this.pendingRenderTaskId!;\n      this.pendingRenderTaskId = null;\n      this.taskService.remove(taskId);\n    }\n  }\n}\n\nexport function provideZonelessChangeDetection(): EnvironmentProviders {\n  return makeEnvironmentProviders([\n    {provide: ChangeDetectionScheduler, useExisting: ChangeDetectionSchedulerImpl},\n    {provide: NgZone, useClass: NoopNgZone},\n  ]);\n}\n"]}

package/esm2022/src/core_private_export.mjs

@@ -6,9 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 export { setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl } from '../primitives/signals';
-export { whenStable as ɵwhenStable } from './application/application_ref';
+export { detectChangesInViewIfRequired as ɵdetectChangesInViewIfRequired, whenStable as ɵwhenStable } from './application/application_ref';
 export { IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS } from './application/application_tokens';
-export { queueStateUpdate as ɵqueueStateUpdate } from './render3/queue_state_update';
 export { internalCreateApplication as ɵinternalCreateApplication } from './application/create_application';
 export { defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers } from './change_detection/change_detection';
 export { getEnsureDirtyViewsAreAlwaysReachable as ɵgetEnsureDirtyViewsAreAlwaysReachable, setEnsureDirtyViewsAreAlwaysReachable as ɵsetEnsureDirtyViewsAreAlwaysReachable } from './change_detection/flags';
@@ -25,7 +24,7 @@ export { INJECTOR_SCOPE as ɵINJECTOR_SCOPE } from './di/scope';
 export { XSS_SECURITY_URL as ɵXSS_SECURITY_URL } from './error_details_base_url';
 export { formatRuntimeError as ɵformatRuntimeError, RuntimeError as ɵRuntimeError } from './errors';
 export { annotateForHydration as ɵannotateForHydration } from './hydration/annotate';
-export { withDomHydration as ɵwithDomHydration } from './hydration/api';
+export { withDomHydration as ɵwithDomHydration, withI18nHydration as ɵwithI18nHydration } from './hydration/api';
 export { IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED } from './hydration/tokens';
 export { readHydrationInfo as ɵreadHydrationInfo, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER } from './hydration/utils';
 export { findLocaleData as ɵfindLocaleData, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, LocaleDataIndex as ɵLocaleDataIndex, registerLocaleData as ɵregisterLocaleData, unregisterAllLocaleData as ɵunregisterLocaleData } from './i18n/locale_data_api';
@@ -36,6 +35,7 @@ export { PendingTasks as ɵPendingTasks } from './pending_tasks';
 export { ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS } from './platform/platform';
 export { ReflectionCapabilities as ɵReflectionCapabilities } from './reflection/reflection_capabilities';
 export { setInjectorProfilerContext as ɵsetInjectorProfilerContext } from './render3/debug/injector_profiler';
+export { queueStateUpdate as ɵqueueStateUpdate } from './render3/queue_state_update';
 export { allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, getSanitizationBypassType as ɵgetSanitizationBypassType, unwrapSafeValue as ɵunwrapSafeValue } from './sanitization/bypass';
 export { _sanitizeHtml as ɵ_sanitizeHtml } from './sanitization/html_sanitizer';
 export { _sanitizeUrl as ɵ_sanitizeUrl } from './sanitization/url_sanitizer';
@@ -47,4 +47,4 @@ export { isPromise as ɵisPromise, isSubscribable as ɵisSubscribable } from './
 export { performanceMarkFeature as ɵperformanceMarkFeature } from './util/performance';
 export { stringify as ɵstringify, truncateMiddle as ɵtruncateMiddle } from './util/stringify';
 export { NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR } from './view/provider_flags';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core_private_export.js","sourceRoot":"","sources":["../../../../../../packages/core/src/core_private_export.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\nexport {setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl} from '../primitives/signals';\nexport {whenStable as ɵwhenStable} from './application/application_ref';\nexport {IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, ImageConfig as ɵImageConfig} from './application/application_tokens';\nexport {queueStateUpdate as ɵqueueStateUpdate} from './render3/queue_state_update';\nexport {internalCreateApplication as ɵinternalCreateApplication} from './application/create_application';\nexport {defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers} from './change_detection/change_detection';\nexport {getEnsureDirtyViewsAreAlwaysReachable as ɵgetEnsureDirtyViewsAreAlwaysReachable, setEnsureDirtyViewsAreAlwaysReachable as ɵsetEnsureDirtyViewsAreAlwaysReachable} from './change_detection/flags';\nexport {ChangeDetectionScheduler as ɵChangeDetectionScheduler} from './change_detection/scheduling/zoneless_scheduling';\nexport {provideZonelessChangeDetection as ɵprovideZonelessChangeDetection} from './change_detection/scheduling/zoneless_scheduling_impl';\nexport {Console as ɵConsole} from './console';\nexport {DeferBlockDetails as ɵDeferBlockDetails, getDeferBlocks as ɵgetDeferBlocks} from './defer/discovery';\nexport {renderDeferBlockState as ɵrenderDeferBlockState, triggerResourceLoading as ɵtriggerResourceLoading} from './defer/instructions';\nexport {DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockConfig as ɵDeferBlockConfig, DeferBlockState as ɵDeferBlockState} from './defer/interfaces';\nexport {convertToBitFlags as ɵconvertToBitFlags, setCurrentInjector as ɵsetCurrentInjector} from './di/injector_compatibility';\nexport {getInjectableDef as ɵgetInjectableDef, ɵɵInjectableDeclaration, ɵɵInjectorDef} from './di/interface/defs';\nexport {InternalEnvironmentProviders as ɵInternalEnvironmentProviders, isEnvironmentProviders as ɵisEnvironmentProviders} from './di/interface/provider';\nexport {INJECTOR_SCOPE as ɵINJECTOR_SCOPE} from './di/scope';\nexport {XSS_SECURITY_URL as ɵXSS_SECURITY_URL} from './error_details_base_url';\nexport {formatRuntimeError as ɵformatRuntimeError, RuntimeError as ɵRuntimeError, RuntimeErrorCode as ɵRuntimeErrorCode} from './errors';\nexport {annotateForHydration as ɵannotateForHydration} from './hydration/annotate';\nexport {withDomHydration as ɵwithDomHydration} from './hydration/api';\nexport {IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED} from './hydration/tokens';\nexport {HydratedNode as ɵHydratedNode, HydrationInfo as ɵHydrationInfo, readHydrationInfo as ɵreadHydrationInfo, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER} from './hydration/utils';\nexport {CurrencyIndex as ɵCurrencyIndex, ExtraLocaleDataIndex as ɵExtraLocaleDataIndex, findLocaleData as ɵfindLocaleData, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, LocaleDataIndex as ɵLocaleDataIndex, registerLocaleData as ɵregisterLocaleData, unregisterAllLocaleData as ɵunregisterLocaleData} from './i18n/locale_data_api';\nexport {DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID} from './i18n/localization';\nexport {Writable as ɵWritable} from './interface/type';\nexport {ComponentFactory as ɵComponentFactory} from './linker/component_factory';\nexport {clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue} from './metadata/resource_loading';\nexport {PendingTasks as ɵPendingTasks} from './pending_tasks';\nexport {ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS} from './platform/platform';\nexport {ReflectionCapabilities as ɵReflectionCapabilities} from './reflection/reflection_capabilities';\nexport {AnimationRendererType as ɵAnimationRendererType} from './render/api';\nexport {InjectorProfilerContext as ɵInjectorProfilerContext, ProviderRecord as ɵProviderRecord, setInjectorProfilerContext as ɵsetInjectorProfilerContext} from './render3/debug/injector_profiler';\nexport {allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, BypassType as ɵBypassType, getSanitizationBypassType as ɵgetSanitizationBypassType, SafeHtml as ɵSafeHtml, SafeResourceUrl as ɵSafeResourceUrl, SafeScript as ɵSafeScript, SafeStyle as ɵSafeStyle, SafeUrl as ɵSafeUrl, SafeValue as ɵSafeValue, unwrapSafeValue as ɵunwrapSafeValue} from './sanitization/bypass';\nexport {_sanitizeHtml as ɵ_sanitizeHtml} from './sanitization/html_sanitizer';\nexport {_sanitizeUrl as ɵ_sanitizeUrl} from './sanitization/url_sanitizer';\nexport {TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER} from './testability/testability';\nexport {booleanAttribute, numberAttribute} from './util/coercion';\nexport {devModeEqual as ɵdevModeEqual} from './util/comparison';\nexport {global as ɵglobal} from './util/global';\nexport {isPromise as ɵisPromise, isSubscribable as ɵisSubscribable} from './util/lang';\nexport {performanceMarkFeature as ɵperformanceMarkFeature} from './util/performance';\nexport {stringify as ɵstringify, truncateMiddle as ɵtruncateMiddle} from './util/stringify';\nexport {NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR} from './view/provider_flags';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core_private_export.js","sourceRoot":"","sources":["../../../../../../packages/core/src/core_private_export.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\nexport {setAlternateWeakRefImpl as ɵsetAlternateWeakRefImpl} from '../primitives/signals';\nexport {detectChangesInViewIfRequired as ɵdetectChangesInViewIfRequired, whenStable as ɵwhenStable} from './application/application_ref';\nexport {IMAGE_CONFIG as ɵIMAGE_CONFIG, IMAGE_CONFIG_DEFAULTS as ɵIMAGE_CONFIG_DEFAULTS, ImageConfig as ɵImageConfig} from './application/application_tokens';\nexport {internalCreateApplication as ɵinternalCreateApplication} from './application/create_application';\nexport {defaultIterableDiffers as ɵdefaultIterableDiffers, defaultKeyValueDiffers as ɵdefaultKeyValueDiffers} from './change_detection/change_detection';\nexport {getEnsureDirtyViewsAreAlwaysReachable as ɵgetEnsureDirtyViewsAreAlwaysReachable, setEnsureDirtyViewsAreAlwaysReachable as ɵsetEnsureDirtyViewsAreAlwaysReachable} from './change_detection/flags';\nexport {ChangeDetectionScheduler as ɵChangeDetectionScheduler} from './change_detection/scheduling/zoneless_scheduling';\nexport {provideZonelessChangeDetection as ɵprovideZonelessChangeDetection} from './change_detection/scheduling/zoneless_scheduling_impl';\nexport {Console as ɵConsole} from './console';\nexport {DeferBlockDetails as ɵDeferBlockDetails, getDeferBlocks as ɵgetDeferBlocks} from './defer/discovery';\nexport {renderDeferBlockState as ɵrenderDeferBlockState, triggerResourceLoading as ɵtriggerResourceLoading} from './defer/instructions';\nexport {DeferBlockBehavior as ɵDeferBlockBehavior, DeferBlockConfig as ɵDeferBlockConfig, DeferBlockState as ɵDeferBlockState} from './defer/interfaces';\nexport {convertToBitFlags as ɵconvertToBitFlags, setCurrentInjector as ɵsetCurrentInjector} from './di/injector_compatibility';\nexport {getInjectableDef as ɵgetInjectableDef, ɵɵInjectableDeclaration, ɵɵInjectorDef} from './di/interface/defs';\nexport {InternalEnvironmentProviders as ɵInternalEnvironmentProviders, isEnvironmentProviders as ɵisEnvironmentProviders} from './di/interface/provider';\nexport {INJECTOR_SCOPE as ɵINJECTOR_SCOPE} from './di/scope';\nexport {XSS_SECURITY_URL as ɵXSS_SECURITY_URL} from './error_details_base_url';\nexport {formatRuntimeError as ɵformatRuntimeError, RuntimeError as ɵRuntimeError, RuntimeErrorCode as ɵRuntimeErrorCode} from './errors';\nexport {annotateForHydration as ɵannotateForHydration} from './hydration/annotate';\nexport {withDomHydration as ɵwithDomHydration, withI18nHydration as ɵwithI18nHydration} from './hydration/api';\nexport {IS_HYDRATION_DOM_REUSE_ENABLED as ɵIS_HYDRATION_DOM_REUSE_ENABLED} from './hydration/tokens';\nexport {HydratedNode as ɵHydratedNode, HydrationInfo as ɵHydrationInfo, readHydrationInfo as ɵreadHydrationInfo, SSR_CONTENT_INTEGRITY_MARKER as ɵSSR_CONTENT_INTEGRITY_MARKER} from './hydration/utils';\nexport {CurrencyIndex as ɵCurrencyIndex, ExtraLocaleDataIndex as ɵExtraLocaleDataIndex, findLocaleData as ɵfindLocaleData, getLocaleCurrencyCode as ɵgetLocaleCurrencyCode, getLocalePluralCase as ɵgetLocalePluralCase, LocaleDataIndex as ɵLocaleDataIndex, registerLocaleData as ɵregisterLocaleData, unregisterAllLocaleData as ɵunregisterLocaleData} from './i18n/locale_data_api';\nexport {DEFAULT_LOCALE_ID as ɵDEFAULT_LOCALE_ID} from './i18n/localization';\nexport {Writable as ɵWritable} from './interface/type';\nexport {ComponentFactory as ɵComponentFactory} from './linker/component_factory';\nexport {clearResolutionOfComponentResourcesQueue as ɵclearResolutionOfComponentResourcesQueue, isComponentDefPendingResolution as ɵisComponentDefPendingResolution, resolveComponentResources as ɵresolveComponentResources, restoreComponentResolutionQueue as ɵrestoreComponentResolutionQueue} from './metadata/resource_loading';\nexport {PendingTasks as ɵPendingTasks} from './pending_tasks';\nexport {ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS} from './platform/platform';\nexport {ReflectionCapabilities as ɵReflectionCapabilities} from './reflection/reflection_capabilities';\nexport {AnimationRendererType as ɵAnimationRendererType} from './render/api';\nexport {InjectorProfilerContext as ɵInjectorProfilerContext, ProviderRecord as ɵProviderRecord, setInjectorProfilerContext as ɵsetInjectorProfilerContext} from './render3/debug/injector_profiler';\nexport {queueStateUpdate as ɵqueueStateUpdate} from './render3/queue_state_update';\nexport {allowSanitizationBypassAndThrow as ɵallowSanitizationBypassAndThrow, BypassType as ɵBypassType, getSanitizationBypassType as ɵgetSanitizationBypassType, SafeHtml as ɵSafeHtml, SafeResourceUrl as ɵSafeResourceUrl, SafeScript as ɵSafeScript, SafeStyle as ɵSafeStyle, SafeUrl as ɵSafeUrl, SafeValue as ɵSafeValue, unwrapSafeValue as ɵunwrapSafeValue} from './sanitization/bypass';\nexport {_sanitizeHtml as ɵ_sanitizeHtml} from './sanitization/html_sanitizer';\nexport {_sanitizeUrl as ɵ_sanitizeUrl} from './sanitization/url_sanitizer';\nexport {TESTABILITY as ɵTESTABILITY, TESTABILITY_GETTER as ɵTESTABILITY_GETTER} from './testability/testability';\nexport {booleanAttribute, numberAttribute} from './util/coercion';\nexport {devModeEqual as ɵdevModeEqual} from './util/comparison';\nexport {global as ɵglobal} from './util/global';\nexport {isPromise as ɵisPromise, isSubscribable as ɵisSubscribable} from './util/lang';\nexport {performanceMarkFeature as ɵperformanceMarkFeature} from './util/performance';\nexport {stringify as ɵstringify, truncateMiddle as ɵtruncateMiddle} from './util/stringify';\nexport {NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR} from './view/provider_flags';\n"]}