@tstdl/base 0.90.60 → 0.90.62

package/core.d.ts

@@ -1,8 +1,7 @@
 import type { CancellationSignal } from './cancellation/token.js';
 import { Injector } from './injector/injector.js';
-import type { InjectionToken } from './injector/token.js';
-import type { LoggerArgument } from './logger/index.js';
-import { LogLevel, Logger } from './logger/index.js';
+import { type InjectionToken } from './injector/token.js';
+import { LogLevel, Logger, type LoggerArgument } from './logger/index.js';
 declare global {
     var tstdlLoaded: boolean | undefined;
 }

package/function/log.d.ts

@@ -1,7 +1,8 @@
 import type { Logger } from '../logger/logger.js';
 export type WrapLogOptions = {
     fnName?: string;
+    logResult?: boolean;
     logger?: Logger;
     trace?: boolean;
 };
-export declare function wrapLog(fn: Function, { fnName, logger, trace }?: WrapLogOptions): Function;
+export declare function wrapLog(fn: Function, { fnName, logResult, logger, trace }?: WrapLogOptions): Function;

package/function/log.js

@@ -1,23 +1,28 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import { isArray, isPrimitive, isString } from '../utils/type-guards.js';
 import { typeOf } from '../utils/type-of.js';
-export function wrapLog(fn, { fnName = fn.name, logger, trace = false } = {}) {
+export function wrapLog(fn, { fnName = fn.name, logResult = true, logger, trace = false } = {}) {
     const log = logger?.trace.bind(logger) ?? console.log.bind(console); // eslint-disable-line no-console
     const wrapped = {
         [fnName](...args) {
-            const argString = args.map((arg) => stringifyArg(arg)).join(', ');
+            const argString = args.map((arg) => stringifyValue(arg)).join(', ');
             log(`[call: ${fnName}(${argString})]`);
             if (trace) {
                 console.trace();
             }
-            return Reflect.apply(fn, this, args);
+            const result = Reflect.apply(fn, this, args);
+            if (logResult) {
+                const resultString = stringifyValue(result);
+                log(`[return: ${fnName} => ${resultString}]`);
+            }
+            return result;
         }
     };
     return wrapped[fnName];
 }
-function stringifyArg(arg, depth = 1) {
+function stringifyValue(arg, depth = 1) {
     if (isArray(arg) && (depth > 0)) {
-        const argString = arg.map((innerArg) => stringifyArg(innerArg, depth - 1)).join(', ');
+        const argString = arg.map((innerArg) => stringifyValue(innerArg, depth - 1)).join(', ');
         return `[${argString}]`;
     }
     return isPrimitive(arg) ? isString(arg) ? `"${arg}"` : String(arg) : typeOf(arg);

package/http/http-query.d.ts

@@ -1,5 +1,4 @@
-import type { HttpValueMapInput } from './http-value-map.js';
-import { HttpValueMap } from './http-value-map.js';
+import { HttpValueMap, type HttpValueMapInput } from './http-value-map.js';
 import type { HttpValueObject, NormalizedHttpValueObject } from './types.js';
 export type HttpQueryObject = HttpValueObject;
 export type NormalizedHttpQueryObject = NormalizedHttpValueObject;

package/http/server/node/node-http-server.d.ts

@@ -1,10 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
 import * as Http from 'node:http';
-import type { AsyncDisposable } from '../../../disposable/index.js';
-import { disposeAsync } from '../../../disposable/index.js';
+import { disposeAsync, type AsyncDisposable } from '../../../disposable/index.js';
 import { Logger } from '../../../logger/index.js';
-import type { HttpServerRequestContext } from '../http-server.js';
-import { HttpServer } from '../http-server.js';
+import { HttpServer, type HttpServerRequestContext } from '../http-server.js';
 export type NodeHttpServerContext = {
     nodeRequest: Http.IncomingMessage;
     nodeResponse: Http.ServerResponse;

package/injector/inject.d.ts

@@ -1,5 +1,4 @@
-import type { ResolveManyItem, ResolveManyReturnType } from './injector.js';
-import { Injector } from './injector.js';
+import { Injector, type ResolveManyItem, type ResolveManyReturnType } from './injector.js';
 import type { Resolvable, ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
 import type { ResolveOptions } from './types.js';

package/injector/injector.d.ts

@@ -1,13 +1,18 @@
-import type { AsyncDisposable } from '../disposable/disposable.js';
+import { type AsyncDisposable } from '../disposable/disposable.js';
 import type { OneOrMany, Record, TypedOmit } from '../types.js';
-import type { InjectOptions } from './inject.js';
-import type { ResolveArgument } from './interfaces.js';
+import { type InjectOptions } from './inject.js';
+import { type ResolveArgument } from './interfaces.js';
 import { type Provider } from './provider.js';
 import { type InjectionToken } from './token.js';
 import type { RegistrationOptions, ResolveOptions } from './types.js';
+export type ProvidersItem<T = any, A = any, D extends Record = Record> = Provider<T, A, D> & {
+    provide: InjectionToken<T, A>;
+    multi?: boolean;
+};
 export type GlobalRegistration<T = any, A = any> = {
     token: InjectionToken<T, A>;
     provider: Provider<T, A>;
+    providers: ProvidersItem[];
     options: RegistrationOptions<T, A>;
 };
 export type Registration<T = any, A = any> = GlobalRegistration<T, A> & {
@@ -37,7 +42,7 @@ export declare class Injector implements AsyncDisposable {
      * @param provider provider used to resolve the token
      * @param options registration options
      */
-    static register<T, A = any, C extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, C>>, options?: RegistrationOptions<T, A, C>): void;
+    static register<T, A = any, D extends Record = Record>(token: InjectionToken<T, A>, providers: OneOrMany<Provider<T, A, D>>, options?: RegistrationOptions<T, A, D>): void;
     /**
      * Globally register a provider for a token as a singleton. Alias for {@link register} with `singleton` lifecycle
      * @param token token to register

package/injector/injector.js

@@ -54,11 +54,13 @@ export class Injector {
      * @param options registration options
      */
     static register(token, providers, options = {}) {
+        const multi = isArray(providers);
         for (const provider of toArray(providers)) {
             const registration = {
                 token,
                 provider,
-                options: { multi: isArray(providers), ...options }
+                providers: options.providers ?? [],
+                options: { multi, ...options }
             };
             addRegistration(Injector.#globalRegistrations, registration);
         }
@@ -93,11 +95,13 @@ export class Injector {
      */
     register(token, providers, options = {}) {
         this.assertNotDisposed();
+        const multi = isArray(providers);
         for (const provider of toArray(providers)) {
             const registration = {
                 token,
                 provider,
-                options: { multi: isArray(providers), ...options },
+                providers: options.providers ?? [],
+                options: { multi, ...options },
                 resolutions: new Map()
             };
             addRegistration(this.#registrations, registration);
@@ -125,20 +129,22 @@ export class Injector {
      * @param token token to get registration for
      */
     tryGetRegistration(token, options) {
-        if (isNull(this.#parent) && !this.#registrations.has(token) && Injector.#globalRegistrations.has(token)) {
-            const globalRegistrations = toArray(Injector.#globalRegistrations.get(token));
+        if (isNull(this.#parent) && !this.#registrations.has(token)) {
+            const globalRegistrations = toArray(Injector.#globalRegistrations.get(token) ?? []);
             for (const globalRegistration of globalRegistrations) {
                 this.register(globalRegistration.token, globalRegistration.provider, globalRegistration.options);
             }
         }
-        const ownRegistration = (options?.skipSelf != true) ? this.#registrations.get(token) : undefined;
-        if (isDefined(ownRegistration)) {
-            return ownRegistration;
+        if (options?.skipSelf != true) {
+            const ownRegistration = this.#registrations.get(token);
+            if (isDefined(ownRegistration)) {
+                return ownRegistration;
+            }
         }
-        if (options?.onlySelf == true) {
-            return undefined;
+        if (options?.onlySelf != true) {
+            return this.#parent?.tryGetRegistration(token);
         }
-        return this.#parent?.tryGetRegistration(token);
+        return undefined;
     }
     /**
      * Get registration
@@ -212,17 +218,17 @@ export class Injector {
             throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
         }
         const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
-        if (isUndefined(registration)) {
-            if (isNotNull(this.#parent) && (options.onlySelf != true)) {
-                return this.#parent._resolve(token, argument, { ...options, skipSelf: false }, context, chain);
-            }
-            if (options.optional == true) {
-                return undefined;
-            }
-            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        if (isDefined(registration)) {
+            const singleRegistration = isArray(registration) ? registration[0] : registration;
+            return this._resolveRegistration(singleRegistration, argument, options, context, chain);
+        }
+        if (isNotNull(this.#parent) && (options.onlySelf != true)) {
+            return this.#parent._resolve(token, argument, { ...options, skipSelf: false }, context, chain);
+        }
+        if (options.optional == true) {
+            return undefined;
         }
-        const singleRegistration = isArray(registration) ? registration[0] : registration;
-        return this._resolveRegistration(singleRegistration, argument, options, context, chain);
+        throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
     }
     _resolveAll(token, argument, options, context, chain) {
         this.assertNotDisposed();
@@ -237,29 +243,33 @@ export class Injector {
             throw new ResolveError('Token is undefined - this might be because of circular dependencies, use alias or forwardRef in this case.', chain);
         }
         const registration = (options.skipSelf == true) ? undefined : this.tryGetRegistration(token);
-        if (isUndefined(registration)) {
-            if (isNotNull(this.#parent) && (options.onlySelf != true)) {
-                return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
-            }
-            if (options.optional == true) {
-                return [];
-            }
-            throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
+        if (isDefined(registration)) {
+            const registrations = isArray(registration) ? registration : [registration];
+            return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
         }
-        const registrations = isArray(registration) ? registration : [registration];
-        return registrations.map((reg) => this._resolveRegistration(reg, argument, options, context, chain));
+        if (isNotNull(this.#parent) && (options.onlySelf != true)) {
+            return this.#parent._resolveAll(token, argument, { ...options, skipSelf: false }, context, chain);
+        }
+        if (options.optional == true) {
+            return [];
+        }
+        throw new ResolveError(`No provider for ${getTokenName(token)} registered.`, chain);
     }
     _resolveRegistration(registration, argument, options, context, chain) {
         checkOverflow(chain, context);
-        const injectionContext = this.getInjectionContext(context, argument, chain);
+        const { token, providers } = registration;
+        const injector = (providers.length > 0) ? this.fork('LocalProvidersInjector') : this;
+        for (const nestedProvider of providers) {
+            injector.register(nestedProvider.provide, nestedProvider, { multi: nestedProvider.multi });
+        }
+        const injectionContext = injector.getInjectionContext(context, argument, chain);
         const previousInjectionContext = setCurrentInjectionContext(injectionContext);
         const resolutionTag = Symbol(); // eslint-disable-line symbol-description
         try {
-            const { token } = registration;
             const resolutionScoped = registration.options.lifecycle == 'resolution';
             const injectorScoped = registration.options.lifecycle == 'injector';
             const singletonScoped = registration.options.lifecycle == 'singleton';
-            const resolveArgument = argument ?? registration.options.defaultArgument ?? (registration.options.defaultArgumentProvider?.(this.getResolveContext(resolutionTag, context, chain)));
+            const resolveArgument = argument ?? registration.options.defaultArgument ?? (registration.options.defaultArgumentProvider?.(injector.getResolveContext(resolutionTag, context, chain)));
             const argumentIdentity = resolveArgumentIdentity(registration, resolveArgument);
             if (resolutionScoped && context.resolutionScopedResolutions.hasFlat(token, argumentIdentity)) {
                 return context.resolutionScopedResolutions.getFlat(token, argumentIdentity).value;
@@ -270,13 +280,13 @@ export class Injector {
             else if (singletonScoped && registration.resolutions.has(argumentIdentity)) {
                 return registration.resolutions.get(argumentIdentity);
             }
-            const value = this._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
+            const value = injector._resolveProvider(resolutionTag, registration, resolveArgument, options, context, injectionContext, chain);
             const resolution = {
                 tag: resolutionTag,
                 registration,
                 value,
                 argument: injectionContext.argument,
-                afterResolveContext: this.getAfterResolveContext(resolutionTag, context),
+                afterResolveContext: injector.getAfterResolveContext(resolutionTag, context),
                 chain
             };
             context.resolutions.push(resolution);

package/injector/types.d.ts

@@ -2,11 +2,11 @@ import type { CancellationSignal } from '../cancellation/index.js';
 import type { AsyncDisposeHandler } from '../disposable/async-disposer.js';
 import type { Record } from '../types.js';
 import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
-import type { Injector } from './injector.js';
+import type { Injector, ProvidersItem } from './injector.js';
 import type { ResolveArgument } from './interfaces.js';
 import type { InjectionToken } from './token.js';
 /**
- * transient: new resolution for every resolve
+ * Transient: new resolution for every resolve
  * resolution: one resolution per resolve tree
  * injector: one resolution per injector
  * singleton: one resolution at injector where token is registered
@@ -34,11 +34,13 @@ export type ResolveOptions<T, A> = {
     forwardRefTypeHint?: ForwardRefTypeHint;
 };
 /**
- * data to store between different stages like resolve and afterResolve
+ * Data to store between different stages like resolve and afterResolve
  */
 export type ResolveContextData<T extends Record> = T;
 export type RegistrationOptions<T, A = unknown, D extends Record = Record> = {
     lifecycle?: Lifecycle;
+    /** Local providers for inner resolutions */
+    providers?: ProvidersItem[];
     /** Default resolve argument used when neither token nor explicit resolve argument is provided */
     defaultArgument?: ResolveArgument<T, A>;
     /** Default resolve argument used when neither token nor explicit resolve argument is provided */
@@ -57,6 +59,6 @@ export type RegistrationOptions<T, A = unknown, D extends Record = Record> = {
     afterResolve?: (instance: T, argument: ResolveArgument<T, A>, context: AfterResolveContext<D>) => any;
     /** Whether multiple values can be resolved or not (used with {@link Injector.resolveAll}). If false, previous registrations are removed */
     multi?: boolean;
-    /** custom metadata */
+    /** Custom metadata */
     metadata?: Record;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.60",
+  "version": "0.90.62",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -105,11 +105,11 @@
     "./utils/string": "./utils/object/index.js"
   },
   "dependencies": {
-    "disposablestack": "^1.1",
+    "core-js": "3.36",
     "luxon": "^3.4",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.12"
+    "type-fest": "4.15"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -130,10 +130,10 @@
     "typedoc": "0.25",
     "typedoc-plugin-missing-exports": "2.2",
     "typescript": "5.4",
-    "typescript-eslint": "7.2"
+    "typescript-eslint": "7.5"
   },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.12",
+    "@elastic/elasticsearch": "^8.13",
     "@koa/router": "^12.0",
     "@tstdl/angular": "^0.90",
     "@zxcvbn-ts/core": "^3.0",
@@ -148,9 +148,9 @@
     "mongodb": "^6.5",
     "nodemailer": "^6.9",
     "playwright": "^1.42",
-    "preact": "^10.19",
+    "preact": "^10.20",
     "preact-render-to-string": "^6.4",
-    "undici": "^6.9",
+    "undici": "^6.11",
     "urlpattern-polyfill": "^10.0"
   },
   "peerDependenciesMeta": {

package/polyfills.d.ts

@@ -1,159 +1,2 @@
-import 'disposablestack/auto';
-declare global {
-    interface SymbolConstructor {
-        /**
-         * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
-         */
-        readonly dispose: unique symbol;
-        /**
-         * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
-         */
-        readonly asyncDispose: unique symbol;
-    }
-    interface Disposable {
-        [Symbol.dispose](): void;
-    }
-    interface AsyncDisposable {
-        [Symbol.asyncDispose](): PromiseLike<void>;
-    }
-    interface SuppressedError extends Error {
-        error: any;
-        suppressed: any;
-    }
-    interface SuppressedErrorConstructor extends ErrorConstructor {
-        new (error: any, suppressed: any, message?: string): SuppressedError;
-        (error: any, suppressed: any, message?: string): SuppressedError;
-        readonly prototype: SuppressedError;
-    }
-    var SuppressedError: SuppressedErrorConstructor;
-    interface DisposableStack {
-        /**
-         * Returns a value indicating whether this stack has been disposed.
-         */
-        readonly disposed: boolean;
-        /**
-         * Disposes each resource in the stack in the reverse order that they were added.
-         */
-        dispose(): void;
-        /**
-         * Adds a disposable resource to the stack, returning the resource.
-         * @param value The resource to add. `null` and `undefined` will not be added, but will be returned.
-         * @returns The provided {@link value}.
-         */
-        use<T extends Disposable | null | undefined>(value: T): T;
-        /**
-         * Adds a value and associated disposal callback as a resource to the stack.
-         * @param value The value to add.
-         * @param onDispose The callback to use in place of a `[Symbol.dispose]()` method. Will be invoked with `value`
-         * as the first parameter.
-         * @returns The provided {@link value}.
-         */
-        adopt<T>(value: T, onDispose: (value: T) => void): T;
-        /**
-         * Adds a callback to be invoked when the stack is disposed.
-         */
-        defer(onDispose: () => void): void;
-        /**
-         * Move all resources out of this stack and into a new `DisposableStack`, and marks this stack as disposed.
-         * @example
-         * ```ts
-         * class C {
-         *   #res1: Disposable;
-         *   #res2: Disposable;
-         *   #disposables: DisposableStack;
-         *   constructor() {
-         *     // stack will be disposed when exiting constructor for any reason
-         *     using stack = new DisposableStack();
-         *
-         *     // get first resource
-         *     this.#res1 = stack.use(getResource1());
-         *
-         *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
-         *     this.#res2 = stack.use(getResource2());
-         *
-         *     // all operations succeeded, move resources out of `stack` so that they aren't disposed
-         *     // when constructor exits
-         *     this.#disposables = stack.move();
-         *   }
-         *
-         *   [Symbol.dispose]() {
-         *     this.#disposables.dispose();
-         *   }
-         * }
-         * ```
-         */
-        move(): DisposableStack;
-        [Symbol.dispose](): void;
-        readonly [Symbol.toStringTag]: string;
-    }
-    interface DisposableStackConstructor {
-        new (): DisposableStack;
-        readonly prototype: DisposableStack;
-    }
-    var DisposableStack: DisposableStackConstructor;
-    interface AsyncDisposableStack {
-        /**
-         * Returns a value indicating whether this stack has been disposed.
-         */
-        readonly disposed: boolean;
-        /**
-         * Disposes each resource in the stack in the reverse order that they were added.
-         */
-        disposeAsync(): Promise<void>;
-        /**
-         * Adds a disposable resource to the stack, returning the resource.
-         * @param value The resource to add. `null` and `undefined` will not be added, but will be returned.
-         * @returns The provided {@link value}.
-         */
-        use<T extends AsyncDisposable | Disposable | null | undefined>(value: T): T;
-        /**
-         * Adds a value and associated disposal callback as a resource to the stack.
-         * @param value The value to add.
-         * @param onDisposeAsync The callback to use in place of a `[Symbol.asyncDispose]()` method. Will be invoked with `value`
-         * as the first parameter.
-         * @returns The provided {@link value}.
-         */
-        adopt<T>(value: T, onDisposeAsync: (value: T) => PromiseLike<void> | void): T;
-        /**
-         * Adds a callback to be invoked when the stack is disposed.
-         */
-        defer(onDisposeAsync: () => PromiseLike<void> | void): void;
-        /**
-         * Move all resources out of this stack and into a new `DisposableStack`, and marks this stack as disposed.
-         * @example
-         * ```ts
-         * class C {
-         *   #res1: Disposable;
-         *   #res2: Disposable;
-         *   #disposables: DisposableStack;
-         *   constructor() {
-         *     // stack will be disposed when exiting constructor for any reason
-         *     using stack = new DisposableStack();
-         *
-         *     // get first resource
-         *     this.#res1 = stack.use(getResource1());
-         *
-         *     // get second resource. If this fails, both `stack` and `#res1` will be disposed.
-         *     this.#res2 = stack.use(getResource2());
-         *
-         *     // all operations succeeded, move resources out of `stack` so that they aren't disposed
-         *     // when constructor exits
-         *     this.#disposables = stack.move();
-         *   }
-         *
-         *   [Symbol.dispose]() {
-         *     this.#disposables.dispose();
-         *   }
-         * }
-         * ```
-         */
-        move(): AsyncDisposableStack;
-        [Symbol.asyncDispose](): Promise<void>;
-        readonly [Symbol.toStringTag]: string;
-    }
-    interface AsyncDisposableStackConstructor {
-        new (): AsyncDisposableStack;
-        readonly prototype: AsyncDisposableStack;
-    }
-    var AsyncDisposableStack: AsyncDisposableStackConstructor;
-}
+import 'core-js/actual/async-disposable-stack/index.js';
+import 'core-js/actual/disposable-stack/index.js';

package/polyfills.js

@@ -1 +1,2 @@
-import 'disposablestack/auto';
+import 'core-js/actual/async-disposable-stack/index.js';
+import 'core-js/actual/disposable-stack/index.js';

package/reflection/decorators.d.ts

@@ -1,7 +1,7 @@
 import 'reflect-metadata/lite';
 import type { ConstructorParameterDecorator } from '../types.js';
 import type { Decorator, DecoratorHandler } from './types.js';
-import type { CreateDecoratorOptions, SpecificCreateDecoratorOptions } from './utils.js';
+import { type CreateDecoratorOptions, type SpecificCreateDecoratorOptions } from './utils.js';
 export declare function Decorate({ handler, ...options }?: CreateDecoratorOptions & {
     handler?: DecoratorHandler;
 }): Decorator;

package/signals/defer.d.ts

@@ -1,2 +1,2 @@
-import type { Signal } from './api.js';
+import { type Signal } from './api.js';
 export declare function defer<T>(signalFactory: () => Signal<T>): Signal<T>;

package/signals/implementation/effect.d.ts

@@ -21,19 +21,14 @@ export declare abstract class EffectScheduler {
      * It is an error to attempt to execute any effects synchronously during a scheduling operation.
      */
     abstract scheduleEffect(e: SchedulableEffect): void;
-}
-/**
- * Interface to an `EffectScheduler` capable of running scheduled effects synchronously.
- */
-export interface FlushableEffectRunner {
     /**
      * Run any scheduled effects.
      */
-    flush(): void;
+    abstract flush(): void;
 }
-export declare class TstdlEffectScheduler implements EffectScheduler, FlushableEffectRunner {
+export declare class TstdlEffectScheduler implements EffectScheduler {
     private readonly queue;
-    private pendingFlush;
+    private hasPendingFlush;
     scheduleEffect(effect: SchedulableEffect): void;
     flush(): void;
 }

package/signals/implementation/effect.js

@@ -15,13 +15,16 @@ export class EffectScheduler {
 }
 export class TstdlEffectScheduler {
     queue = new Set();
-    pendingFlush = false;
+    hasPendingFlush = false;
     scheduleEffect(effect) {
+        if (this.queue.has(effect)) {
+            return;
+        }
         this.queue.add(effect);
-        if (!this.pendingFlush) {
-            this.pendingFlush = true;
+        if (!this.hasPendingFlush) {
+            this.hasPendingFlush = true;
             queueMicrotask(() => {
-                this.pendingFlush = false;
+                this.hasPendingFlush = false;
                 this.flush();
             });
         }

package/signals/implementation/signal.d.ts

@@ -44,7 +44,7 @@ export interface WritableSignal<T> extends Signal<T> {
     update(updateFn: (value: T) => T): void;
     /**
      * Returns a readonly version of this signal. Readonly signals can be accessed to read their value
-     * but can't be changed using set, update or mutate methods. The readonly signals do _not_ have
+     * but can't be changed using set or update methods. The readonly signals do _not_ have
      * any built-in mechanism that would prevent deep-mutation of their value.
      */
     asReadonly(): Signal<T>;