@valentin30/signal 0.0.2 → 0.0.3

package/dist/index.d.mts

@@ -1,203 +1,153 @@
-type Maybe<T> = T | null | undefined
+type Maybe<T> = T | null | undefined;
 
 type Factory<Fn extends FactoryFunction> = Fn & {
-    factory(factory: Maybe<Fn>): void
-    default(factory: Maybe<Fn>): void
-    configured(): boolean
-}
-type FactoryFunction = (...args: any[]) => any
+    factory(factory: Maybe<Fn>): void;
+    default(factory: Maybe<Fn>): void;
+    configured(): boolean;
+};
+type FactoryFunction = (...args: any[]) => any;
 
 interface Collector$1<T> {
-    add(value: T): void
-    collect(callback: () => void): Readonly<Set<T>>
-}
-interface CollectorFactoryFunction {
-    <T>(): Collector$1<T>
+    add(value: T): void;
+    collect(callback: () => void): Readonly<Set<T>>;
 }
-type collector_type = typeof collector$1
-interface collector$1 extends collector_type {}
-declare const collector$1: Factory<CollectorFactoryFunction>
+type CollectorFactoryFunction = <T>() => Collector$1<T>;
+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
+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 SignalFactoryFunction = <T>(value: T, equals?: Equals<T>) => Signal$1<T>;
+declare const signal$1: Factory<SignalFactoryFunction>;
 
-interface ComputedFactoryFunction {
-    <T>(compute: () => T, equals?: Equals<T>): ReadonlySignal<T>
-}
-declare const computed$1: Factory<ComputedFactoryFunction>
+type ComposedFactoryFunction = <T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal$1<T>;
+declare const composed$1: Factory<ComposedFactoryFunction>;
 
-declare function collector<T>(): Collector$1<T>
+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>
+    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 function computed<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
 declare namespace computed {
-    var collector: Factory<ComputedCollectorFactoryFunction>
-}
-interface ComputedCollectorFactoryFunction {
-    (): Maybe<Collector$1<ReadonlySignal<unknown>>>
+    var collector: Factory<ComputedCollectorFactoryFunction>;
 }
+type ComputedCollectorFactoryFunction = () => 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
-    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>
+    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>>>
+    var collector: Factory<ComposedCollectorFactoryFunction>;
 }
+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>>,
-    )
-    write(value: T): void
-}
-
-declare function signal<T>(value: T, equals?: Equals<T>): Signal$1<T>
-declare namespace signal {
-    var collector: Factory<SignalCollectorFactoryFunction>
+    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;
 }
-interface SignalCollectorFactoryFunction {
-    (): Maybe<Collector$1<ReadonlySignal<unknown>>>
+
+type EffectCollectorFactoryFunction = () => Collector$1<ReadonlySignal<unknown>>;
+declare function effect(cb: EffectCallback): Callback;
+declare namespace effect {
+    var collector: Factory<EffectCollectorFactoryFunction>;
 }
+
+declare function signal<T>(value: T, equals?: Equals<T>): Signal$1<T>;
+declare namespace signal {
+    var collector: Factory<SignalCollectorFactoryFunction>;
+}
+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>>>)
-    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 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_EffectCollectorFactoryFunction = EffectCollectorFactoryFunction;
+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_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 { 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 };
 }
 
+type Arguments<T> = T extends (...args: infer A) => any ? A : never;
+
 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<CollectorFactoryFunction>;
+    signal?: Maybe<SignalFactoryFunction>;
+    effect?: Maybe<EffectFactoryFunction>;
+    computed?: Maybe<ComputedFactoryFunction>;
+    composed?: Maybe<ComposedFactoryFunction>;
 }
+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 };

package/dist/index.d.ts

@@ -11,12 +11,7 @@ interface Collector$1<T> {
     add(value: T): void;
     collect(callback: () => void): Readonly<Set<T>>;
 }
-interface CollectorFactoryFunction {
-    <T>(): Collector$1<T>;
-}
-type collector_type = typeof collector$1;
-interface collector$1 extends collector_type {
-}
+type CollectorFactoryFunction = <T>() => Collector$1<T>;
 declare const collector$1: Factory<CollectorFactoryFunction>;
 
 type Equals<T> = (value: T, other: T) => boolean;
@@ -43,21 +38,21 @@ 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>;
-}
+type 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>;
-}
+type ComposedFactoryFunction = <T>(compute: () => T, write: (value: T) => void, equals?: Equals<T>) => Signal$1<T>;
 declare const composed$1: Factory<ComposedFactoryFunction>;
 
-interface ComputedFactoryFunction {
-    <T>(compute: () => T, equals?: Equals<T>): ReadonlySignal<T>;
-}
+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;
@@ -70,9 +65,7 @@ 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>>>;
-}
+type ComputedCollectorFactoryFunction = () => Collector$1<ReadonlySignal<unknown>>;
 declare class Computed<T> implements ReadonlySignal<T> {
     private empty;
     private value;
@@ -94,22 +87,24 @@ declare function composed<T>(compute: () => T, write: (value: T) => void, equals
 declare namespace composed {
     var collector: Factory<ComposedCollectorFactoryFunction>;
 }
-interface ComposedCollectorFactoryFunction {
-    (): Maybe<Collector$1<ReadonlySignal<unknown>>>;
-}
+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>>);
     write(value: T): void;
 }
 
+type EffectCollectorFactoryFunction = () => Collector$1<ReadonlySignal<unknown>>;
+declare function effect(cb: EffectCallback): Callback;
+declare namespace effect {
+    var collector: Factory<EffectCollectorFactoryFunction>;
+}
+
 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>>>;
