static-injector 5.0.2 → 6.0.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "static-injector",
-  "version": "5.0.2",
+  "version": "6.0.0",
   "description": "Angular 依赖注入独立版本;Angular dependency injection standalone version",
   "keywords": [
     "angular",
-    "angular 18.0.0",
+    "angular 19.0.0",
     "injector",
     "typescript",
     "injectable",
@@ -16,7 +16,13 @@
     "inversion of control container",
     "ioc",
     "javascript",
-    "node"
+    "node",
+    "signal",
+    "reactivity",
+    "effect",
+    "computed",
+    "resource",
+    "linkedSignal"
   ],
   "repository": {
     "type": "git",
@@ -26,12 +32,15 @@
     "url": "https://github.com/wszgrcy/static-injector/issues"
   },
   "homepage": "https://github.com/wszgrcy/static-injector#readme",
-  "main": "commonjs/index.js",
-  "es2022": "fesm2022/index.js",
-  "fesm2022": "fesm2022/index.js",
-  "esm2022": "esm2022/index.js",
-  "module": "fesm2022/index.js",
-  "typings": "typings/index.d.ts",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "default": "./index.mjs",
+      "types": "./import/index.d.ts"
+    }
+  },
   "private": false,
   "scripts": {},
   "author": "wszgrcy",
@@ -39,4 +48,4 @@
   "peerDependencies": {},
   "devDependencies": {},
   "sideEffects": false
-}
+}

package/primitives/signals/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @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 { ComputedNode, createComputed } from './src/computed';
+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 { setAlternateWeakRefImpl } from './src/weak_ref';

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

