static-injector 6.0.2 → 6.1.0

package/import/render3/reactivity/effect.d.ts

@@ -5,19 +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.dev/license
  */
-import { ReactiveNode, SIGNAL } from '@angular/core/primitives/signals';
-import { InjectionToken } from '../../di/injection_token';
+import { ReactiveNode, SIGNAL } from '../../../primitives/signals';
 import { Injector } from '../../di/injector';
 import { ChangeDetectionScheduler } from '../../change_detection/scheduling/zoneless_scheduling';
 import { EffectScheduler, SchedulableEffect } from './root_effect_scheduler';
-/**
- * Toggle the flag on whether to use microtask effects (for testing).
- */
-export declare function setUseMicrotaskEffectsByDefault(value: boolean): boolean;
 /**
  * A global reactive effect, which can be manually destroyed.
  *
- * @developerPreview
+ * @publicApi 20.0
  */
 export interface EffectRef {
     /**
@@ -33,7 +28,7 @@ export declare class EffectRefImpl implements EffectRef {
 /**
  * Options passed to the `effect` function.
  *
- * @developerPreview
+ * @publicApi 20.0
  */
 export interface CreateEffectOptions {
     /**
@@ -48,13 +43,11 @@ export interface CreateEffectOptions {
      *
      * If this is `false` (the default) the effect will automatically register itself to be cleaned up
      * with the current `DestroyRef`.
+     *
+     * If this is `true` and you want to use the effect outside an injection context, you still
+     * need to provide an `Injector` to the effect.
      */
     manualCleanup?: boolean;
-    /**
-     * Always create a root effect (which is scheduled as a microtask) regardless of whether `effect`
-     * is called within a component.
-     */
-    forceRoot?: true;
     /**
      * @deprecated no longer required, signal writes are allowed by default.
      */
@@ -69,13 +62,13 @@ export interface CreateEffectOptions {
  * before the next effect run. The cleanup function makes it possible to "cancel" any work that the
  * previous effect run might have started.
  *
- * @developerPreview
+ * @publicApi 20.0
  */
 export type EffectCleanupFn = () => void;
 /**
  * A callback passed to the effect function that makes it possible to register cleanup logic.
  *
- * @developerPreview
+ * @publicApi 20.0
  */
 export type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
 /**
@@ -85,7 +78,7 @@ export type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
  * Angular has two different kinds of effect: component effects and root effects. Component effects
  * are created when `effect()` is called from a component, directive, or within a service of a
  * component/directive. Root effects are created when `effect()` is called from outside the
- * component tree, such as in a root service, or when the `forceRoot` option is provided.
+ * component tree, such as in a root service.
  *
  * The two effect types differ in their timing. Component effects run as a component lifecycle
  * event during Angular's synchronization (change detection) process, and can safely read input
@@ -94,7 +87,7 @@ export type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
  *
  * `effect()` must be run in injection context, unless the `injector` option is manually specified.
  *
- * @developerPreview
+ * @publicApi 20.0
  */
 export declare function effect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;
 export interface EffectNode extends ReactiveNode, SchedulableEffect {
@@ -111,11 +104,6 @@ export interface EffectNode extends ReactiveNode, SchedulableEffect {
 export interface RootEffectNode extends EffectNode {
     scheduler: EffectScheduler;
 }
-/**
- * Not public API, which guarantees `EffectScheduler` only ever comes from the application root
- * injector.
- */
-export declare const APP_EFFECT_SCHEDULER: InjectionToken<EffectScheduler>;
 export declare const BASE_EFFECT_NODE: Omit<EffectNode, 'fn' | 'destroy' | 'injector' | 'notifier'>;
 export declare const ROOT_EFFECT_NODE: Omit<RootEffectNode, 'fn' | 'scheduler' | 'notifier' | 'injector'>;
 export declare function createRootEffect(fn: (onCleanup: EffectCleanupRegisterFn) => void, scheduler: EffectScheduler, notifier: ChangeDetectionScheduler): RootEffectNode;

package/import/render3/reactivity/linked_signal.d.ts

@@ -5,12 +5,12 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
-import { WritableSignal } from './signal';
 import { ValueEqualityFn } from './api';
+import { WritableSignal } from './signal';
 /**
  * Creates a writable signal whose value is initialized and reset by the linked, reactive computation.
  *
- * @developerPreview
+ * @publicApi 20.0
  */
 export declare function linkedSignal<D>(computation: () => D, options?: {
     equal?: ValueEqualityFn<NoInfer<D>>;
@@ -21,7 +21,7 @@ export declare function linkedSignal<D>(computation: () => D, options?: {
  *
  * Note: The computation is reactive, meaning the linked signal will automatically update whenever any of the signals used within the computation change.
  *
- * @developerPreview
+ * @publicApi 20.0
  */
 export declare function linkedSignal<S, D>(options: {
     source: () => S;

package/import/render3/reactivity/root_effect_scheduler.d.ts

@@ -13,11 +13,13 @@ export interface SchedulableEffect {
     zone: {
         run<T>(fn: () => T): T;
     } | null;
+    dirty: boolean;
 }
 /**
  * A scheduler which manages the execution of effects.
  */
 export declare abstract class EffectScheduler {
+    abstract add(e: SchedulableEffect): void;
     /**
      * Schedule the given effect to be executed at a later time.
      *
@@ -38,8 +40,9 @@ export declare abstract class EffectScheduler {
  * when.
  */
 export declare class ZoneAwareEffectScheduler implements EffectScheduler {
-    private queuedEffectCount;
+    private dirtyEffectCount;
     private queues;
+    add(handle: SchedulableEffect): void;
     schedule(handle: SchedulableEffect): void;
     remove(handle: SchedulableEffect): void;
     private enqueue;

package/import/render3/reactivity/signal.d.ts

@@ -5,12 +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.dev/license
  */
-import { SignalGetter } from '@angular/core/primitives/signals';
+import { SignalGetter } from '../../../primitives/signals';
 import { Signal, ValueEqualityFn } from './api';
 /** Symbol used distinguish `WritableSignal` from other non-writable signals and functions. */
 export declare const ɵWRITABLE_SIGNAL: unique symbol;
 /**
  * A `Signal` with a value that can be mutated via a setter interface.
+ *
+ * @publicApi 17.0
  */
 export interface WritableSignal<T> extends Signal<T> {
     [ɵWRITABLE_SIGNAL]: T;

package/import/resource/api.d.ts

@@ -9,44 +9,29 @@ import { Injector } from '../di/injector';
 import { Signal, ValueEqualityFn } from '../render3/reactivity/api';
 import { WritableSignal } from '../render3/reactivity/signal';
 /**
- * Status of a `Resource`.
+ * String value capturing the status of a `Resource`.
+ *
+ * Possible statuses are:
+ *
+ * `idle` - The resource has no valid request and will not perform any loading. `value()` will be
+ * `undefined`.
+ *
+ * `loading` - The resource is currently loading a new value as a result of a change in its reactive
+ * dependencies. `value()` will be `undefined`.
+ *
+ * `reloading` - The resource is currently reloading a fresh value for the same reactive
+ * dependencies. `value()` will continue to return the previously fetched value during the reloading
+ * operation.
+ *
+ * `error` - Loading failed with an error. `value()` will be `undefined`.
+ *
+ * `resolved` - Loading has completed and the resource has the value returned from the loader.
+ *
+ * `local` - The resource's value was set locally via `.set()` or `.update()`.
  *
  * @experimental
  */
-export declare enum ResourceStatus {
-    /**
-     * The resource has no valid request and will not perform any loading.
-     *
-     * `value()` will be `undefined`.
-     */
-    Idle = 0,
-    /**
-     * Loading failed with an error.
-     *
-     * `value()` will be `undefined`.
-     */
-    Error = 1,
-    /**
-     * The resource is currently loading a new value as a result of a change in its `request`.
-     *
-     * `value()` will be `undefined`.
-     */
-    Loading = 2,
-    /**
-     * The resource is currently reloading a fresh value for the same request.
-     *
-     * `value()` will continue to return the previously fetched value during the reloading operation.
-     */
-    Reloading = 3,
-    /**
-     * Loading has completed and the resource has the value returned from the loader.
-     */
-    Resolved = 4,
-    /**
-     * The resource's value was set locally via `.set()` or `.update()`.
-     */
-    Local = 5
-}
+export type ResourceStatus = 'idle' | 'error' | 'loading' | 'reloading' | 'resolved' | 'local';
 /**
  * A Resource is an asynchronous dependency (for example, the results of an API call) that is
  * managed and delivered through signals.
@@ -58,7 +43,7 @@ export declare enum ResourceStatus {
  */
 export interface Resource<T> {
     /**
-     * The current value of the `Resource`, or `undefined` if there is no current value.
+     * The current value of the `Resource`, or throws an error if the resource is in an error state.
      */
     readonly value: Signal<T>;
     /**
@@ -69,7 +54,7 @@ export interface Resource<T> {
     /**
      * When in the `error` state, this returns the last known error from the `Resource`.
      */
-    readonly error: Signal<unknown>;
+    readonly error: Signal<Error | undefined>;
     /**
      * Whether this resource is loading a new value (or reloading the existing one).
      */
@@ -80,15 +65,6 @@ export interface Resource<T> {
      * This function is reactive.
      */
     hasValue(): this is Resource<Exclude<T, undefined>>;
-    /**
-     * Instructs the resource to re-load any asynchronous dependency it may have.
-     *
-     * Note that the resource will not enter its reloading state until the actual backend request is
-     * made.
-     *
-     * @returns true if a reload was initiated, false if a reload was unnecessary or unsupported
-     */
-    reload(): boolean;
 }
 /**
  * A `Resource` with a mutable value.
@@ -109,6 +85,15 @@ export interface WritableResource<T> extends Resource<T> {
      */
     update(updater: (value: T) => T): void;
     asReadonly(): Resource<T>;
+    /**
+     * Instructs the resource to re-load any asynchronous dependency it may have.
+     *
+     * Note that the resource will not enter its reloading state until the actual backend request is
+     * made.
+     *
+     * @returns true if a reload was initiated, false if a reload was unnecessary or unsupported
+     */
+    reload(): boolean;
 }
 /**
  * A `WritableResource` created through the `resource` function.
@@ -129,7 +114,7 @@ export interface ResourceRef<T> extends WritableResource<T> {
  * @experimental
  */
 export interface ResourceLoaderParams<R> {
-    request: Exclude<NoInfer<R>, undefined>;
+    params: NoInfer<Exclude<R, undefined>>;
     abortSignal: AbortSignal;
     previous: {
         status: ResourceStatus;
@@ -159,10 +144,10 @@ export interface BaseResourceOptions<T, R> {
      *
      * If a request function isn't provided, the loader won't rerun unless the resource is reloaded.
      */
-    request?: () => R;
+    params?: () => R;
     /**
      * The value which will be returned from the resource when a server value is unavailable, such as
-     * when the resource is still loading, or in an error state.
+     * when the resource is still loading.
      */
     defaultValue?: NoInfer<T>;
     /**
@@ -215,5 +200,5 @@ export type ResourceOptions<T, R> = PromiseResourceOptions<T, R> | StreamingReso
 export type ResourceStreamItem<T> = {
     value: T;
 } | {
-    error: unknown;
+    error: Error;
 };

package/import/resource/resource.d.ts

@@ -8,7 +8,7 @@
 import { WritableSignal } from '../render3/reactivity/signal';
 import { Signal } from '../render3/reactivity/api';
 import { ResourceOptions, ResourceStatus, WritableResource, Resource, ResourceRef, ResourceStreamingLoader } from './api';
-import { ValueEqualityFn } from '@angular/core/primitives/signals';
+import { ValueEqualityFn } from '../../primitives/signals';
 import { Injector } from '../di/injector';
 /**
  * Constructs a `Resource` that projects a reactive request to an asynchronous operation defined by
@@ -18,7 +18,7 @@ import { Injector } from '../di/injector';
  * `resource` will cancel in-progress loads via the `AbortSignal` when destroyed or when a new
  * request object becomes available, which could prematurely abort mutations.
  *
- * @experimental
+ * @experimental 19.0
  */
 export declare function resource<T, R>(options: ResourceOptions<T, R> & {
     defaultValue: NoInfer<T>;
@@ -31,7 +31,7 @@ export declare function resource<T, R>(options: ResourceOptions<T, R> & {
  * `resource` will cancel in-progress loads via the `AbortSignal` when destroyed or when a new
  * request object becomes available, which could prematurely abort mutations.
  *
- * @experimental
+ * @experimental 19.0
  */
 export declare function resource<T, R>(options: ResourceOptions<T, R>): ResourceRef<T | undefined>;
 type WrappedRequest = {
@@ -44,10 +44,11 @@ type WrappedRequest = {
 declare abstract class BaseWritableResource<T> implements WritableResource<T> {
     readonly value: WritableSignal<T>;
     abstract readonly status: Signal<ResourceStatus>;
-    abstract readonly error: Signal<unknown>;
+    abstract readonly error: Signal<Error | undefined>;
     abstract reload(): boolean;
     constructor(value: Signal<T>);
     abstract set(value: T): void;
+    private readonly isError;
     update(updateFn: (value: T) => T): void;
     readonly isLoading: Signal<boolean>;
     hasValue(): this is ResourceRef<Exclude<T, undefined>>;
@@ -58,7 +59,6 @@ declare abstract class BaseWritableResource<T> implements WritableResource<T> {
  */
 export declare class ResourceImpl<T, R> extends BaseWritableResource<T> implements ResourceRef<T> {
     private readonly loaderFn;
-    private readonly defaultValue;
     private readonly equal;
     private readonly pendingTasks;
     /**
@@ -74,9 +74,10 @@ export declare class ResourceImpl<T, R> extends BaseWritableResource<T> implemen
     private pendingController;
     private resolvePendingTask;
     private destroyed;
-    constructor(request: () => R, loaderFn: ResourceStreamingLoader<T, R>, defaultValue: T, equal: ValueEqualityFn<T> | undefined, injector: Injector);
+    private unregisterOnDestroy;
+    constructor(request: () => R, loaderFn: ResourceStreamingLoader<T, R>, defaultValue: T, equal: ValueEqualityFn<T> | undefined, injector: Injector, throwErrorsFromValue?: boolean);
     readonly status: Signal<ResourceStatus>;
-    readonly error: Signal<unknown>;
+    readonly error: Signal<Error | undefined>;
     /**
      * Called either directly via `WritableResource.set` or via `.value.set()`.
      */
@@ -86,4 +87,5 @@ export declare class ResourceImpl<T, R> extends BaseWritableResource<T> implemen
     private loadEffect;
     private abortInProgressLoad;
 }
+export declare function encapsulateResourceError(error: unknown): Error;
 export {};