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

package/esm2022/primitives/signals/src/signal.mjs

@@ -41,14 +41,7 @@ export function signalSetFn(node, newValue) {
     if (!producerUpdatesAllowed()) {
         throwInvalidWriteToSignalError();
     }
-    const value = node.value;
-    if (Object.is(value, newValue)) {
-        if (typeof ngDevMode !== 'undefined' && ngDevMode && !node.equal(value, newValue)) {
-            console.warn('Signal value equality implementations should always return `true` for' +
-                ' values that are the same according to `Object.is` but returned `false` instead.');
-        }
-    }
-    else if (!node.equal(value, newValue)) {
+    if (!node.equal(node.value, newValue)) {
         node.value = newValue;
         signalValueChanged(node);
     }
@@ -83,4 +76,4 @@ function signalValueChanged(node) {
     producerNotifyConsumers(node);
     postSignalSetFn?.();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signal.js","sourceRoot":"","sources":["../../../../../../../../packages/core/primitives/signals/src/signal.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {defaultEquals, ValueEqualityFn} from './equality';\nimport {throwInvalidWriteToSignalError} from './errors';\nimport {producerAccessed, producerIncrementEpoch, producerNotifyConsumers, producerUpdatesAllowed, REACTIVE_NODE, ReactiveNode, SIGNAL} from './graph';\n\n// Required as the signals library is in a separate package, so we need to explicitly ensure the\n// global `ngDevMode` type is defined.\ndeclare const ngDevMode: boolean|undefined;\n\n/**\n * If set, called after `WritableSignal`s are updated.\n *\n * This hook can be used to achieve various effects, such as running effects synchronously as part\n * of setting a signal.\n */\nlet postSignalSetFn: (() => void)|null = null;\n\nexport interface SignalNode<T> extends ReactiveNode {\n  value: T;\n  equal: ValueEqualityFn<T>;\n  readonly[SIGNAL]: SignalNode<T>;\n}\n\nexport type SignalBaseGetter<T> = (() => T)&{readonly[SIGNAL]: unknown};\n\n// Note: Closure *requires* this to be an `interface` and not a type, which is why the\n// `SignalBaseGetter` type exists to provide the correct shape.\nexport interface SignalGetter<T> extends SignalBaseGetter<T> {\n  readonly[SIGNAL]: SignalNode<T>;\n}\n\n/**\n * Create a `Signal` that can be set or updated directly.\n */\nexport function createSignal<T>(initialValue: T): SignalGetter<T> {\n  const node: SignalNode<T> = Object.create(SIGNAL_NODE);\n  node.value = initialValue;\n  const getter = (() => {\n                   producerAccessed(node);\n                   return node.value;\n                 }) as SignalGetter<T>;\n  (getter as any)[SIGNAL] = node;\n  return getter;\n}\n\nexport function setPostSignalSetFn(fn: (() => void)|null): (() => void)|null {\n  const prev = postSignalSetFn;\n  postSignalSetFn = fn;\n  return prev;\n}\n\nexport function signalGetFn<T>(this: SignalNode<T>): T {\n  producerAccessed(this);\n  return this.value;\n}\n\nexport function signalSetFn<T>(node: SignalNode<T>, newValue: T) {\n  if (!producerUpdatesAllowed()) {\n    throwInvalidWriteToSignalError();\n  }\n\n  const value = node.value;\n  if (Object.is(value, newValue)) {\n    if (typeof ngDevMode !== 'undefined' && ngDevMode && !node.equal(value, newValue)) {\n      console.warn(\n          'Signal value equality implementations should always return `true` for' +\n          ' values that are the same according to `Object.is` but returned `false` instead.');\n    }\n  } else if (!node.equal(value, newValue)) {\n    node.value = newValue;\n    signalValueChanged(node);\n  }\n}\n\nexport function signalUpdateFn<T>(node: SignalNode<T>, updater: (value: T) => T): void {\n  if (!producerUpdatesAllowed()) {\n    throwInvalidWriteToSignalError();\n  }\n\n  signalSetFn(node, updater(node.value));\n}\n\nexport function signalMutateFn<T>(node: SignalNode<T>, mutator: (value: T) => void): void {\n  if (!producerUpdatesAllowed()) {\n    throwInvalidWriteToSignalError();\n  }\n  // Mutate bypasses equality checks as it's by definition changing the value.\n  mutator(node.value);\n  signalValueChanged(node);\n}\n\n// Note: Using an IIFE here to ensure that the spread assignment is not considered\n// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.\n// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.\nconst SIGNAL_NODE: object = /* @__PURE__ */ (() => {\n  return {\n    ...REACTIVE_NODE,\n    equal: defaultEquals,\n    value: undefined,\n  };\n})();\n\nfunction signalValueChanged<T>(node: SignalNode<T>): void {\n  node.version++;\n  producerIncrementEpoch();\n  producerNotifyConsumers(node);\n  postSignalSetFn?.();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/application/application_config.mjs

@@ -0,0 +1,21 @@
+/**
+ * @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
+ */
+/**
+ * Merge multiple application configurations from left to right.
+ *
+ * @param configs Two or more configurations to be merged.
+ * @returns A merged [ApplicationConfig](api/core/ApplicationConfig).
+ *
+ * @publicApi
+ */
+export function mergeApplicationConfig(...configs) {
+    return configs.reduce((prev, curr) => {
+        return Object.assign(prev, curr, { providers: [...prev.providers, ...curr.providers] });
+    }, { providers: [] });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/application/application_init.mjs

@@ -0,0 +1,188 @@
+import { inject, Injectable, InjectionToken } from '../di';
+import { RuntimeError } from '../errors';
+import { isPromise, isSubscribable } from '../util/lang';
+import * as i0 from "../r3_symbols";
+/**
+ * A [DI token](guide/glossary#di-token "DI token definition") that you can use to provide
+ * one or more initialization functions.
+ *
+ * The provided functions are injected at application startup and executed during
+ * app initialization. If any of these functions returns a Promise or an Observable, initialization
+ * does not complete until the Promise is resolved or the Observable is completed.
+ *
+ * You can, for example, create a factory function that loads language data
+ * or an external configuration, and provide that function to the `APP_INITIALIZER` token.
+ * The function is executed during the application bootstrap process,
+ * and the needed data is available on startup.
+ *
+ * @see {@link ApplicationInitStatus}
+ *
+ * @usageNotes
+ *
+ * The following example illustrates how to configure a multi-provider using `APP_INITIALIZER` token
+ * and a function returning a promise.
+ * ### Example with NgModule-based application
+ * ```
+ *  function initializeApp(): Promise<any> {
+ *    return new Promise((resolve, reject) => {
+ *      // Do some asynchronous stuff
+ *      resolve();
+ *    });
+ *  }
+ *
+ *  @NgModule({
+ *   imports: [BrowserModule],
+ *   declarations: [AppComponent],
+ *   bootstrap: [AppComponent],
+ *   providers: [{
+ *     provide: APP_INITIALIZER,
+ *     useFactory: () => initializeApp,
+ *     multi: true
+ *    }]
+ *   })
+ *  export class AppModule {}
+ * ```
+ *
+ * ### Example with standalone application
+ * ```
+ * export function initializeApp(http: HttpClient) {
+ *   return (): Promise<any> =>
+ *     firstValueFrom(
+ *       http
+ *         .get("https://someUrl.com/api/user")
+ *         .pipe(tap(user => { ... }))
+ *     );
+ * }
+ *
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideHttpClient(),
+ *     {
+ *       provide: APP_INITIALIZER,
+ *       useFactory: initializeApp,
+ *       multi: true,
+ *       deps: [HttpClient],
+ *     },
+ *   ],
+ * });
+
+ * ```
+ *
+ *
+ * It's also possible to configure a multi-provider using `APP_INITIALIZER` token and a function
+ * returning an observable, see an example below. Note: the `HttpClient` in this example is used for
+ * demo purposes to illustrate how the factory function can work with other providers available
+ * through DI.
+ *
+ * ### Example with NgModule-based application
+ * ```
+ *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
+ *   return () => httpClient.get("https://someUrl.com/api/user")
+ *     .pipe(
+ *        tap(user => { ... })
+ *     );
+ *  }
+ *
+ *  @NgModule({
+ *    imports: [BrowserModule, HttpClientModule],
+ *    declarations: [AppComponent],
+ *    bootstrap: [AppComponent],
+ *    providers: [{
+ *      provide: APP_INITIALIZER,
+ *      useFactory: initializeAppFactory,
+ *      deps: [HttpClient],
+ *      multi: true
+ *    }]
+ *  })
+ *  export class AppModule {}
+ * ```
+ *
+ * ### Example with standalone application
+ * ```
+ *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {
+ *   return () => httpClient.get("https://someUrl.com/api/user")
+ *     .pipe(
+ *        tap(user => { ... })
+ *     );
+ *  }
+ *
+ * bootstrapApplication(App, {
+ *   providers: [
+ *     provideHttpClient(),
+ *     {
+ *       provide: APP_INITIALIZER,
+ *       useFactory: initializeAppFactory,
+ *       multi: true,
+ *       deps: [HttpClient],
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @publicApi
+ */
+export const APP_INITIALIZER = new InjectionToken('Application Initializer');
+/**
+ * A class that reflects the state of running {@link APP_INITIALIZER} functions.
+ *
+ * @publicApi
+ */
+export class ApplicationInitStatus {
+    constructor() {
+        this.initialized = false;
+        this.done = false;
+        this.donePromise = new Promise((res, rej) => {
+            this.resolve = res;
+            this.reject = rej;
+        });
+        this.appInits = inject(APP_INITIALIZER, { optional: true }) ?? [];
+        if ((typeof ngDevMode === 'undefined' || ngDevMode) && !Array.isArray(this.appInits)) {
+            throw new RuntimeError(-209 /* RuntimeErrorCode.INVALID_MULTI_PROVIDER */, 'Unexpected type of the `APP_INITIALIZER` token value ' +
+                `(expected an array, but got ${typeof this.appInits}). ` +
+                'Please check that the `APP_INITIALIZER` token is configured as a ' +
+                '`multi: true` provider.');
+        }
+    }
+    /** @internal */
+    runInitializers() {
+        if (this.initialized) {
+            return;
+        }
+        const asyncInitPromises = [];
+        for (const appInits of this.appInits) {
+            const initResult = appInits();
+            if (isPromise(initResult)) {
+                asyncInitPromises.push(initResult);
+            }
+            else if (isSubscribable(initResult)) {
+                const observableAsPromise = new Promise((resolve, reject) => {
+                    initResult.subscribe({ complete: resolve, error: reject });
+                });
+                asyncInitPromises.push(observableAsPromise);
+            }
+        }
+        const complete = () => {
+            // @ts-expect-error overwriting a readonly
+            this.done = true;
+            this.resolve();
+        };
+        Promise.all(asyncInitPromises)
+            .then(() => {
+            complete();
+        })
+            .catch(e => {
+            this.reject(e);
+        });
+        if (asyncInitPromises.length === 0) {
+            complete();
+        }
+        this.initialized = true;
+    }
+    static { this.ɵfac = function ApplicationInitStatus_Factory(t) { return new (t || ApplicationInitStatus)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ApplicationInitStatus, factory: ApplicationInitStatus.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.setClassMetadata(ApplicationInitStatus, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], () => [], null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"application_init.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/application/application_init.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Observable} from 'rxjs';\n\nimport {inject, Injectable, InjectionToken} from '../di';\nimport {RuntimeError, RuntimeErrorCode} from '../errors';\nimport {isPromise, isSubscribable} from '../util/lang';\n\n/**\n * A [DI token](guide/glossary#di-token \"DI token definition\") that you can use to provide\n * one or more initialization functions.\n *\n * The provided functions are injected at application startup and executed during\n * app initialization. If any of these functions returns a Promise or an Observable, initialization\n * does not complete until the Promise is resolved or the Observable is completed.\n *\n * You can, for example, create a factory function that loads language data\n * or an external configuration, and provide that function to the `APP_INITIALIZER` token.\n * The function is executed during the application bootstrap process,\n * and the needed data is available on startup.\n *\n * @see {@link ApplicationInitStatus}\n *\n * @usageNotes\n *\n * The following example illustrates how to configure a multi-provider using `APP_INITIALIZER` token\n * and a function returning a promise.\n * ### Example with NgModule-based application\n * ```\n *  function initializeApp(): Promise<any> {\n *    return new Promise((resolve, reject) => {\n *      // Do some asynchronous stuff\n *      resolve();\n *    });\n *  }\n *\n *  @NgModule({\n *   imports: [BrowserModule],\n *   declarations: [AppComponent],\n *   bootstrap: [AppComponent],\n *   providers: [{\n *     provide: APP_INITIALIZER,\n *     useFactory: () => initializeApp,\n *     multi: true\n *    }]\n *   })\n *  export class AppModule {}\n * ```\n *\n * ### Example with standalone application\n * ```\n * export function initializeApp(http: HttpClient) {\n *   return (): Promise<any> =>\n *     firstValueFrom(\n *       http\n *         .get(\"https://someUrl.com/api/user\")\n *         .pipe(tap(user => { ... }))\n *     );\n * }\n *\n * bootstrapApplication(App, {\n *   providers: [\n *     provideHttpClient(),\n *     {\n *       provide: APP_INITIALIZER,\n *       useFactory: initializeApp,\n *       multi: true,\n *       deps: [HttpClient],\n *     },\n *   ],\n * });\n\n * ```\n *\n *\n * It's also possible to configure a multi-provider using `APP_INITIALIZER` token and a function\n * returning an observable, see an example below. Note: the `HttpClient` in this example is used for\n * demo purposes to illustrate how the factory function can work with other providers available\n * through DI.\n *\n * ### Example with NgModule-based application\n * ```\n *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {\n *   return () => httpClient.get(\"https://someUrl.com/api/user\")\n *     .pipe(\n *        tap(user => { ... })\n *     );\n *  }\n *\n *  @NgModule({\n *    imports: [BrowserModule, HttpClientModule],\n *    declarations: [AppComponent],\n *    bootstrap: [AppComponent],\n *    providers: [{\n *      provide: APP_INITIALIZER,\n *      useFactory: initializeAppFactory,\n *      deps: [HttpClient],\n *      multi: true\n *    }]\n *  })\n *  export class AppModule {}\n * ```\n *\n * ### Example with standalone application\n * ```\n *  function initializeAppFactory(httpClient: HttpClient): () => Observable<any> {\n *   return () => httpClient.get(\"https://someUrl.com/api/user\")\n *     .pipe(\n *        tap(user => { ... })\n *     );\n *  }\n *\n * bootstrapApplication(App, {\n *   providers: [\n *     provideHttpClient(),\n *     {\n *       provide: APP_INITIALIZER,\n *       useFactory: initializeAppFactory,\n *       multi: true,\n *       deps: [HttpClient],\n *     },\n *   ],\n * });\n * ```\n *\n * @publicApi\n */\nexport const APP_INITIALIZER =\n    new InjectionToken<ReadonlyArray<() => Observable<unknown>| Promise<unknown>| void>>(\n        'Application Initializer');\n\n/**\n * A class that reflects the state of running {@link APP_INITIALIZER} functions.\n *\n * @publicApi\n */\n@Injectable({providedIn: 'root'})\nexport class ApplicationInitStatus {\n  // Using non null assertion, these fields are defined below\n  // within the `new Promise` callback (synchronously).\n  private resolve!: (...args: any[]) => void;\n  private reject!: (...args: any[]) => void;\n\n  private initialized = false;\n  public readonly done = false;\n  public readonly donePromise: Promise<any> = new Promise((res, rej) => {\n    this.resolve = res;\n    this.reject = rej;\n  });\n\n  private readonly appInits = inject(APP_INITIALIZER, {optional: true}) ?? [];\n\n  constructor() {\n    if ((typeof ngDevMode === 'undefined' || ngDevMode) && !Array.isArray(this.appInits)) {\n      throw new RuntimeError(\n          RuntimeErrorCode.INVALID_MULTI_PROVIDER,\n          'Unexpected type of the `APP_INITIALIZER` token value ' +\n              `(expected an array, but got ${typeof this.appInits}). ` +\n              'Please check that the `APP_INITIALIZER` token is configured as a ' +\n              '`multi: true` provider.');\n    }\n  }\n\n  /** @internal */\n  runInitializers() {\n    if (this.initialized) {\n      return;\n    }\n\n    const asyncInitPromises = [];\n    for (const appInits of this.appInits) {\n      const initResult = appInits();\n      if (isPromise(initResult)) {\n        asyncInitPromises.push(initResult);\n      } else if (isSubscribable(initResult)) {\n        const observableAsPromise = new Promise<void>((resolve, reject) => {\n          initResult.subscribe({complete: resolve, error: reject});\n        });\n        asyncInitPromises.push(observableAsPromise);\n      }\n    }\n\n    const complete = () => {\n      // @ts-expect-error overwriting a readonly\n      this.done = true;\n      this.resolve();\n    };\n\n    Promise.all(asyncInitPromises)\n        .then(() => {\n          complete();\n        })\n        .catch(e => {\n          this.reject(e);\n        });\n\n    if (asyncInitPromises.length === 0) {\n      complete();\n    }\n    this.initialized = true;\n  }\n}\n"]}

package/esm2022/src/application/application_module.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
+ */
+import { NgModule } from '../metadata';
+import { ApplicationRef } from './application_ref';
+import * as i0 from "../r3_symbols";
+import * as i1 from "./application_ref";
+/**
+ * Re-exported by `BrowserModule`, which is included automatically in the root
+ * `AppModule` when you create a new app with the CLI `new` command. Eagerly injects
+ * `ApplicationRef` to instantiate it.
+ *
+ * @publicApi
+ */
+export class ApplicationModule {
+    // Inject ApplicationRef to make it eager...
+    constructor(appRef) { }
+    static { this.ɵfac = function ApplicationModule_Factory(t) { return new (t || ApplicationModule)(i0.ɵɵinject(i1.ApplicationRef)); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: ApplicationModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({}); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.setClassMetadata(ApplicationModule, [{
+        type: NgModule
+    }], () => [{ type: i1.ApplicationRef }], null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwbGljYXRpb25fbW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvYXBwbGljYXRpb24vYXBwbGljYXRpb25fbW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxhQUFhLENBQUM7QUFFckMsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLG1CQUFtQixDQUFDOzs7QUFFakQ7Ozs7OztHQU1HO0FBRUgsTUFBTSxPQUFPLGlCQUFpQjtJQUM1Qiw0Q0FBNEM7SUFDNUMsWUFBWSxNQUFzQixJQUFHLENBQUM7a0ZBRjNCLGlCQUFpQjttRUFBakIsaUJBQWlCOzs7Z0ZBQWpCLGlCQUFpQjtjQUQ3QixRQUFRIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7TmdNb2R1bGV9IGZyb20gJy4uL21ldGFkYXRhJztcblxuaW1wb3J0IHtBcHBsaWNhdGlvblJlZn0gZnJvbSAnLi9hcHBsaWNhdGlvbl9yZWYnO1xuXG4vKipcbiAqIFJlLWV4cG9ydGVkIGJ5IGBCcm93c2VyTW9kdWxlYCwgd2hpY2ggaXMgaW5jbHVkZWQgYXV0b21hdGljYWxseSBpbiB0aGUgcm9vdFxuICogYEFwcE1vZHVsZWAgd2hlbiB5b3UgY3JlYXRlIGEgbmV3IGFwcCB3aXRoIHRoZSBDTEkgYG5ld2AgY29tbWFuZC4gRWFnZXJseSBpbmplY3RzXG4gKiBgQXBwbGljYXRpb25SZWZgIHRvIGluc3RhbnRpYXRlIGl0LlxuICpcbiAqIEBwdWJsaWNBcGlcbiAqL1xuQE5nTW9kdWxlKClcbmV4cG9ydCBjbGFzcyBBcHBsaWNhdGlvbk1vZHVsZSB7XG4gIC8vIEluamVjdCBBcHBsaWNhdGlvblJlZiB0byBtYWtlIGl0IGVhZ2VyLi4uXG4gIGNvbnN0cnVjdG9yKGFwcFJlZjogQXBwbGljYXRpb25SZWYpIHt9XG59XG4iXX0=