@@ -0,0 +1,55 @@
+/**
+ * @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 { ValueEqualityFn } from './equality';
+import { ReactiveNode, SIGNAL } from './graph';
+/**
+ * A computation, which derives a value from a declarative reactive expression.
+ *
+ * `Computed`s are both producers and consumers of reactivity.
+ */
+export interface ComputedNode<T> extends ReactiveNode {
+    /**
+     * Current value of the computation, or one of the sentinel values above (`UNSET`, `COMPUTING`,
+     * `ERROR`).
+     */
+    value: T;
+    /**
+     * If `value` is `ERRORED`, the error caught from the last computation attempt which will
+     * be re-thrown.
+     */
+    error: unknown;
+    /**
+     * The computation function which will produce a new value.
+     */
+    computation: () => T;
+    equal: ValueEqualityFn<T>;
+}
+export type ComputedGetter<T> = (() => T) & {
+    [SIGNAL]: ComputedNode<T>;
+};
+/**
+ * Create a computed signal which derives a reactive value from an expression.
+ */
+export declare function createComputed<T>(computation: () => 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.
+ */
+export declare const UNSET: any;
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * is in progress. Used to detect cycles in computation chains.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+export declare const COMPUTING: any;
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * failed. The thrown error is cached until the computation gets dirty again.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+export declare const ERRORED: any;

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

@@ -0,0 +1,15 @@
+/**
+ * @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
+ */
+/**
+ * A comparison function which can determine if two values are equal.
+ */
+export type ValueEqualityFn<T> = (a: T, b: T) => boolean;
+/**
+ * The default equality function used for `signal` and `computed`, which uses referential equality.
+ */
+export declare function defaultEquals<T>(a: T, b: T): boolean;

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

@@ -0,0 +1,10 @@
+/**
+ * @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 { SignalNode } from './signal';
+export declare function throwInvalidWriteToSignalError<T>(node: SignalNode<T>): void;
+export declare function setThrowInvalidWriteToSignalError(fn: <T>(node: SignalNode<T>) => never): void;

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

@@ -0,0 +1,182 @@
+/**
+ * @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
+ */
+type Version = number & {
+    __brand: 'Version';
+};
+/**
+ * Symbol used to tell `Signal`s apart from other functions.
+ *
+ * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ */
+export declare const SIGNAL: unique symbol;
+export declare function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null;
+export declare function getActiveConsumer(): ReactiveNode | null;
+export declare function isInNotificationPhase(): boolean;
+export interface Reactive {
+    [SIGNAL]: ReactiveNode;
+}
+export declare function isReactive(value: unknown): value is Reactive;
+export declare const REACTIVE_NODE: ReactiveNode;
+/**
+ * A producer and/or consumer which participates in the reactive graph.
+ *
+ * Producer `ReactiveNode`s which are accessed when a consumer `ReactiveNode` is the
+ * `activeConsumer` are tracked as dependencies of that consumer.
+ *
+ * Certain consumers are also tracked as "live" consumers and create edges in the other direction,
+ * from producer to consumer. These edges are used to propagate change notifications when a
+ * producer's value is updated.
+ *
+ * A `ReactiveNode` may be both a producer and consumer.
+ */
+export interface ReactiveNode {
+    /**
+     * Version of the value that this node produces.
+     *
+     * This is incremented whenever a new value is produced by this node which is not equal to the
+     * previous value (by whatever definition of equality is in use).
+     */
+    version: Version;
+    /**
+     * Epoch at which this node is verified to be clean.
+     *
+     * This allows skipping of some polling operations in the case where no signals have been set
+     * since this node was last read.
+     */
+    lastCleanEpoch: Version;
+    /**
+     * Whether this node (in its consumer capacity) is dirty.
+     *
+     * Only live consumers become dirty, when receiving a change notification from a dependency
+     * producer.
+     */
+    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.
+     */
+    producerLastReadVersion: Version[] | undefined;
+    /**
+     * 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.
+     */
+    nextProducerIndex: number;
+    /**
+     * Array of consumers of this producer that are "live" (they require push notifications).
+     *
+     * `liveConsumerNode.length` is effectively our reference count for this node.
+     */
+    liveConsumerNode: ReactiveNode[] | undefined;
+    /**
+     * Index of `this` (producer) in each consumer's `producerNode` array.
+     *
+     * Uses the same indices as the `liveConsumerNode` array.
+     */
+    liveConsumerIndexOfThis: number[] | undefined;
+    /**
+     * Whether writes to signals are allowed when this consumer is the `activeConsumer`.
+     *
+     * This is used to enforce guardrails such as preventing writes to writable signals in the
+     * computation function of computed signals, which is supposed to be pure.
+     */
+    consumerAllowSignalWrites: boolean;
+    readonly consumerIsAlwaysLive: boolean;
+    /**
+     * Tracks whether producers need to recompute their value independently of the reactive graph (for
+     * example, if no initial value has been computed).
+     */
+    producerMustRecompute(node: unknown): boolean;
+    producerRecomputeValue(node: unknown): void;
+    consumerMarkedDirty(node: unknown): void;
+    /**
+     * Called when a signal is read within this consumer.
+     */
+    consumerOnSignalRead(node: unknown): void;
+    /**
+     * A debug name for the reactive node. Used in Angular DevTools to identify the node.
+     */
+    debugName?: string;
+    /**
+     * Kind of node. Example: 'signal', 'computed', 'input', 'effect'.
+     *
+     * ReactiveNode has this as 'unknown' by default, but derived node types should override this to
+     * make available the kind of signal that particular instance of a ReactiveNode represents.
+     *
+     * Used in Angular DevTools to identify the kind of signal.
+     */
+    kind: string;
+}
+/**
+ * Called by implementations when a producer's signal is read.
+ */
+export declare function producerAccessed(node: ReactiveNode): void;
+/**
+ * Increment the global epoch counter.
+ *
+ * Called by source producers (that is, not computeds) whenever their values change.
+ */
+export declare function producerIncrementEpoch(): void;
+/**
+ * Ensure this producer's `version` is up-to-date.
+ */
+export declare function producerUpdateValueVersion(node: ReactiveNode): void;
+/**
+ * Propagate a dirty notification to live consumers of this producer.
+ */
+export declare function producerNotifyConsumers(node: ReactiveNode): void;
+/**
+ * Whether this `ReactiveNode` in its producer capacity is currently allowed to initiate updates,
+ * based on the current consumer context.
+ */
+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.
+ *
+ * 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.
+ *
+ * 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;
+/**
+ * Determine whether this consumer has any dependencies which have changed since the last time
+ * they were read.
+ */
+export declare function consumerPollProducersForChange(node: ReactiveNode): boolean;
+/**
+ * Disconnect this consumer from the graph.
+ */
+export declare function consumerDestroy(node: ReactiveNode): void;
+export {};

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

@@ -0,0 +1,72 @@
+/**
+ * @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 { defaultEquals, ValueEqualityFn } from './equality';
+import { ReactiveNode, SIGNAL } from './graph';
+export type ComputationFn<S, D> = (source: S, previous?: {
+    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.
+     */
+    sourceValue: S;
+    /**
+     * Current state value, or one of the sentinel values (`UNSET`, `COMPUTING`,
+     * `ERROR`).
+     */
+    value: D;
+    /**
+     * If `value` is `ERRORED`, the error caught from the last computation attempt which will
+     * be re-thrown.
+     */
+    error: unknown;
+    /**
+     * The source function represents reactive dependency based on which the linked state is reset.
+     */
+    source: () => S;
+    /**
+     * The computation function which will produce a new value based on the source and, optionally - previous values.
+     */
+    computation: ComputationFn<S, D>;
+    equal: ValueEqualityFn<D>;
+}
+export type LinkedSignalGetter<S, D> = (() => D) & {
+    [SIGNAL]: LinkedSignalNode<S, 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;
+};

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

