static-injector 6.0.3 → 6.1.1

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "static-injector",
-  "version": "6.0.3",
+  "version": "6.1.1",
   "description": "Angular 依赖注入独立版本;Angular dependency injection standalone version",
   "keywords": [
     "angular",
-    "angular 19.2.0",
+    "angular 20.0.2",
     "injector",
     "typescript",
     "injectable",

package/primitives/di/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @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.dev/license
+ */
+export { setCurrentInjector, getCurrentInjector } from './src/injector';
+export type { Injector } from './src/injector';
+export { NOT_FOUND, NotFoundError, isNotFound } from './src/not_found';
+export type { NotFound } from './src/not_found';
+export type { InjectionToken, ɵɵInjectableDeclaration } from './src/injection_token';

package/primitives/di/src/injection_token.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @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.dev/license
+ */
+import { Type } from './type';
+/**
+ * Information about how a type or `InjectionToken` interfaces with the DI
+ * system. This describes:
+ *
+ * 1. *How* the type is provided
+ *    The declaration must specify only one of the following:
+ *    - A `value` which is a predefined instance of the type.
+ *    - A `factory` which defines how to create the given type `T`, possibly
+ *      requesting injection of other types if necessary.
+ *    - Neither, in which case the type is expected to already be present in the
+ *      injector hierarchy. This is used for internal use cases.
+ *
+ * 2. *Where* the type is stored (if it is stored)
+ *    - The `providedIn` parameter specifies which injector the type belongs to.
+ *    - The `token` is used as the key to store the type in the injector.
+ */
+export interface ɵɵInjectableDeclaration<T> {
+    /**
+     * Specifies that the given type belongs to a particular `Injector`,
+     * `NgModule`, or a special scope (e.g. `'root'`).
+     *
+     * `any` is deprecated and will be removed soon.
+     *
+     * A value of `null` indicates that the injectable does not belong to any
+     * scope, and won't be stored in any injector. For declarations with a
+     * factory, this will create a new instance of the type each time it is
+     * requested.
+     */
+    providedIn: Type<any> | 'root' | 'platform' | 'any' | null;
+    /**
+     * The token to which this definition belongs.
+     *
+     * Note that this may not be the same as the type that the `factory` will create.
+     */
+    token: unknown;
+    /**
+     * Factory method to execute to create an instance of the injectable.
+     */
+    factory?: (t?: Type<any>) => T;
+    /**
+     * In a case of no explicit injector, a location where the instance of the injectable is stored.
+     */
+    value?: T;
+}
+/**
+ * A `Type` which has a `ɵprov: ɵɵInjectableDeclaration` static field.
+ *
+ * `InjectableType`s contain their own Dependency Injection metadata and are usable in an
+ * `InjectorDef`-based `StaticInjector`.
+ *
+ * @publicApi
+ */
+export interface InjectionToken<T> {
+    ɵprov: ɵɵInjectableDeclaration<T>;
+}

package/primitives/di/src/injector.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @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.dev/license
+ */
+import { InjectionToken } from './injection_token';
+import { NotFound } from './not_found';
+export interface Injector {
+    retrieve<T>(token: InjectionToken<T>, options?: unknown): T | NotFound;
+}
+export declare function getCurrentInjector(): Injector | undefined | null;
+export declare function setCurrentInjector(injector: Injector | null | undefined): Injector | undefined | null;

package/primitives/di/src/not_found.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @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.dev/license
+ */
+/**
+ * Value returned if the key-value pair couldn't be found in the context
+ * hierarchy.
+ */
+export declare const NOT_FOUND: unique symbol;
+/**
+ * Error thrown when the key-value pair couldn't be found in the context
+ * hierarchy. Context can be attached below.
+ */
+export declare class NotFoundError extends Error {
+    readonly name: string;
+    constructor(message: string);
+}
+/**
+ * Type guard for checking if an unknown value is a NotFound.
+ */
+export declare function isNotFound(e: unknown): e is NotFound;
+/**
+ * Type union of NotFound and NotFoundError.
+ */
+export type NotFound = typeof NOT_FOUND | NotFoundError;

package/primitives/di/src/type.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @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.dev/license
+ */
+/**
+ * @description
+ *
+ * Represents a type that a Component or other object is instances of.
+ *
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is represented by
+ * the `MyCustomComponent` constructor function.
+ *
+ * @publicApi
+ */
+export declare const Type: FunctionConstructor;
+export declare function isType(v: any): v is Type<any>;
+/**
+ * @description
+ *
+ * Represents an abstract class `T`, if applied to a concrete class it would stop being
+ * instantiable.
+ *
+ * @publicApi
+ */
+export interface AbstractType<T> extends Function {
+    prototype: T;
+}
+export interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+/**
+ * Returns a writable type version of type.
+ *
+ * USAGE:
+ * Given:
+ * ```ts
+ * interface Person {readonly name: string}
+ * ```
+ *
+ * We would like to get a read/write version of `Person`.
+ * ```ts
+ * const WritablePerson = Writable<Person>;
+ * ```
+ *
+ * The result is that you can do:
+ *
+ * ```ts
+ * const readonlyPerson: Person = {name: 'Marry'};
+ * readonlyPerson.name = 'John'; // TypeError
+ * (readonlyPerson as WritablePerson).name = 'John'; // OK
+ *
+ * // Error: Correctly detects that `Person` did not have `age` property.
+ * (readonlyPerson as WritablePerson).age = 30;
+ * ```
+ */
+export type Writable<T> = {
+    -readonly [K in keyof T]: T[K];
+};

package/primitives/signals/index.d.ts

@@ -6,10 +6,11 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 export { ComputedNode, createComputed } from './src/computed';
-export { ComputationFn, LinkedSignalNode, LinkedSignalGetter, createLinkedSignal, linkedSignalSetFn, linkedSignalUpdateFn, } from './src/linked_signal';
+export { ComputationFn, LinkedSignalNode, LinkedSignalGetter, createLinkedSignal, linkedSignalSetFn, linkedSignalUpdateFn } from './src/linked_signal';
 export { ValueEqualityFn, defaultEquals } from './src/equality';
 export { setThrowInvalidWriteToSignalError } from './src/errors';
-export { REACTIVE_NODE, Reactive, ReactiveNode, SIGNAL, consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, getActiveConsumer, isInNotificationPhase, isReactive, producerAccessed, producerIncrementEpoch, producerMarkClean, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, setActiveConsumer, } from './src/graph';
-export { SIGNAL_NODE, SignalGetter, SignalNode, createSignal, runPostSignalSetFn, setPostSignalSetFn, signalSetFn, signalUpdateFn, } from './src/signal';
-export { Watch, WatchCleanupFn, WatchCleanupRegisterFn, createWatch, } from './src/watch';
+export { REACTIVE_NODE, Reactive, ReactiveHookFn, ReactiveNode, SIGNAL, consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, getActiveConsumer, isInNotificationPhase, isReactive, producerAccessed, producerIncrementEpoch, producerMarkClean, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, runPostProducerCreatedFn, setActiveConsumer, setPostProducerCreatedFn, } from './src/graph';
+export { SIGNAL_NODE, SignalGetter, SignalNode, createSignal, runPostSignalSetFn, setPostSignalSetFn, signalGetFn, signalSetFn, signalUpdateFn } from './src/signal';
+export { Watch, WatchCleanupFn, WatchCleanupRegisterFn, createWatch } from './src/watch';
 export { setAlternateWeakRefImpl } from './src/weak_ref';
+export { untracked } from './src/untracked';

package/primitives/signals/src/computed.d.ts

@@ -35,7 +35,7 @@ export type ComputedGetter<T> = (() => T) & {
 /**
  * Create a computed signal which derives a reactive value from an expression.
  */
-export declare function createComputed<T>(computation: () => T): ComputedGetter<T>;
+export declare function createComputed<T>(computation: () => T, equal?: ValueEqualityFn<T>): ComputedGetter<T>;
 /**
  * A dedicated symbol used before a computed value has been calculated for the first time.
  * Explicitly typed as `any` so we can use it as signal's value.

package/primitives/signals/src/graph.d.ts

@@ -8,6 +8,7 @@
 type Version = number & {
     __brand: 'Version';
 };
+export type ReactiveHookFn = (node: ReactiveNode) => void;
 /**
  * Symbol used to tell `Signal`s apart from other functions.
  *
@@ -179,4 +180,6 @@ export declare function consumerPollProducersForChange(node: ReactiveNode): bool
  * Disconnect this consumer from the graph.
  */
 export declare function consumerDestroy(node: ReactiveNode): void;
+export declare function runPostProducerCreatedFn(node: ReactiveNode): void;
+export declare function setPostProducerCreatedFn(fn: ReactiveHookFn | null): ReactiveHookFn | null;
 export {};

package/primitives/signals/src/linked_signal.d.ts

@@ -5,7 +5,7 @@
  * 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 { defaultEquals, ValueEqualityFn } from './equality';
+import { ValueEqualityFn } from './equality';
 import { ReactiveNode, SIGNAL } from './graph';
 export type ComputationFn<S, D> = (source: S, previous?: {
     source: S;
@@ -42,31 +42,4 @@ export type LinkedSignalGetter<S, D> = (() => D) & {
 export declare function createLinkedSignal<S, D>(sourceFn: () => S, computationFn: ComputationFn<S, D>, equalityFn?: ValueEqualityFn<D>): LinkedSignalGetter<S, D>;
 export declare function linkedSignalSetFn<S, D>(node: LinkedSignalNode<S, D>, newValue: D): void;
 export declare function linkedSignalUpdateFn<S, D>(node: LinkedSignalNode<S, D>, updater: (value: D) => D): void;
-export declare const LINKED_SIGNAL_NODE: {
-    value: any;
-    dirty: boolean;
-    error: null;
-    equal: typeof defaultEquals;
-    producerMustRecompute(node: LinkedSignalNode<unknown, unknown>): boolean;
-    producerRecomputeValue(node: LinkedSignalNode<unknown, unknown>): void;
-    version: number & {
-        __brand: "Version";
-    };
-    lastCleanEpoch: number & {
-        __brand: "Version";
-    };
-    producerNode: ReactiveNode[] | undefined;
-    producerLastReadVersion: (number & {
-        __brand: "Version";
-    })[] | undefined;
-    producerIndexOfThis: number[] | undefined;
-    nextProducerIndex: number;
-    liveConsumerNode: ReactiveNode[] | undefined;
-    liveConsumerIndexOfThis: number[] | undefined;
-    consumerAllowSignalWrites: boolean;
-    consumerIsAlwaysLive: boolean;
-    consumerMarkedDirty(node: unknown): void;
-    consumerOnSignalRead(node: unknown): void;
-    debugName?: string;
-    kind: string;
-};
+export declare const LINKED_SIGNAL_NODE: object;

package/primitives/signals/src/signal.d.ts

@@ -6,7 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 import { ValueEqualityFn } from './equality';
-import { ReactiveNode, SIGNAL } from './graph';
+import { ReactiveNode, ReactiveHookFn, SIGNAL } from './graph';
 export interface SignalNode<T> extends ReactiveNode {
     value: T;
     equal: ValueEqualityFn<T>;
@@ -14,16 +14,18 @@ export interface SignalNode<T> extends ReactiveNode {
 export type SignalBaseGetter<T> = (() => T) & {
     readonly [SIGNAL]: unknown;
 };
+export type SignalSetter<T> = (newValue: T) => void;
+export type SignalUpdater<T> = (updateFn: (value: T) => T) => void;
 export interface SignalGetter<T> extends SignalBaseGetter<T> {
     readonly [SIGNAL]: SignalNode<T>;
 }
 /**
- * Create a `Signal` that can be set or updated directly.
+ * Creates a `Signal` getter, setter, and updater function.
  */
-export declare function createSignal<T>(initialValue: T): SignalGetter<T>;
-export declare function setPostSignalSetFn(fn: (() => void) | null): (() => void) | null;
-export declare function signalGetFn<T>(this: SignalNode<T>): T;
+export declare function createSignal<T>(initialValue: T, equal?: ValueEqualityFn<T>): [SignalGetter<T>, SignalSetter<T>, SignalUpdater<T>];
+export declare function setPostSignalSetFn(fn: ReactiveHookFn | null): ReactiveHookFn | null;
+export declare function signalGetFn<T>(node: SignalNode<T>): T;
 export declare function signalSetFn<T>(node: SignalNode<T>, newValue: T): void;
 export declare function signalUpdateFn<T>(node: SignalNode<T>, updater: (value: T) => T): void;
-export declare function runPostSignalSetFn(): void;
+export declare function runPostSignalSetFn<T>(node: SignalNode<T>): void;
 export declare const SIGNAL_NODE: SignalNode<unknown>;

package/{import/render3/reactivity/patch.d.ts → primitives/signals/src/untracked.d.ts}

@@ -6,6 +6,7 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 /**
- * Controls whether effects use the legacy `microtaskEffect` by default.
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
  */
-export declare const USE_MICROTASK_EFFECT_BY_DEFAULT = false;
+export declare function untracked<T>(nonReactiveReadsFn: () => T): T;

package/readme.md

@@ -13,7 +13,7 @@
 
 # Source
 
-- Angular 19.2.0
+- Angular 20.0.2
 
 # Usage
 

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

@@ -1,21 +0,0 @@
-/**
- * @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.dev/license
- */
-import type { CreateEffectOptions, EffectCleanupRegisterFn, EffectRef } from './effect';
-import { type SchedulableEffect, ZoneAwareEffectScheduler } from './root_effect_scheduler';
-export declare class MicrotaskEffectScheduler extends ZoneAwareEffectScheduler {
-    private readonly pendingTasks;
-    private taskId;
-    schedule(effect: SchedulableEffect): void;
-    flush(): void;
-    /** @nocollapse */
-    static ɵprov: unknown;
-}
-/**
- * Create a global `Effect` for the given reactive function.
- */
-export declare function microtaskEffect(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, options?: CreateEffectOptions): EffectRef;