@valentin30/signal 0.0.2 → 0.0.4

package/dist/index.d.mts

@@ -1,203 +1,203 @@
-type Maybe<T> = T | null | undefined
+type Function = (...args: any[]) => any;
 
-type Factory<Fn extends FactoryFunction> = Fn & {
-    factory(factory: Maybe<Fn>): void
-    default(factory: Maybe<Fn>): void
-    configured(): boolean
-}
-type FactoryFunction = (...args: any[]) => any
+type Maybe<T> = T | null | undefined;
+
+type Factory<Fn extends Function> = Fn & {
+    factory(factory: Maybe<Fn>): void;
+    default(factory: Maybe<Fn>): void;
+    configured(): boolean;
+};
+declare function factory<Fn extends Function>(name: string): Factory<Fn>;
 
 interface Collector$1<T> {
-    add(value: T): void
-    collect(callback: () => void): Readonly<Set<T>>
+    add(value: T): void;
+    collecting(): boolean;
+    collect(callback: () => void): Readonly<Set<T>>;
+    ignore(callback: () => void): void;
 }
-interface CollectorFactoryFunction {
-    <T>(): Collector$1<T>
+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 values;
+    constructor(values: Set<T> | null);
+    collecting(): boolean;
+    add(value: T): void;
+    collect(callback: () => void): Set<T>;
+    ignore(callback: () => void): void;
 }
-type collector_type = typeof collector$1
-interface collector$1 extends collector_type {}
-declare const collector$1: Factory<CollectorFactoryFunction>
 
-type Equals<T> = (value: T, other: T) => boolean
+type Equals<T> = (value: T, other: T) => boolean;
 interface Comparable<T> {
-    equals(other: T): boolean
+    equals(other: T): boolean;
 }
 
 interface Reader<T> {
-    read(): T
+    read(): T;
 }
 
-type Callback = () => void
-
 interface Subscription {
-    subscribe(callback: Callback): Callback
-    unsubscribe(callback: Callback): void
+    subscribe(callback: Callback): Callback;
+    unsubscribe(callback: Callback): void;
 }
 
 interface Writer<T> {
-    write(value: T): void
+    write(value: T): void;
 }
 
-interface Signal$1<T> extends Reader<T>, Writer<T>, Comparable<T>, Subscription {}
-interface ReadonlySignal<T> extends Reader<T>, Comparable<T>, Subscription {}
-interface SignalFactoryFunction {
-    <T>(value: T, equals?: Equals<T>): Signal$1<T>
+interface Signal$1<T> extends Reader<T>, Writer<T>, Comparable<T>, Subscription {
 }
-declare const signal$1: Factory<SignalFactoryFunction>
-
-interface ComposedFactoryFunction {
-    <T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): Signal$1<T>
+interface ReadonlySignal<T> extends Reader<T>, Comparable<T>, Subscription {
 }
-declare const composed$1: Factory<ComposedFactoryFunction>
+type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal$1<T>;
+declare const signal$1: Factory<SignalFactory>;
 
-interface ComputedFactoryFunction {
-    <T>(compute: () => T, equals?: Equals<T>): ReadonlySignal<T>
+declare function computed$1<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
+declare namespace computed$1 {
+    var collector: Factory<ComputedCollectorFactory>;
 }
-declare const computed$1: Factory<ComputedFactoryFunction>
-
-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 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: [ReadonlySignal<unknown>, unknown][], dependencies: Set<ReadonlySignal<unknown>>, listeners: Set<Callback>, collector: Collector$1<ReadonlySignal<unknown>>, compute: () => T, equals: Maybe<Equals<T>>);
+    private dirty;
+    read(): T;
+    equals(other: T): boolean;
+    subscribe(callback: Callback): Callback;
+    unsubscribe(callback: Callback): void;
+}
+
+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>;
+}
+declare class Composed<T> extends Computed<T> implements Signal$1<T> {
+    private readonly batcher;
+    private readonly writeFn;
+    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;
 }
 
-declare function computed<T>(compute: () => T, equals?: Equals<T>): Computed<T>
-declare namespace computed {
-    var collector: Factory<ComputedCollectorFactoryFunction>
+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<EffectCollectorFactory>;
 }
-interface ComputedCollectorFactoryFunction {
-    (): Maybe<Collector$1<ReadonlySignal<unknown>>>
+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 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
-    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>
-}
-interface ComposedCollectorFactoryFunction {
-    (): Maybe<Collector$1<ReadonlySignal<unknown>>>
+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>;
 }
