static-injector 6.1.2 → 6.2.0

package/package.json

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

package/primitives/di/index.d.ts

@@ -5,8 +5,9 @@
  * 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 { setCurrentInjector, getCurrentInjector, inject } 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';
+export { defineInjectable, registerInjectable } from './src/injection_token';

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

@@ -61,3 +61,12 @@ export interface ɵɵInjectableDeclaration<T> {
 export interface InjectionToken<T> {
     ɵprov: ɵɵInjectableDeclaration<T>;
 }
+export declare function defineInjectable<T>(opts: {
+    token: unknown;
+    providedIn?: Type<any> | 'root' | 'platform' | 'any' | 'environment' | null;
+    factory: () => T;
+}): ɵɵInjectableDeclaration<T>;
+export type Constructor<T> = Function & {
+    prototype: T;
+};
+export declare function registerInjectable<T>(ctor: unknown, declaration: ɵɵInjectableDeclaration<T>): InjectionToken<T>;

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

@@ -5,10 +5,11 @@
  * 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 { Constructor, 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;
+export declare function inject<T>(token: InjectionToken<T> | Constructor<T>): T;

package/primitives/signals/index.d.ts

@@ -6,11 +6,13 @@
  * 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, PreviousValue, createLinkedSignal, linkedSignalSetFn, linkedSignalUpdateFn } from './src/linked_signal';
 export { ValueEqualityFn, defaultEquals } from './src/equality';
 export { setThrowInvalidWriteToSignalError } from './src/errors';
-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 { REACTIVE_NODE, Reactive, ReactiveHookFn, ReactiveNode, SIGNAL, consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, finalizeConsumerAfterComputation, getActiveConsumer, isInNotificationPhase, isReactive, producerAccessed, producerIncrementEpoch, producerMarkClean, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, resetConsumerBeforeComputation, runPostProducerCreatedFn, setActiveConsumer, setPostProducerCreatedFn, Version, } 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';
+export { runEffect, BASE_EFFECT_NODE, BaseEffectNode } from './src/effect';
+export { installDevToolsSignalFormatter } from './src/formatter';

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

@@ -0,0 +1,26 @@
+/**
+ * @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 { ReactiveNode } from './graph';
+/**
+ * An effect can, optionally, register a cleanup function. If registered, the cleanup is executed
+ * before the next effect run. The cleanup function makes it possible to "cancel" any work that the
+ * previous effect run might have started.
+ */
+export type EffectCleanupFn = () => void;
+/**
+ * A callback passed to the effect function that makes it possible to register cleanup logic.
+ */
+export type EffectCleanupRegisterFn = (cleanupFn: EffectCleanupFn) => void;
+export interface BaseEffectNode extends ReactiveNode {
+    fn: () => void;
+    destroy(): void;
+    cleanup(): void;
+    run(): void;
+}
+export declare const BASE_EFFECT_NODE: Omit<BaseEffectNode, 'fn' | 'destroy' | 'cleanup' | 'run'>;
+export declare function runEffect(node: BaseEffectNode): void;

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

@@ -0,0 +1,18 @@
+/**
+ * @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
+ */
+declare global {
+    var devtoolsFormatters: any[];
+}
+/**
+ * Installs the custom formatter into custom formatting on Signals in the devtools.
+ *
+ * Supported by both Chrome and Firefox.
+ *
+ * @see https://firefox-source-docs.mozilla.org/devtools-user/custom_formatters/index.html
+ */
+export declare function installDevToolsSignalFormatter(): void;

package/primitives/signals/src/graph.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
  */
-type Version = number & {
+export type Version = number & {
     __brand: 'Version';
 };
 export type ReactiveHookFn = (node: ReactiveNode) => void;
@@ -23,6 +23,14 @@ export interface Reactive {
 }
 export declare function isReactive(value: unknown): value is Reactive;
 export declare const REACTIVE_NODE: ReactiveNode;
+interface ReactiveLink {
+    producer: ReactiveNode;
+    consumer: ReactiveNode;
+    lastReadVersion: number;
+    prevConsumer: ReactiveLink | undefined;
+    nextConsumer: ReactiveLink | undefined;
+    nextProducer: ReactiveLink | undefined;
+}
 /**
  * A producer and/or consumer which participates in the reactive graph.
  *
@@ -58,47 +66,26 @@ export interface ReactiveNode {
      */
     dirty: boolean;
     /**
-     * Producers which are dependencies of this consumer.
-     *
-     * Uses the same indices as the `producerLastReadVersion` and `producerIndexOfThis` arrays.
-     */
-    producerNode: ReactiveNode[] | undefined;
-    /**
-     * `Version` of the value last read by a given producer.
-     *
-     * Uses the same indices as the `producerNode` and `producerIndexOfThis` arrays.
+     * Whether this node is currently rebuilding its producer list.
      */
-    producerLastReadVersion: Version[] | undefined;
+    recomputing: boolean;
     /**
-     * Index of `this` (consumer) in each producer's `liveConsumers` array.
-     *
-     * This value is only meaningful if this node is live (`liveConsumers.length > 0`). Otherwise
-     * these indices are stale.
-     *
-     * Uses the same indices as the `producerNode` and `producerLastReadVersion` arrays.
-     */
-    producerIndexOfThis: number[] | undefined;
-    /**
-     * Index into the producer arrays that the next dependency of this node as a consumer will use.
-     *
-     * This index is zeroed before this node as a consumer begins executing. When a producer is read,
-     * it gets inserted into the producers arrays at this index. There may be an existing dependency
-     * in this location which may or may not match the incoming producer, depending on whether the
-     * same producers were read in the same order as the last computation.
+     * Producers which are dependencies of this consumer.
      */
-    nextProducerIndex: number;
+    producers: ReactiveLink | undefined;
     /**
-     * Array of consumers of this producer that are "live" (they require push notifications).
+     * Points to the last linked list node in the `producers` linked list.
      *
-     * `liveConsumerNode.length` is effectively our reference count for this node.
+     * When this node is recomputing, this is used to track the producers that we have accessed so far.
      */
-    liveConsumerNode: ReactiveNode[] | undefined;
+    producersTail: ReactiveLink | undefined;
     /**
-     * Index of `this` (producer) in each consumer's `producerNode` array.
+     * Linked list of consumers of this producer that are "live" (they require push notifications).
      *
-     * Uses the same indices as the `liveConsumerNode` array.
+     * The length of this list is effectively our reference count for this node.
      */
-    liveConsumerIndexOfThis: number[] | undefined;
+    consumers: ReactiveLink | undefined;
+    consumersTail: ReactiveLink | undefined;
     /**
      * Whether writes to signals are allowed when this consumer is the `activeConsumer`.
      *
@@ -158,19 +145,39 @@ export declare function producerUpdatesAllowed(): boolean;
 export declare function consumerMarkDirty(node: ReactiveNode): void;
 export declare function producerMarkClean(node: ReactiveNode): void;
 /**
- * Prepare this consumer to run a computation in its reactive context.
+ * Prepare this consumer to run a computation in its reactive context and set
+ * it as the active consumer.
  *
  * Must be called by subclasses which represent reactive computations, before those computations
  * begin.
  */
 export declare function consumerBeforeComputation(node: ReactiveNode | null): ReactiveNode | null;
 /**
- * Finalize this consumer's state after a reactive computation has run.
+ * Prepare this consumer to run a computation in its reactive context.
+ *
+ * We expose this mainly for code where we manually batch effects into a single
+ * consumer. In those cases we may wish to "reopen" a consumer multiple times
+ * in initial render before finalizing it. Most code should just call
+ * `consumerBeforeComputation` instead of calling this directly.
+ */
+export declare function resetConsumerBeforeComputation(node: ReactiveNode): void;
+/**
+ * Finalize this consumer's state and set previous consumer as the active consumer after a
+ * reactive computation has run.
  *
  * Must be called by subclasses which represent reactive computations, after those computations
  * have finished.
  */
 export declare function consumerAfterComputation(node: ReactiveNode | null, prevConsumer: ReactiveNode | null): void;
+/**
+ * Finalize this consumer's state after a reactive computation has run.
+ *
+ * We expose this mainly for code where we manually batch effects into a single
+ * consumer. In those cases we may wish to "reopen" a consumer multiple times
+ * in initial render before finalizing it. Most code should just call
+ * `consumerAfterComputation` instead of calling this directly.
+ */
+export declare function finalizeConsumerAfterComputation(node: ReactiveNode): void;
 /**
  * Determine whether this consumer has any dependencies which have changed since the last time
  * they were read.

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

@@ -7,10 +7,11 @@
  */
 import { ValueEqualityFn } from './equality';
 import { ReactiveNode, SIGNAL } from './graph';
-export type ComputationFn<S, D> = (source: S, previous?: {
+export type ComputationFn<S, D> = (source: S, previous?: PreviousValue<S, D>) => D;
+export type PreviousValue<S, D> = {
     source: S;
     value: D;
-}) => D;
+};
 export interface LinkedSignalNode<S, D> extends ReactiveNode {
     /**
      * Value of the source signal that was used to derive the computed value.

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

@@ -34,7 +34,6 @@ export interface Watch {
     [SIGNAL]: WatchNode;
 }
 export interface WatchNode extends ReactiveNode {
-    hasRun: boolean;
     fn: ((onCleanup: WatchCleanupRegisterFn) => void) | null;
     schedule: ((watch: Watch) => void) | null;
     cleanupFn: WatchCleanupFn;

package/readme.md

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