@@ -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.dev/license
+ */
+import { ValueEqualityFn } from './equality';
+import { ReactiveNode, SIGNAL } from './graph';
+export interface SignalNode<T> extends ReactiveNode {
+    value: T;
+    equal: ValueEqualityFn<T>;
+}
+export type SignalBaseGetter<T> = (() => T) & {
+    readonly [SIGNAL]: unknown;
+};
+export interface SignalGetter<T> extends SignalBaseGetter<T> {
+    readonly [SIGNAL]: SignalNode<T>;
+}
+/**
+ * Create a `Signal` that can be set or updated directly.
+ */
+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 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 const SIGNAL_NODE: SignalNode<unknown>;

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

@@ -0,0 +1,43 @@
+/**
+ * @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, SIGNAL } from './graph';
+/**
+ * A cleanup function that can be optionally registered from the watch logic. If registered, the
+ * cleanup logic runs before the next watch execution.
+ */
+export type WatchCleanupFn = () => void;
+/**
+ * A callback passed to the watch function that makes it possible to register cleanup logic.
+ */
+export type WatchCleanupRegisterFn = (cleanupFn: WatchCleanupFn) => void;
+export interface Watch {
+    notify(): void;
+    /**
+     * Execute the reactive expression in the context of this `Watch` consumer.
+     *
+     * Should be called by the user scheduling algorithm when the provided
+     * `schedule` hook is called by `Watch`.
+     */
+    run(): void;
+    cleanup(): void;
+    /**
+     * Destroy the watcher:
+     * - disconnect it from the reactive graph;
+     * - mark it as destroyed so subsequent run and notify operations are noop.
+     */
+    destroy(): void;
+    [SIGNAL]: WatchNode;
+}
+export interface WatchNode extends ReactiveNode {
+    hasRun: boolean;
+    fn: ((onCleanup: WatchCleanupRegisterFn) => void) | null;
+    schedule: ((watch: Watch) => void) | null;
+    cleanupFn: WatchCleanupFn;
+    ref: Watch;
+}
+export declare function createWatch(fn: (onCleanup: WatchCleanupRegisterFn) => void, schedule: (watch: Watch) => void, allowSignalWrites: boolean): Watch;

package/{es2022/di/injector_marker.js → primitives/signals/src/weak_ref.d.ts}

@@ -3,6 +3,6 @@
  * 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
+ * found in the LICENSE file at https://angular.dev/license
  */
-export {};
+export declare function setAlternateWeakRefImpl(impl: unknown): void;

package/readme.md

@@ -8,9 +8,7 @@
 - No transformer required
 - 0 dependencies
 - Remove Decorator
-> `@Injectable()`=>`static injectOptions={}`
-> `@Inject() xx`=>`xx=inject()`
-> `@Optional()`=>`xx=inject(token,{optional:true})`
+  > `@Injectable()`=>`static injectOptions={}` > `@Inject() xx`=>`xx=inject()` > `@Optional()`=>`xx=inject(token,{optional:true})`
 - `JS`/`TS` Support
 
 # Source
@@ -20,8 +18,16 @@
 # Usage
 
 - Create a first level dependency injector with `Injector.create`
+
 ```ts
-import { Injector, inject } from 'static-injector';
+import {
+  Injector,
+  inject,
+  // root
+  createRootInjector,
+  // child
+  createInjector,
+} from 'static-injector';
 
 class Main {
   child = inject(Child);
@@ -31,23 +37,20 @@ class Child {
     return 'hello world';
   }
 }
-let injector = Injector.create({ providers: [Main, Child] });
+let injector = createRootInjector({ providers: [Main, Child] });
 const instance = injector.get(Main);
 console.log(instance.child.output());
 ```
 
-# Different from `injection-js`
-
-- `injection-js` belongs to dynamic dependency injection and is a version used before Angular5. Currently no longer updated
-- The two are basically interchangeable (the details need to be adjusted)
-
-- Support the use of `inject` during construction
-
 # No Decorator
 
 - The original use of `@Injectable()` to pass parameters has been changed to `static injectOptions={}`. If there are no parameters, there is no need to set them
 - Originally, `@Optional`, `@SkipSelf`, `@Self`, please use the second pass parameter of `inject` instead
 
+# reactivity
+
+- support `signal`,`effect`,`resource`,`linkedSignal`,`computed`
+
 # Test
 
 - Partially conducted unit testing to ensure that most functions are functioning properly
@@ -58,4 +61,5 @@ console.log(instance.child.output());
 - Currently, the synchronization logic has been refactored and modified using `@code-recycle/cli` to ensure consistency with the official version of `angular`
 
 # Examples
-- [https://github.com/wszgrcy/static-injector/tree/main/test/import](https://github.com/wszgrcy/static-injector/tree/main/test/import)
+
+- [https://github.com/wszgrcy/static-injector/tree/main/test/import](https://github.com/wszgrcy/static-injector/tree/main/test/import)