@valentin30/signal 0.0.3 → 0.0.5

package/dist/index.d.mts

@@ -1,18 +1,42 @@
+type Function = (...args: any[]) => any;
+
 type Maybe<T> = T | null | undefined;
 
-type Factory<Fn extends FactoryFunction> = Fn & {
+type Factory<Fn extends Function> = Fn & {
     factory(factory: Maybe<Fn>): void;
     default(factory: Maybe<Fn>): void;
     configured(): boolean;
 };
-type FactoryFunction = (...args: any[]) => any;
+declare function factory<Fn extends Function>(name: string): Factory<Fn>;
 
 interface Collector$1<T> {
     add(value: T): void;
+    collecting(): boolean;
     collect(callback: () => void): Readonly<Set<T>>;
+    ignore(callback: () => void): void;
+}
+type CollectorFactory = <T>() => Collector$1<T>;
+declare const collector$1: Factory<CollectorFactory>;
+
+type Callback = () => void;
+
+declare function batch$1(callback: Callback): void;
+declare function batch$1(callback: Callback, collector: Collector$1<Callback>): void;
+declare function batch$1(callback: Callback, collector?: Collector$1<Callback>): void;
+declare namespace batch$1 {
+    var collector: Factory<BatchCollectorFactory>;
+}
+type BatchCollectorFactory = () => Collector$1<Callback>;
+
+declare function collector<T>(): Collector$1<T>;
+declare class Collector<T> implements Collector$1<T> {
+    #private;
+    constructor(values: Set<T> | null);
+    collecting(): boolean;
+    add(value: T): void;
+    collect(callback: () => void): Set<T>;
+    ignore(callback: () => void): void;
 }
-type CollectorFactoryFunction = <T>() => Collector$1<T>;
-declare const collector$1: Factory<CollectorFactoryFunction>;
 
 type Equals<T> = (value: T, other: T) => boolean;
 interface Comparable<T> {
@@ -23,8 +47,6 @@ interface Reader<T> {
     read(): T;
 }
 
-type Callback = () => void;
-
 interface Subscription {
     subscribe(callback: Callback): Callback;
     unsubscribe(callback: Callback): void;
@@ -38,79 +60,70 @@ interface Signal$1<T> extends Reader<T>, Writer<T>, Comparable<T>, Subscription
 }
 interface ReadonlySignal<T> extends Reader<T>, Comparable<T>, Subscription {
 }
-type SignalFactoryFunction = <T>(value: T, equals?: Equals<T>) => Signal$1<T>;
-declare const signal$1: Factory<SignalFactoryFunction>;
-
-type ComposedFactoryFunction = <T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal$1<T>;
-declare const composed$1: Factory<ComposedFactoryFunction>;
-
-type ComputedFactoryFunction = <T>(compute: () => T, equals?: Equals<T>) => ReadonlySignal<T>;
-declare const computed$1: Factory<ComputedFactoryFunction>;
-
-type Effect = () => void;
-type EffectCallback = (init: boolean) => EffectCleanup | void;
-type EffectCleanup = (destroy: boolean) => void;
-type EffectFactoryFunction = (callback: EffectCallback) => Effect;
-declare const effect$1: Factory<EffectFactoryFunction>;
-
-declare function collector<T>(): Collector$1<T>;
-declare class Collector<T> implements Collector$1<T> {
-    private values;
-    constructor(values: Set<T> | null);
-    add(value: T): void;
-    collect(callback: () => void): Set<T>;
-}
+type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal$1<T>;
+declare const signal$1: Factory<SignalFactory>;
 
-declare function computed<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
-declare namespace computed {
-    var collector: Factory<ComputedCollectorFactoryFunction>;
+declare function computed$1<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
+declare namespace computed$1 {
+    var collector: Factory<ComputedCollectorFactory>;
 }
-type ComputedCollectorFactoryFunction = () => Collector$1<ReadonlySignal<unknown>>;
+type ComputedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
 declare class Computed<T> implements ReadonlySignal<T> {
-    private empty;
-    private value;
-    private values;
-    private dependencies;
-    private readonly compute;
-    private readonly equalsFn;
-    private readonly listeners;
-    private readonly collector;
-    constructor(empty: boolean, value: T | undefined, values: unknown[], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, equals: Maybe<Equals<T>>);
-    private dirty;
+    #private;
+    constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, equals: Maybe<Equals<T>>);
     read(): T;
     equals(other: T): boolean;
     subscribe(callback: Callback): Callback;
     unsubscribe(callback: Callback): void;
 }
 
-declare function composed<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): Composed<T>;
-declare namespace composed {
-    var collector: Factory<ComposedCollectorFactoryFunction>;
+type ComposedBatcherFactory = () => Collector$1<Callback>;
+type ComposedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
+declare function composed$1<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): Composed<T>;
+declare namespace composed$1 {
+    var batcher: Factory<ComposedBatcherFactory>;
+    var collector: Factory<ComposedCollectorFactory>;
 }
-type ComposedCollectorFactoryFunction = () => Collector$1<ReadonlySignal<unknown>>;
 declare class Composed<T> extends Computed<T> implements Signal$1<T> {
-    private readonly writeFn;
-    constructor(empty: boolean, value: T | undefined, values: unknown[], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, write: (value: T) => void, equals: Maybe<Equals<T>>);
+    #private;
+    constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, write: (value: T) => void, equals: Maybe<Equals<T>>);
     write(value: T): void;
 }
 
-type EffectCollectorFactoryFunction = () => Collector$1<ReadonlySignal<unknown>>;
+type Effect = (callback: EffectCallback) => Callback;
+type EffectCallback = (init: boolean) => EffectCleanup | void;
+type EffectCleanup = (destroy: boolean) => void;
+declare const effect$1: Factory<Effect>;
+
 declare function effect(cb: EffectCallback): Callback;
 declare namespace effect {
-    var collector: Factory<EffectCollectorFactoryFunction>;
+    var collector: Factory<EffectCollectorFactory>;
 }
+type EffectCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
 