-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>>,
-    )
-    write(value: T): void
-}
-
-declare function signal<T>(value: T, equals?: Equals<T>): Signal$1<T>
+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>
-}
-interface SignalCollectorFactoryFunction {
-    (): Maybe<Collector$1<ReadonlySignal<unknown>>>
+    var batcher: Factory<SignalBatcherFactory>;
+    var collector: Factory<SignalCollectorFactory>;
 }
 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>>>)
-    read(): T
-    write(value: T): void
-    equals(other: T): boolean
-    subscribe(callback: Callback): Callback
-    unsubscribe(callback: Callback): void
-}
-
-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_Computed<T> = Computed<T>
-declare const index_Computed: typeof Computed
-type index_ComputedCollectorFactoryFunction = ComputedCollectorFactoryFunction
-type index_Signal<T> = Signal<T>
-declare const index_Signal: typeof Signal
-type index_SignalCollectorFactoryFunction = SignalCollectorFactoryFunction
-declare const index_collector: typeof collector
-declare const index_composed: typeof composed
-declare const index_computed: typeof computed
-declare const index_signal: typeof signal
+    private value;
+    private readonly equalsFn;
+    private readonly listeners;
+    private readonly batcher;
+    private readonly collector;
+    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;
+    subscribe(callback: Callback): Callback;
+    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_ComposedBatcherFactory = ComposedBatcherFactory;
+type index_ComposedCollectorFactory = ComposedCollectorFactory;
+type index_Computed<T> = Computed<T>;
+declare const index_Computed: typeof Computed;
+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_SignalBatcherFactory = SignalBatcherFactory;
+type index_SignalCollectorFactory = SignalCollectorFactory;
+declare const index_collector: typeof collector;
+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,
-        index_Signal as Signal,
-        type index_SignalCollectorFactoryFunction as SignalCollectorFactoryFunction,
-        index_collector as collector,
-        index_composed as composed,
-        index_computed as computed,
-        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>
-    computed?: Maybe<ComputedFactoryFunction>
-    composed?: Maybe<ComposedFactoryFunction>
-}
-declare function config(config?: Config): void
-
-export {
-    type Callback,
-    type Collector$1 as Collector,
-    type CollectorFactoryFunction,
-    type Comparable,
-    type ComposedFactoryFunction,
-    type ComputedFactoryFunction,
-    type Config,
-    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,
-    index as internal,
-    signal$1 as signal,
+    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 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,23 +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;
 }
-interface CollectorFactoryFunction {
-    <T>(): Collector$1<T>;
+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 collector_type = typeof collector$1;
-interface collector$1 extends collector_type {
+type BatchCollectorFactory = () => Collector$1<Callback>;
+
+declare function collector<T>(): Collector$1<T>;
+declare class Collector<T> implements Collector$1<T> {
+    private values;
+    constructor(values: Set<T> | null);
+    collecting(): boolean;
+    add(value: T): void;
+    collect(callback: () => void): Set<T>;
+    ignore(callback: () => void): void;
 }
-declare const collector$1: Factory<CollectorFactoryFunction>;
 
 type Equals<T> = (value: T, other: T) => boolean;
 interface Comparable<T> {
@@ -28,8 +47,6 @@ interface Reader<T> {
     read(): T;
 }
 
-type Callback = () => void;
-
 interface Subscription {
     subscribe(callback: Callback): Callback;
     unsubscribe(callback: Callback): void;
@@ -43,36 +60,14 @@ interface Signal$1<T> extends Reader<T>, Writer<T>, Comparable<T>, Subscription
 }
 interface ReadonlySignal<T> extends Reader<T>, Comparable<T>, Subscription {
 }
-interface SignalFactoryFunction {
-    <T>(value: T, equals?: Equals<T>): Signal$1<T>;
-}
-declare const signal$1: Factory<SignalFactoryFunction>;
-
-interface ComposedFactoryFunction {
-    <T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>): Signal$1<T>;
-}
-declare const composed$1: Factory<ComposedFactoryFunction>;
+type SignalFactory = <T>(value: T, equals?: Equals<T>) => Signal$1<T>;
+declare const signal$1: Factory<SignalFactory>;
 
-interface ComputedFactoryFunction {
-    <T>(compute: () => T, equals?: Equals<T>): ReadonlySignal<T>;
-}
-declare const computed$1: Factory<ComputedFactoryFunction>;
-
-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>;
-}
-
-declare function computed<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
-declare namespace computed {
-    var collector: Factory<ComputedCollectorFactoryFunction>;
-}
-interface ComputedCollectorFactoryFunction {
-    (): Maybe<Collector$1<ReadonlySignal<unknown>>>;
+declare function computed$1<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
+declare namespace computed$1 {
+    var collector: Factory<ComputedCollectorFactory>;
 }
+type ComputedCollectorFactory = () => Collector$1<ReadonlySignal<unknown>>;
 declare class Computed<T> implements ReadonlySignal<T> {
     private empty;
     private value;
@@ -82,7 +77,7 @@ declare class Computed<T> implements ReadonlySignal<T> {
     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>>);
+    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>>);
     private dirty;
     read(): T;
     equals(other: T): boolean;
@@ -90,32 +85,58 @@ declare class Computed<T> implements ReadonlySignal<T> {
     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>;
-}
-interface ComposedCollectorFactoryFunction {
-    (): Maybe<Collector$1<ReadonlySignal<unknown>>>;
+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>;
 }
 declare class Composed<T> extends Computed<T> implements Signal$1<T> {
+    private readonly batcher;
     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>>);
+    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 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<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>;
-}
-interface SignalCollectorFactoryFunction {
-    (): Maybe<Collector$1<ReadonlySignal<unknown>>>;
+    var batcher: Factory<SignalBatcherFactory>;
+    var collector: Factory<SignalCollectorFactory>;
 }
 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 readonly equalsFn;
+    private readonly listeners;
+    private readonly batcher;
+    private readonly collector;
+    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;
@@ -123,31 +144,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_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, index_Signal as Signal, type index_SignalCollectorFactoryFunction as SignalCollectorFactoryFunction, index_collector as collector, index_composed as composed, index_computed as computed, 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>;
-    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 Callback, type Collector$1 as Collector, type CollectorFactoryFunction, type Comparable, type ComposedFactoryFunction, type ComputedFactoryFunction, type Config, 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, 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,10 +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
 });