-}
+type SignalCollectorFactoryFunction = () => Maybe<Collector$1<ReadonlySignal<unknown>>>;
 declare class Signal<T> implements Signal$1<T> {
     private value;
     private equalsFn;
@@ -131,23 +126,28 @@ type index_ComposedCollectorFactoryFunction = ComposedCollectorFactoryFunction;
 type index_Computed<T> = Computed<T>;
 declare const index_Computed: typeof Computed;
 type index_ComputedCollectorFactoryFunction = ComputedCollectorFactoryFunction;
+type index_EffectCollectorFactoryFunction = EffectCollectorFactoryFunction;
 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_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 { 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 };
 }
 
+type Arguments<T> = T extends (...args: infer A) => any ? A : never;
+
 interface Config {
     collector?: Maybe<CollectorFactoryFunction>;
     signal?: Maybe<SignalFactoryFunction>;
+    effect?: Maybe<EffectFactoryFunction>;
     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 };
+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 };

package/dist/index.js

@@ -24,6 +24,7 @@ __export(index_exports, {
   composed: () => composed,
   computed: () => computed,
   config: () => config,
+  effect: () => effect,
   internal: () => internal_exports,
   signal: () => signal
 });
@@ -57,6 +58,9 @@ var composed = factory("composed");
 // src/core/computed.ts
 var computed = factory("computed");
 
+// src/core/effect.ts
+var effect = factory("effect");
+
 // src/core/signal.ts
 var signal = factory("signal");
 
@@ -70,6 +74,7 @@ __export(internal_exports, {
   collector: () => collector2,
   composed: () => composed2,
   computed: () => computed2,
+  effect: () => effect2,
   signal: () => signal2
 });
 
@@ -98,9 +103,6 @@ var Collector = class {
 
 // 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 +136,20 @@ var Computed = class {
   }
   dirty() {
     if (this.empty) return true;
-    return Array.from(this.dependencies).some((dependency, index) => !dependency.equals(this.values[index]));
+    return Array.from(this.dependencies).some((dep, index) => !dep.equals(this.values[index]));
   }
   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.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,20 +158,17 @@ var Computed = class {
   }
   subscribe(callback) {
     this.listeners.add(callback);
-    this.dependencies.forEach((dependency) => dependency.subscribe(callback));
+    this.dependencies.forEach((dep) => dep.subscribe(callback));
     return () => this.unsubscribe(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,
@@ -203,6 +194,27 @@ var Composed = class extends Computed {
   }
 };
 
+// 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/signal.ts
 function signal2(value, equals) {
   return new Signal(value, equals, /* @__PURE__ */ new Set(), signal2.collector());
@@ -243,8 +255,9 @@ var Signal = class {
 
 // src/index.ts
 function config(config2 = {}) {
-  signal.factory(config2.signal);
   collector.factory(config2.collector);
+  signal.factory(config2.signal);
+  effect.factory(config2.effect);
   computed.factory(config2.computed);
   composed.factory(config2.composed);
 }
@@ -254,9 +267,11 @@ function shared() {
   return __shared__;
 }
 signal2.collector.default(shared);
+effect2.collector.default(shared);
 computed2.collector.default(shared);
 composed2.collector.default(shared);
 signal.default(signal2);
+effect.default(effect2);
 collector.default(collector2);
 computed.default(computed2);
 composed.default(composed2);
@@ -266,6 +281,7 @@ composed.default(composed2);
   composed,
   computed,
   config,
+  effect,
   internal,
   signal
 });

package/dist/index.mjs

@@ -32,6 +32,9 @@ var composed = factory("composed");
 // src/core/computed.ts
 var computed = factory("computed");
 
+// src/core/effect.ts
+var effect = factory("effect");
+
 // src/core/signal.ts
 var signal = factory("signal");
 
@@ -45,6 +48,7 @@ __export(internal_exports, {
   collector: () => collector2,
   composed: () => composed2,
   computed: () => computed2,
+  effect: () => effect2,
   signal: () => signal2
 });
 
@@ -73,9 +77,6 @@ var Collector = class {
 
 // 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 +110,20 @@ var Computed = class {
   }
   dirty() {
     if (this.empty) return true;
-    return Array.from(this.dependencies).some((dependency, index) => !dependency.equals(this.values[index]));
+    return Array.from(this.dependencies).some((dep, index) => !dep.equals(this.values[index]));
   }
   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.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,20 +132,17 @@ var Computed = class {
   }
   subscribe(callback) {
     this.listeners.add(callback);
-    this.dependencies.forEach((dependency) => dependency.subscribe(callback));
+    this.dependencies.forEach((dep) => dep.subscribe(callback));
     return () => this.unsubscribe(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,
@@ -178,6 +168,27 @@ var Composed = class extends Computed {
   }
 };
 
+// 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/signal.ts
 function signal2(value, equals) {
   return new Signal(value, equals, /* @__PURE__ */ new Set(), signal2.collector());
@@ -218,8 +229,9 @@ var Signal = class {
 
 // src/index.ts
 function config(config2 = {}) {
-  signal.factory(config2.signal);
   collector.factory(config2.collector);
+  signal.factory(config2.signal);
+  effect.factory(config2.effect);
   computed.factory(config2.computed);
   composed.factory(config2.composed);
 }
@@ -229,9 +241,11 @@ function shared() {
   return __shared__;
 }
 signal2.collector.default(shared);
+effect2.collector.default(shared);
 computed2.collector.default(shared);
 composed2.collector.default(shared);
 signal.default(signal2);
+effect.default(effect2);
 collector.default(collector2);
 computed.default(computed2);
 composed.default(composed2);
@@ -240,6 +254,7 @@ export {
   composed,
   computed,
   config,
+  effect,
   internal_exports as internal,
   signal
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valentin30/signal",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -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"