+interface Ignore$1 {
+    <Value>(value: ReadonlySignal<Value>): Value;
+    <Value>(callback: () => Value): Value;
+    <Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
+}
+declare function ignore$1<Value>(value: ReadonlySignal<Value>): Value;
+declare function ignore$1<Value>(callback: () => Value): Value;
+declare function ignore$1<Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
+declare namespace ignore$1 {
+    var collector: Factory<IgnoreCollectorFactory>;
+}
+type IgnoreCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
+
+type SignalBatcherFactory = () => Collector$1<Callback>;
+type SignalCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
 declare function signal<T>(value: T, equals?: Equals<T>): Signal$1<T>;
 declare namespace signal {
-    var collector: Factory<SignalCollectorFactoryFunction>;
+    var batcher: Factory<SignalBatcherFactory>;
+    var collector: Factory<SignalCollectorFactory>;
 }
-type SignalCollectorFactoryFunction = () => Maybe<Collector$1<ReadonlySignal<unknown>>>;
 declare class Signal<T> implements Signal$1<T> {
-    private value;
-    private equalsFn;
-    private listeners;
-    private collector;
-    constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, collector: Maybe<Collector$1<ReadonlySignal<unknown>>>);
+    #private;
+    constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>);
     read(): T;
     write(value: T): void;
     equals(other: T): boolean;
@@ -118,36 +131,60 @@ declare class Signal<T> implements Signal$1<T> {
     unsubscribe(callback: Callback): void;
 }
 
+type index_BatchCollectorFactory = BatchCollectorFactory;
 type index_Collector<T> = Collector<T>;
 declare const index_Collector: typeof Collector;
 type index_Composed<T> = Composed<T>;
 declare const index_Composed: typeof Composed;
-type index_ComposedCollectorFactoryFunction = ComposedCollectorFactoryFunction;
+type index_ComposedBatcherFactory = ComposedBatcherFactory;
+type index_ComposedCollectorFactory = ComposedCollectorFactory;
 type index_Computed<T> = Computed<T>;
 declare const index_Computed: typeof Computed;
-type index_ComputedCollectorFactoryFunction = ComputedCollectorFactoryFunction;
-type index_EffectCollectorFactoryFunction = EffectCollectorFactoryFunction;
+type index_ComputedCollectorFactory = ComputedCollectorFactory;
+type index_EffectCollectorFactory = EffectCollectorFactory;
+type index_IgnoreCollectorFactory = IgnoreCollectorFactory;
 type index_Signal<T> = Signal<T>;
 declare const index_Signal: typeof Signal;
-type index_SignalCollectorFactoryFunction = SignalCollectorFactoryFunction;
+type index_SignalBatcherFactory = SignalBatcherFactory;
+type index_SignalCollectorFactory = SignalCollectorFactory;
 declare const index_collector: typeof collector;
-declare const index_composed: typeof composed;
-declare const index_computed: typeof computed;
 declare const index_effect: typeof effect;
 declare const index_signal: typeof signal;
 declare namespace index {
-  export { index_Collector as Collector, index_Composed as Composed, type index_ComposedCollectorFactoryFunction as ComposedCollectorFactoryFunction, index_Computed as Computed, type index_ComputedCollectorFactoryFunction as ComputedCollectorFactoryFunction, type index_EffectCollectorFactoryFunction as EffectCollectorFactoryFunction, index_Signal as Signal, type index_SignalCollectorFactoryFunction as SignalCollectorFactoryFunction, index_collector as collector, index_composed as composed, index_computed as computed, index_effect as effect, index_signal as signal };
+  export { type index_BatchCollectorFactory as BatchCollectorFactory, index_Collector as Collector, index_Composed as Composed, type index_ComposedBatcherFactory as ComposedBatcherFactory, type index_ComposedCollectorFactory as ComposedCollectorFactory, index_Computed as Computed, type index_ComputedCollectorFactory as ComputedCollectorFactory, type index_EffectCollectorFactory as EffectCollectorFactory, type Ignore$1 as Ignore, type index_IgnoreCollectorFactory as IgnoreCollectorFactory, index_Signal as Signal, type index_SignalBatcherFactory as SignalBatcherFactory, type index_SignalCollectorFactory as SignalCollectorFactory, batch$1 as batch, index_collector as collector, composed$1 as composed, computed$1 as computed, index_effect as effect, ignore$1 as ignore, index_signal as signal };
 }
 
 type Arguments<T> = T extends (...args: infer A) => any ? A : never;
 