@@ -38,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");
 
@@ -57,6 +60,12 @@ var composed = factory("composed");
 // src/core/computed.ts
 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");
 
@@ -67,12 +76,22 @@ __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);
@@ -82,6 +101,9 @@ var Collector = class {
   constructor(values) {
     this.values = values;
   }
+  collecting() {
+    return this.values !== null;
+  }
   add(value) {
     if (!this.values) return;
     this.values.add(value);
@@ -94,13 +116,16 @@ var Collector = class {
     this.values = current;
     return collected;
   }
+  ignore(callback) {
+    const current = this.values;
+    this.values = null;
+    callback();
+    this.values = current;
+  }
 };
 
 // src/internal/computed.ts
 function computed2(compute, equals) {
-  if (!computed2.collector()) {
-    throw new Error("computed: collector is not configured.");
-  }
   return new Computed(
     true,
     void 0,
@@ -134,28 +159,20 @@ var Computed = class {
   }
   dirty() {
     if (this.empty) return true;
-    return Array.from(this.dependencies).some((dependency, index) => !dependency.equals(this.values[index]));
+    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();
-    });
+    const next = this.collector.collect(() => this.value = this.compute());
     this.dependencies = next;
-    this.values = Array.from(this.dependencies).map((dependency) => dependency.read());
+    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((dependency) => {
-      if (next.has(dependency)) return;
-      this.listeners.forEach((listener) => dependency.unsubscribe(listener));
-    });
-    next.forEach((dependency) => {
-      if (current.has(dependency)) return;
-      this.listeners.forEach((listener) => dependency.subscribe(listener));
-    });
+    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) {
@@ -164,69 +181,103 @@ var Computed = class {
   }
   subscribe(callback) {
     this.listeners.add(callback);
-    this.dependencies.forEach((dependency) => dependency.subscribe(callback));
-    return () => this.unsubscribe(callback);
+    this.dependencies.forEach((dep) => dep.subscribe(callback));
+    return this.unsubscribe.bind(this, callback);
   }
   unsubscribe(callback) {
     this.listeners.delete(callback);
-    this.dependencies.forEach((dependency) => dependency.unsubscribe(callback));
+    this.dependencies.forEach((dep) => dep.unsubscribe(callback));
   }
 };
 
 // src/internal/composed.ts
 function composed2(compute, write, equals) {
-  if (!composed2.collector()) {
-    throw new Error("composed: collector is not configured.");
-  }
   return new Composed(
     true,
     void 0,
     [],
     /* @__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 {
+  batcher;
   writeFn;
-  constructor(empty, value, values, dependencies, listeners, collector3, compute, write, equals) {
+  constructor(empty, value, values, dependencies, listeners, batcher, collector3, compute, write, equals) {
     super(empty, value, values, dependencies, listeners, collector3, compute, equals);
+    this.batcher = batcher;
     this.writeFn = write;
   }
   write(value) {
     if (this.equals(value)) return;
-    this.writeFn(value);
+    batch(() => this.writeFn(value), this.batcher);
   }
 };
 
+// src/internal/effect.ts
+function effect2(cb) {
+  let cleanupFn = null;
+  let dependencies = effect2.collector().collect(() => cleanupFn = cb(true) ?? null);
+  dependencies.forEach((dependency) => dependency.subscribe(callback));
+  function callback() {
+    if (cleanupFn) cleanupFn(false);
+    const next = effect2.collector().collect(() => cleanupFn = cb(false) ?? null);
+    next.forEach((dependency) => !dependencies.has(dependency) && dependency.subscribe(callback));
+    dependencies.forEach((dependency) => !next.has(dependency) && dependency.unsubscribe(callback));
+    dependencies = next;
+  }
+  return () => {
+    dependencies.forEach((dependency) => dependency.unsubscribe(callback));
+    dependencies.clear();
+    if (cleanupFn) cleanupFn(true);
+    cleanupFn = null;
+  };
+}
+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;
+  batcher;
   collector;
-  constructor(value, equals, listeners, collector3) {
+  constructor(value, equals, listeners, batcher, collector3) {
     this.value = value;
     this.equalsFn = equals;
     this.listeners = listeners;
+    this.batcher = batcher;
     this.collector = collector3;
   }
   read() {
-    if (this.collector) this.collector.add(this);
+    this.collector.add(this);
     return this.value;
   }
   write(value) {
     if (this.equals(value)) return;
     this.value = value;
-    this.listeners.forEach((listener) => listener());
+    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);
@@ -234,38 +285,60 @@ var Signal = class {
   }
   subscribe(callback) {
     this.listeners.add(callback);
-    return () => this.unsubscribe(callback);
+    return this.unsubscribe.bind(this, callback);
   }
   unsubscribe(callback) {
     this.listeners.delete(callback);
   }
 };
 
-// src/index.ts
+// src/core/config.ts
 function config(config2 = {}) {
-  signal.factory(config2.signal);
   collector.factory(config2.collector);
+  signal.factory(config2.signal);
   computed.factory(config2.computed);
   composed.factory(config2.composed);
+  effect.factory(config2.effect);
+  batch.factory(config2.batch);
+  ignore.factory(config2.ignore);
 }
-var __shared__ = null;
-function shared() {
-  if (!__shared__) __shared__ = collector();
-  return __shared__;
+
+// src/index.ts
+var __collector__ = null;
+function shared_collector() {
+  if (!__collector__) __collector__ = collector();
+  return __collector__;
 }
-signal2.collector.default(shared);
-computed2.collector.default(shared);
-composed2.collector.default(shared);
-signal.default(signal2);
+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.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");
 
@@ -32,6 +31,12 @@ var composed = factory("composed");
 // src/core/computed.ts
 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");
 
@@ -42,12 +47,22 @@ __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);
@@ -57,6 +72,9 @@ var Collector = class {
   constructor(values) {
     this.values = values;
   }
+  collecting() {
+    return this.values !== null;
+  }
   add(value) {
     if (!this.values) return;
     this.values.add(value);
@@ -69,13 +87,16 @@ var Collector = class {
     this.values = current;
     return collected;
   }
+  ignore(callback) {
+    const current = this.values;
+    this.values = null;
+    callback();
+    this.values = current;
+  }
 };
 
 // src/internal/computed.ts
 function computed2(compute, equals) {
-  if (!computed2.collector()) {
-    throw new Error("computed: collector is not configured.");
-  }
   return new Computed(
     true,
     void 0,
@@ -109,28 +130,20 @@ var Computed = class {
   }
   dirty() {
     if (this.empty) return true;
-    return Array.from(this.dependencies).some((dependency, index) => !dependency.equals(this.values[index]));
+    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();
-    });
+    const next = this.collector.collect(() => this.value = this.compute());
     this.dependencies = next;
-    this.values = Array.from(this.dependencies).map((dependency) => dependency.read());
+    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((dependency) => {
-      if (next.has(dependency)) return;
-      this.listeners.forEach((listener) => dependency.unsubscribe(listener));
-    });
-    next.forEach((dependency) => {
-      if (current.has(dependency)) return;
-      this.listeners.forEach((listener) => dependency.subscribe(listener));
-    });
+    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) {
@@ -139,69 +152,103 @@ var Computed = class {
   }
   subscribe(callback) {
     this.listeners.add(callback);
-    this.dependencies.forEach((dependency) => dependency.subscribe(callback));
-    return () => this.unsubscribe(callback);
+    this.dependencies.forEach((dep) => dep.subscribe(callback));
+    return this.unsubscribe.bind(this, callback);
   }
   unsubscribe(callback) {
     this.listeners.delete(callback);
-    this.dependencies.forEach((dependency) => dependency.unsubscribe(callback));
+    this.dependencies.forEach((dep) => dep.unsubscribe(callback));
   }
 };
 
 // src/internal/composed.ts
 function composed2(compute, write, equals) {
-  if (!composed2.collector()) {
-    throw new Error("composed: collector is not configured.");
-  }
   return new Composed(
     true,
     void 0,
     [],
     /* @__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 {
+  batcher;
   writeFn;
-  constructor(empty, value, values, dependencies, listeners, collector3, compute, write, equals) {
+  constructor(empty, value, values, dependencies, listeners, batcher, collector3, compute, write, equals) {
     super(empty, value, values, dependencies, listeners, collector3, compute, equals);
+    this.batcher = batcher;
     this.writeFn = write;
   }
   write(value) {
     if (this.equals(value)) return;
-    this.writeFn(value);
+    batch(() => this.writeFn(value), this.batcher);
   }
 };
 
+// src/internal/effect.ts
+function effect2(cb) {
+  let cleanupFn = null;
+  let dependencies = effect2.collector().collect(() => cleanupFn = cb(true) ?? null);
+  dependencies.forEach((dependency) => dependency.subscribe(callback));
+  function callback() {
+    if (cleanupFn) cleanupFn(false);
+    const next = effect2.collector().collect(() => cleanupFn = cb(false) ?? null);
+    next.forEach((dependency) => !dependencies.has(dependency) && dependency.subscribe(callback));
+    dependencies.forEach((dependency) => !next.has(dependency) && dependency.unsubscribe(callback));
+    dependencies = next;
+  }
+  return () => {
+    dependencies.forEach((dependency) => dependency.unsubscribe(callback));
+    dependencies.clear();
+    if (cleanupFn) cleanupFn(true);
+    cleanupFn = null;
+  };
+}
+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;
+  batcher;
   collector;
-  constructor(value, equals, listeners, collector3) {
+  constructor(value, equals, listeners, batcher, collector3) {
     this.value = value;
     this.equalsFn = equals;
     this.listeners = listeners;
+    this.batcher = batcher;
     this.collector = collector3;
   }
   read() {
-    if (this.collector) this.collector.add(this);
+    this.collector.add(this);
     return this.value;
   }
   write(value) {
     if (this.equals(value)) return;
     this.value = value;
-    this.listeners.forEach((listener) => listener());
+    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);
@@ -209,37 +256,59 @@ var Signal = class {
   }
   subscribe(callback) {
     this.listeners.add(callback);
-    return () => this.unsubscribe(callback);
+    return this.unsubscribe.bind(this, callback);
   }
   unsubscribe(callback) {
     this.listeners.delete(callback);
   }
 };
 
-// src/index.ts
+// src/core/config.ts
 function config(config2 = {}) {
-  signal.factory(config2.signal);
   collector.factory(config2.collector);
+  signal.factory(config2.signal);
   computed.factory(config2.computed);
   composed.factory(config2.composed);
+  effect.factory(config2.effect);
+  batch.factory(config2.batch);
+  ignore.factory(config2.ignore);
 }
-var __shared__ = null;
-function shared() {
-  if (!__shared__) __shared__ = collector();
-  return __shared__;
+
+// src/index.ts
+var __collector__ = null;
+function shared_collector() {
+  if (!__collector__) __collector__ = collector();
+  return __collector__;
 }
-signal2.collector.default(shared);
-computed2.collector.default(shared);
-composed2.collector.default(shared);
-signal.default(signal2);
+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.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.2",
-  "description": "",
+  "version": "0.0.4",
+  "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",
@@ -11,6 +11,7 @@
   "scripts": {
     "clean": "rimraf dist",
     "build": "npm run clean && tsup",
+    "publish": "npm run build && npm publish --access public",
     "dev": "tsup --watch",
     "test": "vitest run",
     "test:watch": "vitest"