+interface Batch {
+    (callback: Callback): void;
+    (callback: Callback, collector: Collector$1<Callback>): void;
+    (callback: Callback, collector?: Collector$1<Callback>): void;
+}
+declare const batch: Factory<Batch>;
+
+type ComposedFactory = <T>(read: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal$1<T>;
+declare const composed: Factory<ComposedFactory>;
+
+type ComputedFactory = <T>(read: () => T, equals?: Equals<T>) => ReadonlySignal<T>;
+declare const computed: Factory<ComputedFactory>;
+
+interface Ignore {
+    <Value>(value: ReadonlySignal<Value>): Value;
+    <Value>(callback: () => Value): Value;
+    <Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
+}
+declare const ignore: Factory<Ignore>;
+
 interface Config {
-    collector?: Maybe<CollectorFactoryFunction>;
-    signal?: Maybe<SignalFactoryFunction>;
-    effect?: Maybe<EffectFactoryFunction>;
-    computed?: Maybe<ComputedFactoryFunction>;
-    composed?: Maybe<ComposedFactoryFunction>;
+    collector?: Maybe<CollectorFactory>;
+    signal?: Maybe<SignalFactory>;
+    computed?: Maybe<ComputedFactory>;
+    composed?: Maybe<ComposedFactory>;
+    effect?: Maybe<Effect>;
+    batch?: Maybe<Batch>;
+    ignore?: Maybe<Ignore$1>;
 }
 declare function config(config?: Config): void;
 
-export { type Arguments, type Callback, type Collector$1 as Collector, type CollectorFactoryFunction, type Comparable, type ComposedFactoryFunction, type ComputedFactoryFunction, type Config, type Effect, type EffectCallback, type EffectCleanup, type EffectFactoryFunction, type Equals, type Maybe, type Reader, type ReadonlySignal, type Signal$1 as Signal, type SignalFactoryFunction, type Subscription, type Writer, collector$1 as collector, composed$1 as composed, computed$1 as computed, config, effect$1 as effect, index as internal, signal$1 as signal };
+export { type Arguments, type Batch, type Callback, type Collector$1 as Collector, type CollectorFactory, type Comparable, type ComposedFactory, type ComputedFactory, type Config, type Effect, type EffectCallback, type EffectCleanup, type Equals, type Factory, type Function, type Ignore, type Maybe, type Reader, type ReadonlySignal, type Signal$1 as Signal, type SignalFactory, type Subscription, type Writer, batch, collector$1 as collector, composed, computed, config, effect$1 as effect, factory, ignore, index as internal, signal$1 as signal };

package/dist/index.d.ts

@@ -1,18 +1,42 @@
+type Function = (...args: any[]) => any;
+
 type Maybe<T> = T | null | undefined;
 
-type Factory<Fn extends FactoryFunction> = Fn & {
+type Factory<Fn extends Function> = Fn & {
     factory(factory: Maybe<Fn>): void;
     default(factory: Maybe<Fn>): void;
     configured(): boolean;
 };
-type FactoryFunction = (...args: any[]) => any;
+declare function factory<Fn extends Function>(name: string): Factory<Fn>;
 
 interface Collector$1<T> {
     add(value: T): void;
+    collecting(): boolean;
     collect(callback: () => void): Readonly<Set<T>>;
+    ignore(callback: () => void): void;
+}
+type CollectorFactory = <T>() => Collector$1<T>;
+declare const collector$1: Factory<CollectorFactory>;
+
+type Callback = () => void;
+
+declare function batch$1(callback: Callback): void;
+declare function batch$1(callback: Callback, collector: Collector$1<Callback>): void;
+declare function batch$1(callback: Callback, collector?: Collector$1<Callback>): void;
+declare namespace batch$1 {
+    var collector: Factory<BatchCollectorFactory>;
+}
+type BatchCollectorFactory = () => Collector$1<Callback>;
+
+declare function collector<T>(): Collector$1<T>;
+declare class Collector<T> implements Collector$1<T> {
+    #private;
+    constructor(values: Set<T> | null);
+    collecting(): boolean;
+    add(value: T): void;
+    collect(callback: () => void): Set<T>;
+    ignore(callback: () => void): void;
 }
-type CollectorFactoryFunction = <T>() => Collector$1<T>;
-declare const collector$1: Factory<CollectorFactoryFunction>;
 
 type Equals<T> = (value: T, other: T) => boolean;
 interface Comparable<T> {
@@ -23,8 +47,6 @@ interface Reader<T> {
     read(): T;
 }
 
-type Callback = () => void;
-
 interface Subscription {
     subscribe(callback: Callback): Callback;
     unsubscribe(callback: Callback): void;
@@ -38,79 +60,70 @@ interface Signal$1<T> extends Reader<T>, Writer<T>, Comparable<T>, Subscription
 }
 interface ReadonlySignal<T> extends Reader<T>, Comparable<T>, Subscription {
 }
-type SignalFactoryFunction = <T>(value: T, equals?: Equals<T>) => Signal$1<T>;
-declare const signal$1: Factory<SignalFactoryFunction>;
-
-type ComposedFactoryFunction = <T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal$1<T>;
-declare const composed$1: Factory<ComposedFactoryFunction>;
-
-type ComputedFactoryFunction = <T>(compute: () => T, equals?: Equals<T>) => ReadonlySignal<T>;
-declare const computed$1: Factory<ComputedFactoryFunction>;
-
-type Effect = () => void;
-type EffectCallback = (init: boolean) => EffectCleanup | void;
-type EffectCleanup = (destroy: boolean) => void;
-type EffectFactoryFunction = (callback: EffectCallback) => Effect;
-declare const effect$1: Factory<EffectFactoryFunction>;
-
-declare function collector<T>(): Collector$1<T>;
-declare class Collector<T> implements Collector$1<T> {
-    private values;
-    constructor(values: Set<T> | null);
-    add(value: T): void;
-    collect(callback: () => void): Set<T>;
-}
+type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal$1<T>;
+declare const signal$1: Factory<SignalFactory>;
 
-declare function computed<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
-declare namespace computed {
-    var collector: Factory<ComputedCollectorFactoryFunction>;
+declare function computed$1<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
+declare namespace computed$1 {
+    var collector: Factory<ComputedCollectorFactory>;
 }
-type ComputedCollectorFactoryFunction = () => Collector$1<ReadonlySignal<unknown>>;
+type ComputedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
 declare class Computed<T> implements ReadonlySignal<T> {
-    private empty;
-    private value;
-    private values;
-    private dependencies;
-    private readonly compute;
-    private readonly equalsFn;
-    private readonly listeners;
-    private readonly collector;
-    constructor(empty: boolean, value: T | undefined, values: unknown[], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, equals: Maybe<Equals<T>>);
-    private dirty;
+    #private;
+    constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, equals: Maybe<Equals<T>>);
     read(): T;
     equals(other: T): boolean;
     subscribe(callback: Callback): Callback;
     unsubscribe(callback: Callback): void;
 }
 
-declare function composed<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): Composed<T>;
-declare namespace composed {
-    var collector: Factory<ComposedCollectorFactoryFunction>;
+type ComposedBatcherFactory = () => Collector$1<Callback>;
+type ComposedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
+declare function composed$1<T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): Composed<T>;
+declare namespace composed$1 {
+    var batcher: Factory<ComposedBatcherFactory>;
+    var collector: Factory<ComposedCollectorFactory>;
 }
-type ComposedCollectorFactoryFunction = () => Collector$1<ReadonlySignal<unknown>>;
 declare class Composed<T> extends Computed<T> implements Signal$1<T> {
-    private readonly writeFn;
-    constructor(empty: boolean, value: T | undefined, values: unknown[], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, write: (value: T) => void, equals: Maybe<Equals<T>>);
+    #private;
+    constructor(empty: boolean, value: T | undefined, values: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, write: (value: T) => void, equals: Maybe<Equals<T>>);
     write(value: T): void;
 }
 
-type EffectCollectorFactoryFunction = () => Collector$1<ReadonlySignal<unknown>>;
+type Effect = (callback: EffectCallback) => Callback;
+type EffectCallback = (init: boolean) => EffectCleanup | void;
+type EffectCleanup = (destroy: boolean) => void;
+declare const effect$1: Factory<Effect>;
+
 declare function effect(cb: EffectCallback): Callback;
 declare namespace effect {
-    var collector: Factory<EffectCollectorFactoryFunction>;
+    var collector: Factory<EffectCollectorFactory>;
 }
+type EffectCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
 
+interface Ignore$1 {
+    <Value>(value: ReadonlySignal<Value>): Value;
+    <Value>(callback: () => Value): Value;
+    <Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
+}
+declare function ignore$1<Value>(value: ReadonlySignal<Value>): Value;
+declare function ignore$1<Value>(callback: () => Value): Value;
+declare function ignore$1<Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
+declare namespace ignore$1 {
+    var collector: Factory<IgnoreCollectorFactory>;
+}
+type IgnoreCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
+
+type SignalBatcherFactory = () => Collector$1<Callback>;
+type SignalCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
 declare function signal<T>(value: T, equals?: Equals<T>): Signal$1<T>;
 declare namespace signal {
-    var collector: Factory<SignalCollectorFactoryFunction>;
+    var batcher: Factory<SignalBatcherFactory>;
+    var collector: Factory<SignalCollectorFactory>;
 }
-type SignalCollectorFactoryFunction = () => Maybe<Collector$1<ReadonlySignal<unknown>>>;
 declare class Signal<T> implements Signal$1<T> {
-    private value;
-    private equalsFn;
-    private listeners;
-    private collector;
-    constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, collector: Maybe<Collector$1<ReadonlySignal<unknown>>>);
+    #private;
+    constructor(value: T, equals: Maybe<Equals<T>>, listeners: Set<Callback>, batcher: Collector$1<Callback>, collector: Collector$1<ReadonlySignal<unknown>>);
     read(): T;
     write(value: T): void;
     equals(other: T): boolean;
@@ -118,36 +131,60 @@ declare class Signal<T> implements Signal$1<T> {
     unsubscribe(callback: Callback): void;
 }
 
+type index_BatchCollectorFactory = BatchCollectorFactory;
 type index_Collector<T> = Collector<T>;
 declare const index_Collector: typeof Collector;
 type index_Composed<T> = Composed<T>;
 declare const index_Composed: typeof Composed;
-type index_ComposedCollectorFactoryFunction = ComposedCollectorFactoryFunction;
+type index_ComposedBatcherFactory = ComposedBatcherFactory;
+type index_ComposedCollectorFactory = ComposedCollectorFactory;
 type index_Computed<T> = Computed<T>;
 declare const index_Computed: typeof Computed;
-type index_ComputedCollectorFactoryFunction = ComputedCollectorFactoryFunction;
-type index_EffectCollectorFactoryFunction = EffectCollectorFactoryFunction;
+type index_ComputedCollectorFactory = ComputedCollectorFactory;
+type index_EffectCollectorFactory = EffectCollectorFactory;
+type index_IgnoreCollectorFactory = IgnoreCollectorFactory;
 type index_Signal<T> = Signal<T>;
 declare const index_Signal: typeof Signal;
-type index_SignalCollectorFactoryFunction = SignalCollectorFactoryFunction;
+type index_SignalBatcherFactory = SignalBatcherFactory;
+type index_SignalCollectorFactory = SignalCollectorFactory;
 declare const index_collector: typeof collector;
-declare const index_composed: typeof composed;
-declare const index_computed: typeof computed;
 declare const index_effect: typeof effect;
 declare const index_signal: typeof signal;
 declare namespace index {
-  export { index_Collector as Collector, index_Composed as Composed, type index_ComposedCollectorFactoryFunction as ComposedCollectorFactoryFunction, index_Computed as Computed, type index_ComputedCollectorFactoryFunction as ComputedCollectorFactoryFunction, type index_EffectCollectorFactoryFunction as EffectCollectorFactoryFunction, index_Signal as Signal, type index_SignalCollectorFactoryFunction as SignalCollectorFactoryFunction, index_collector as collector, index_composed as composed, index_computed as computed, index_effect as effect, index_signal as signal };
+  export { type index_BatchCollectorFactory as BatchCollectorFactory, index_Collector as Collector, index_Composed as Composed, type index_ComposedBatcherFactory as ComposedBatcherFactory, type index_ComposedCollectorFactory as ComposedCollectorFactory, index_Computed as Computed, type index_ComputedCollectorFactory as ComputedCollectorFactory, type index_EffectCollectorFactory as EffectCollectorFactory, type Ignore$1 as Ignore, type index_IgnoreCollectorFactory as IgnoreCollectorFactory, index_Signal as Signal, type index_SignalBatcherFactory as SignalBatcherFactory, type index_SignalCollectorFactory as SignalCollectorFactory, batch$1 as batch, index_collector as collector, composed$1 as composed, computed$1 as computed, index_effect as effect, ignore$1 as ignore, index_signal as signal };
 }
 
 type Arguments<T> = T extends (...args: infer A) => any ? A : never;
 
+interface Batch {
+    (callback: Callback): void;
+    (callback: Callback, collector: Collector$1<Callback>): void;
+    (callback: Callback, collector?: Collector$1<Callback>): void;
+}
+declare const batch: Factory<Batch>;
+
+type ComposedFactory = <T>(read: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal$1<T>;
+declare const composed: Factory<ComposedFactory>;
+
+type ComputedFactory = <T>(read: () => T, equals?: Equals<T>) => ReadonlySignal<T>;
+declare const computed: Factory<ComputedFactory>;
+
+interface Ignore {
+    <Value>(value: ReadonlySignal<Value>): Value;
+    <Value>(callback: () => Value): Value;
+    <Value, Args extends any[]>(callback: (...args: Args) => Value, ...args: Args): Value;
+}
+declare const ignore: Factory<Ignore>;
+
 interface Config {
-    collector?: Maybe<CollectorFactoryFunction>;
-    signal?: Maybe<SignalFactoryFunction>;
-    effect?: Maybe<EffectFactoryFunction>;
-    computed?: Maybe<ComputedFactoryFunction>;
-    composed?: Maybe<ComposedFactoryFunction>;
+    collector?: Maybe<CollectorFactory>;
+    signal?: Maybe<SignalFactory>;
+    computed?: Maybe<ComputedFactory>;
+    composed?: Maybe<ComposedFactory>;
+    effect?: Maybe<Effect>;
+    batch?: Maybe<Batch>;
+    ignore?: Maybe<Ignore$1>;
 }
 declare function config(config?: Config): void;
 
-export { type Arguments, type Callback, type Collector$1 as Collector, type CollectorFactoryFunction, type Comparable, type ComposedFactoryFunction, type ComputedFactoryFunction, type Config, type Effect, type EffectCallback, type EffectCleanup, type EffectFactoryFunction, type Equals, type Maybe, type Reader, type ReadonlySignal, type Signal$1 as Signal, type SignalFactoryFunction, type Subscription, type Writer, collector$1 as collector, composed$1 as composed, computed$1 as computed, config, effect$1 as effect, index as internal, signal$1 as signal };
+export { type Arguments, type Batch, type Callback, type Collector$1 as Collector, type CollectorFactory, type Comparable, type ComposedFactory, type ComputedFactory, type Config, type Effect, type EffectCallback, type EffectCleanup, type Equals, type Factory, type Function, type Ignore, type Maybe, type Reader, type ReadonlySignal, type Signal$1 as Signal, type SignalFactory, type Subscription, type Writer, batch, collector$1 as collector, composed, computed, config, effect$1 as effect, factory, ignore, index as internal, signal$1 as signal };

package/dist/index.js

@@ -20,11 +20,14 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  batch: () => batch,
   collector: () => collector,
   composed: () => composed,
   computed: () => computed,
   config: () => config,
   effect: () => effect,
+  factory: () => factory,
+  ignore: () => ignore,
   internal: () => internal_exports,
   signal: () => signal
 });
@@ -39,16 +42,15 @@ function factory(name) {
     if (__default__) return __default__(...args);
     throw new Error(`${name}.factory() not configured!`);
   }
-  object.default = (factory2) => {
-    __default__ = factory2;
-  };
-  object.factory = (factory2) => {
-    __factory__ = factory2;
-  };
+  object.default = (factory2) => __default__ = factory2;
+  object.factory = (factory2) => __factory__ = factory2;
   object.configured = () => __default__ !== null || __factory__ !== null;
   return object;
 }
 
+// src/core/batch.ts
+var batch = factory("batch");
+
 // src/core/collector.ts
 var collector = factory("collector");
 
@@ -61,6 +63,9 @@ var computed = factory("computed");
 // src/core/effect.ts
 var effect = factory("effect");
 
+// src/core/ignore.ts
+var ignore = factory("ignore");
+
 // src/core/signal.ts
 var signal = factory("signal");
 
@@ -71,34 +76,52 @@ __export(internal_exports, {
   Composed: () => Composed,
   Computed: () => Computed,
   Signal: () => Signal,
+  batch: () => batch2,
   collector: () => collector2,
   composed: () => composed2,
   computed: () => computed2,
   effect: () => effect2,
+  ignore: () => ignore2,
   signal: () => signal2
 });
 
+// src/internal/batch.ts
+function batch2(callback, collector3 = batch2.collector()) {
+  if (collector3.collecting()) return callback();
+  collector3.collect(callback).forEach((listener) => listener());
+}
+batch2.collector = factory("batch.collector");
+
 // src/internal/collector.ts
 function collector2() {
   return new Collector(null);
 }
 var Collector = class {
-  values;
+  #values;
   constructor(values) {
-    this.values = values;
+    this.#values = values;
+  }
+  collecting() {
+    return this.#values !== null;
   }
   add(value) {
-    if (!this.values) return;
-    this.values.add(value);
+    if (!this.collecting() || !this.#values) return;
+    this.#values.add(value);
   }
   collect(callback) {
-    const current = this.values;
-    this.values = /* @__PURE__ */ new Set();
+    const current = this.#values;
+    this.#values = /* @__PURE__ */ new Set();
     callback();
-    const collected = this.values;
-    this.values = current;
+    const collected = this.#values;
+    this.#values = current;
     return collected;
   }
+  ignore(callback) {
+    const current = this.#values;
+    this.#values = null;
+    callback();
+    this.#values = current;
+  }
 };
 
 // src/internal/computed.ts
@@ -116,54 +139,54 @@ function computed2(compute, equals) {
 }
 computed2.collector = factory("computed.collector");
 var Computed = class {
-  empty;
-  value;
-  values;
-  dependencies;
-  compute;
-  equalsFn;
-  listeners;
-  collector;
+  #empty;
+  #value;
+  #values;
+  #dependencies;
+  #compute;
+  #equals;
+  #listeners;
+  #collector;
   constructor(empty, value, values, dependencies, listeners, collector3, compute, equals) {
-    this.empty = empty;
-    this.value = value;
-    this.values = values;
-    this.dependencies = dependencies;
-    this.listeners = listeners;
-    this.collector = collector3;
-    this.compute = compute;
-    this.equalsFn = equals;
+    this.#empty = empty;
+    this.#value = value;
+    this.#values = values;
+    this.#dependencies = dependencies;
+    this.#listeners = listeners;
+    this.#collector = collector3;
+    this.#compute = compute;
+    this.#equals = equals;
   }
-  dirty() {
-    if (this.empty) return true;
-    return Array.from(this.dependencies).some((dep, index) => !dep.equals(this.values[index]));
+  #dirty() {
+    if (this.#empty) return true;
+    return this.#values.some(([dep, value]) => !dep.equals(value));
   }
   read() {
-    this.collector.add(this);
-    if (!this.dirty()) return this.value;
-    const current = this.dependencies;
-    const next = this.collector.collect(() => this.value = this.compute());
-    this.dependencies = next;
-    this.values = Array.from(next).map((dep) => dep.read());
-    this.empty = false;
-    if (!current.size && !next.size) return this.value;
-    if (!this.listeners.size) return this.value;
-    current.forEach((dep) => !next.has(dep) && this.listeners.forEach((listener) => dep.unsubscribe(listener)));
-    next.forEach((dep) => !current.has(dep) && this.listeners.forEach((listener) => dep.subscribe(listener)));
-    return this.value;
+    this.#collector.add(this);
+    if (!this.#dirty()) return this.#value;
+    const current = this.#dependencies;
+    const next = this.#collector.collect(() => this.#value = this.#compute());
+    this.#dependencies = next;
+    this.#values = Array.from(next).map((dep) => [dep, dep.read()]);
+    this.#empty = false;
+    if (!current.size && !next.size) return this.#value;
+    if (!this.#listeners.size) return this.#value;
+    current.forEach((dep) => !next.has(dep) && this.#listeners.forEach((listener) => dep.unsubscribe(listener)));
+    next.forEach((dep) => !current.has(dep) && this.#listeners.forEach((listener) => dep.subscribe(listener)));
+    return this.#value;
   }
   equals(other) {
-    if (this.equalsFn) return this.equalsFn(this.read(), other);
+    if (this.#equals) return this.#equals(this.read(), other);
     return this.read() === other;
   }
   subscribe(callback) {
-    this.listeners.add(callback);
-    this.dependencies.forEach((dep) => dep.subscribe(callback));
-    return () => this.unsubscribe(callback);
+    this.#listeners.add(callback);
+    this.#dependencies.forEach((dep) => dep.subscribe(callback));
+    return this.unsubscribe.bind(this, callback);
   }
   unsubscribe(callback) {
-    this.listeners.delete(callback);
-    this.dependencies.forEach((dep) => dep.unsubscribe(callback));
+    this.#listeners.delete(callback);
+    this.#dependencies.forEach((dep) => dep.unsubscribe(callback));
   }
 };
 
@@ -175,22 +198,26 @@ function composed2(compute, write, equals) {
     [],
     /* @__PURE__ */ new Set(),
     /* @__PURE__ */ new Set(),
+    composed2.batcher(),
     composed2.collector(),
     compute,
     write,
     equals
   );
 }
+composed2.batcher = factory("composed.batcher");
 composed2.collector = factory("composed.collector");
 var Composed = class extends Computed {
-  writeFn;
-  constructor(empty, value, values, dependencies, listeners, collector3, compute, write, equals) {
+  #batcher;
+  #write;
+  constructor(empty, value, values, dependencies, listeners, batcher, collector3, compute, write, equals) {
     super(empty, value, values, dependencies, listeners, collector3, compute, equals);
-    this.writeFn = write;
+    this.#batcher = batcher;
+    this.#write = write;
   }
   write(value) {
     if (this.equals(value)) return;
-    this.writeFn(value);
+    batch(() => this.#write(value), this.#batcher);
   }
 };
 
@@ -215,73 +242,103 @@ function effect2(cb) {
 }
 effect2.collector = factory("effect.collector");
 
+// src/internal/ignore.ts
+function ignore2(callback, ...args) {
+  let value;
+  ignore2.collector().ignore(() => value = typeof callback === "function" ? callback(...args) : callback.read());
+  return value;
+}
+ignore2.collector = factory("signal.collector");
+
 // src/internal/signal.ts
 function signal2(value, equals) {
-  return new Signal(value, equals, /* @__PURE__ */ new Set(), signal2.collector());
+  return new Signal(value, equals, /* @__PURE__ */ new Set(), signal2.batcher(), signal2.collector());
 }
+signal2.batcher = factory("signal.batcher");
 signal2.collector = factory("signal.collector");
 var Signal = class {
-  value;
-  equalsFn;
-  listeners;
-  collector;
-  constructor(value, equals, listeners, collector3) {
-    this.value = value;
-    this.equalsFn = equals;
-    this.listeners = listeners;
-    this.collector = collector3;
+  #value;
+  #equals;
+  #listeners;
+  #batcher;
+  #collector;
+  constructor(value, equals, listeners, batcher, collector3) {
+    this.#value = value;
+    this.#equals = equals;
+    this.#listeners = listeners;
+    this.#batcher = batcher;
+    this.#collector = collector3;
   }
   read() {
-    if (this.collector) this.collector.add(this);
-    return this.value;
+    this.#collector.add(this);
+    return this.#value;
   }
   write(value) {
     if (this.equals(value)) return;
-    this.value = value;
-    this.listeners.forEach((listener) => listener());
+    this.#value = value;
+    if (this.#batcher.collecting()) this.#listeners.forEach((listener) => this.#batcher.add(listener));
+    else this.#listeners.forEach((listener) => listener());
   }
   equals(other) {
-    if (this.equalsFn) return this.equalsFn(this.value, other);
-    return this.value === other;
+    if (this.#equals) return this.#equals(this.#value, other);
+    return this.#value === other;
   }
   subscribe(callback) {
-    this.listeners.add(callback);
-    return () => this.unsubscribe(callback);
+    this.#listeners.add(callback);
+    return this.unsubscribe.bind(this, callback);
   }
   unsubscribe(callback) {
-    this.listeners.delete(callback);
+    this.#listeners.delete(callback);
   }
 };
 
-// src/index.ts
+// src/core/config.ts
 function config(config2 = {}) {
   collector.factory(config2.collector);
   signal.factory(config2.signal);
-  effect.factory(config2.effect);
   computed.factory(config2.computed);
   composed.factory(config2.composed);
+  effect.factory(config2.effect);
+  batch.factory(config2.batch);
+  ignore.factory(config2.ignore);
+}
+
+// src/index.ts
+var __collector__ = null;
+function shared_collector() {
+  if (!__collector__) __collector__ = collector();
+  return __collector__;
 }
-var __shared__ = null;
-function shared() {
-  if (!__shared__) __shared__ = collector();
-  return __shared__;
+signal2.collector.default(shared_collector);
+computed2.collector.default(shared_collector);
+composed2.collector.default(shared_collector);
+effect2.collector.default(shared_collector);
+ignore2.collector.default(shared_collector);
+var __batcher__ = null;
+function shared_batcher() {
+  if (!__batcher__) __batcher__ = collector();
+  return __batcher__;
 }
-signal2.collector.default(shared);
-effect2.collector.default(shared);
-computed2.collector.default(shared);
-composed2.collector.default(shared);
-signal.default(signal2);
-effect.default(effect2);
+signal2.batcher.default(shared_batcher);
+composed2.batcher.default(shared_batcher);
+batch2.collector.default(shared_batcher);
 collector.default(collector2);
+signal.default(signal2);
 computed.default(computed2);
 composed.default(composed2);
+effect.default(effect2);
+batch.default(batch2);
+ignore.default(ignore2);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  batch,
   collector,
   composed,
   computed,
   config,
   effect,
+  factory,
+  ignore,
   internal,
   signal
 });

package/dist/index.mjs

@@ -13,16 +13,15 @@ function factory(name) {
     if (__default__) return __default__(...args);
     throw new Error(`${name}.factory() not configured!`);
   }
-  object.default = (factory2) => {
-    __default__ = factory2;
-  };
-  object.factory = (factory2) => {
-    __factory__ = factory2;
-  };
+  object.default = (factory2) => __default__ = factory2;
+  object.factory = (factory2) => __factory__ = factory2;
   object.configured = () => __default__ !== null || __factory__ !== null;
   return object;
 }
 
+// src/core/batch.ts
+var batch = factory("batch");
+
 // src/core/collector.ts
 var collector = factory("collector");
 
@@ -35,6 +34,9 @@ var computed = factory("computed");
 // src/core/effect.ts
 var effect = factory("effect");
 
+// src/core/ignore.ts
+var ignore = factory("ignore");
+
 // src/core/signal.ts
 var signal = factory("signal");
 
@@ -45,34 +47,52 @@ __export(internal_exports, {
   Composed: () => Composed,
   Computed: () => Computed,
   Signal: () => Signal,
+  batch: () => batch2,
   collector: () => collector2,
   composed: () => composed2,
   computed: () => computed2,
   effect: () => effect2,
+  ignore: () => ignore2,
   signal: () => signal2
 });
 
+// src/internal/batch.ts
+function batch2(callback, collector3 = batch2.collector()) {
+  if (collector3.collecting()) return callback();
+  collector3.collect(callback).forEach((listener) => listener());
+}
+batch2.collector = factory("batch.collector");
+
 // src/internal/collector.ts
 function collector2() {
   return new Collector(null);
 }
 var Collector = class {
-  values;
+  #values;
   constructor(values) {
-    this.values = values;
+    this.#values = values;
+  }
+  collecting() {
+    return this.#values !== null;
   }
   add(value) {
-    if (!this.values) return;
-    this.values.add(value);
+    if (!this.collecting() || !this.#values) return;
+    this.#values.add(value);
   }
   collect(callback) {
-    const current = this.values;
-    this.values = /* @__PURE__ */ new Set();
+    const current = this.#values;
+    this.#values = /* @__PURE__ */ new Set();
     callback();
-    const collected = this.values;
-    this.values = current;
+    const collected = this.#values;
+    this.#values = current;
     return collected;
   }
+  ignore(callback) {
+    const current = this.#values;
+    this.#values = null;
+    callback();
+    this.#values = current;
+  }
 };
 
 // src/internal/computed.ts
@@ -90,54 +110,54 @@ function computed2(compute, equals) {
 }
 computed2.collector = factory("computed.collector");
 var Computed = class {
-  empty;
-  value;
-  values;
-  dependencies;
-  compute;
-  equalsFn;
-  listeners;
-  collector;
+  #empty;
+  #value;
+  #values;
+  #dependencies;
+  #compute;
+  #equals;
+  #listeners;
+  #collector;
   constructor(empty, value, values, dependencies, listeners, collector3, compute, equals) {
-    this.empty = empty;
-    this.value = value;
-    this.values = values;
-    this.dependencies = dependencies;
-    this.listeners = listeners;
-    this.collector = collector3;
-    this.compute = compute;
-    this.equalsFn = equals;
+    this.#empty = empty;
+    this.#value = value;
+    this.#values = values;
+    this.#dependencies = dependencies;
+    this.#listeners = listeners;
+    this.#collector = collector3;
+    this.#compute = compute;
+    this.#equals = equals;
   }
-  dirty() {
-    if (this.empty) return true;
-    return Array.from(this.dependencies).some((dep, index) => !dep.equals(this.values[index]));
+  #dirty() {
+    if (this.#empty) return true;
+    return this.#values.some(([dep, value]) => !dep.equals(value));
   }
   read() {
-    this.collector.add(this);
-    if (!this.dirty()) return this.value;
-    const current = this.dependencies;
-    const next = this.collector.collect(() => this.value = this.compute());
-    this.dependencies = next;
-    this.values = Array.from(next).map((dep) => dep.read());
-    this.empty = false;
-    if (!current.size && !next.size) return this.value;
-    if (!this.listeners.size) return this.value;
-    current.forEach((dep) => !next.has(dep) && this.listeners.forEach((listener) => dep.unsubscribe(listener)));
-    next.forEach((dep) => !current.has(dep) && this.listeners.forEach((listener) => dep.subscribe(listener)));
-    return this.value;
+    this.#collector.add(this);
+    if (!this.#dirty()) return this.#value;
+    const current = this.#dependencies;
+    const next = this.#collector.collect(() => this.#value = this.#compute());
+    this.#dependencies = next;
+    this.#values = Array.from(next).map((dep) => [dep, dep.read()]);
+    this.#empty = false;
+    if (!current.size && !next.size) return this.#value;
+    if (!this.#listeners.size) return this.#value;
+    current.forEach((dep) => !next.has(dep) && this.#listeners.forEach((listener) => dep.unsubscribe(listener)));
+    next.forEach((dep) => !current.has(dep) && this.#listeners.forEach((listener) => dep.subscribe(listener)));
+    return this.#value;
   }
   equals(other) {
-    if (this.equalsFn) return this.equalsFn(this.read(), other);
+    if (this.#equals) return this.#equals(this.read(), other);
     return this.read() === other;
   }
   subscribe(callback) {
-    this.listeners.add(callback);
-    this.dependencies.forEach((dep) => dep.subscribe(callback));
-    return () => this.unsubscribe(callback);
+    this.#listeners.add(callback);
+    this.#dependencies.forEach((dep) => dep.subscribe(callback));
+    return this.unsubscribe.bind(this, callback);
   }
   unsubscribe(callback) {
-    this.listeners.delete(callback);
-    this.dependencies.forEach((dep) => dep.unsubscribe(callback));
+    this.#listeners.delete(callback);
+    this.#dependencies.forEach((dep) => dep.unsubscribe(callback));
   }
 };
 
@@ -149,22 +169,26 @@ function composed2(compute, write, equals) {
     [],
     /* @__PURE__ */ new Set(),
     /* @__PURE__ */ new Set(),
+    composed2.batcher(),
     composed2.collector(),
     compute,
     write,
     equals
   );
 }
+composed2.batcher = factory("composed.batcher");
 composed2.collector = factory("composed.collector");
 var Composed = class extends Computed {
-  writeFn;
-  constructor(empty, value, values, dependencies, listeners, collector3, compute, write, equals) {
+  #batcher;
+  #write;
+  constructor(empty, value, values, dependencies, listeners, batcher, collector3, compute, write, equals) {
     super(empty, value, values, dependencies, listeners, collector3, compute, equals);
-    this.writeFn = write;
+    this.#batcher = batcher;
+    this.#write = write;
   }
   write(value) {
     if (this.equals(value)) return;
-    this.writeFn(value);
+    batch(() => this.#write(value), this.#batcher);
   }
 };
 
@@ -189,72 +213,102 @@ function effect2(cb) {
 }
 effect2.collector = factory("effect.collector");
 
+// src/internal/ignore.ts
+function ignore2(callback, ...args) {
+  let value;
+  ignore2.collector().ignore(() => value = typeof callback === "function" ? callback(...args) : callback.read());
+  return value;
+}
+ignore2.collector = factory("signal.collector");
+
 // src/internal/signal.ts
 function signal2(value, equals) {
-  return new Signal(value, equals, /* @__PURE__ */ new Set(), signal2.collector());
+  return new Signal(value, equals, /* @__PURE__ */ new Set(), signal2.batcher(), signal2.collector());
 }
+signal2.batcher = factory("signal.batcher");
 signal2.collector = factory("signal.collector");
 var Signal = class {
-  value;
-  equalsFn;
-  listeners;
-  collector;
-  constructor(value, equals, listeners, collector3) {
-    this.value = value;
-    this.equalsFn = equals;
-    this.listeners = listeners;
-    this.collector = collector3;
+  #value;
+  #equals;
+  #listeners;
+  #batcher;
+  #collector;
+  constructor(value, equals, listeners, batcher, collector3) {
+    this.#value = value;
+    this.#equals = equals;
+    this.#listeners = listeners;
+    this.#batcher = batcher;
+    this.#collector = collector3;
   }
   read() {
-    if (this.collector) this.collector.add(this);
-    return this.value;
+    this.#collector.add(this);
+    return this.#value;
   }
   write(value) {
     if (this.equals(value)) return;
-    this.value = value;
-    this.listeners.forEach((listener) => listener());
+    this.#value = value;
+    if (this.#batcher.collecting()) this.#listeners.forEach((listener) => this.#batcher.add(listener));
+    else this.#listeners.forEach((listener) => listener());
   }
   equals(other) {
-    if (this.equalsFn) return this.equalsFn(this.value, other);
-    return this.value === other;
+    if (this.#equals) return this.#equals(this.#value, other);
+    return this.#value === other;
   }
   subscribe(callback) {
-    this.listeners.add(callback);
-    return () => this.unsubscribe(callback);
+    this.#listeners.add(callback);
+    return this.unsubscribe.bind(this, callback);
   }
   unsubscribe(callback) {
-    this.listeners.delete(callback);
+    this.#listeners.delete(callback);
   }
 };
 
-// src/index.ts
+// src/core/config.ts
 function config(config2 = {}) {
   collector.factory(config2.collector);
   signal.factory(config2.signal);
-  effect.factory(config2.effect);
   computed.factory(config2.computed);
   composed.factory(config2.composed);
+  effect.factory(config2.effect);
+  batch.factory(config2.batch);
+  ignore.factory(config2.ignore);
+}
+
+// src/index.ts
+var __collector__ = null;
+function shared_collector() {
+  if (!__collector__) __collector__ = collector();
+  return __collector__;
 }
-var __shared__ = null;
-function shared() {
-  if (!__shared__) __shared__ = collector();
-  return __shared__;
+signal2.collector.default(shared_collector);
+computed2.collector.default(shared_collector);
+composed2.collector.default(shared_collector);
+effect2.collector.default(shared_collector);
+ignore2.collector.default(shared_collector);
+var __batcher__ = null;
+function shared_batcher() {
+  if (!__batcher__) __batcher__ = collector();
+  return __batcher__;
 }
-signal2.collector.default(shared);
-effect2.collector.default(shared);
-computed2.collector.default(shared);
-composed2.collector.default(shared);
-signal.default(signal2);
-effect.default(effect2);
+signal2.batcher.default(shared_batcher);
+composed2.batcher.default(shared_batcher);
+batch2.collector.default(shared_batcher);
 collector.default(collector2);
+signal.default(signal2);
 computed.default(computed2);
 composed.default(composed2);
+effect.default(effect2);
+batch.default(batch2);
+ignore.default(ignore2);
 export {
+  batch,
   collector,
   composed,
   computed,
   config,
   effect,
+  factory,
+  ignore,
   internal_exports as internal,
   signal
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@valentin30/signal",
-  "version": "0.0.3",
-  "description": "",
+  "version": "0.0.5",
+  "description": "My take on signals - lightweight reactive primitives inspired by Preact Signals, written in TypeScript.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",