@valentin30/signal 0.0.1 → 0.0.3

package/dist/index.d.mts

@@ -1,3 +1,153 @@
-declare function signal(): string;
+type Maybe<T> = T | null | undefined;
 
-export { signal };
+type Factory<Fn extends FactoryFunction> = Fn & {
+    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>>;
+}
+type CollectorFactoryFunction = <T>() => Collector$1<T>;
+declare const collector$1: Factory<CollectorFactoryFunction>;
+
+type Equals<T> = (value: T, other: T) => boolean;
+interface Comparable<T> {
+    equals(other: T): boolean;
+}
+
+interface Reader<T> {
+    read(): T;
+}
+
+type Callback = () => void;
+
+interface Subscription {
+    subscribe(callback: Callback): Callback;
+    unsubscribe(callback: Callback): void;
+}
+
+interface Writer<T> {
+    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 {
+}
+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>;
+}
+
+declare function computed<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
+declare namespace computed {
+    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>;
+declare namespace composed {
+    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;
+}
+
+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_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, 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 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

@@ -1,3 +1,153 @@
-declare function signal(): string;
+type Maybe<T> = T | null | undefined;
 
-export { signal };
+type Factory<Fn extends FactoryFunction> = Fn & {
+    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>>;
+}
+type CollectorFactoryFunction = <T>() => Collector$1<T>;
+declare const collector$1: Factory<CollectorFactoryFunction>;
+
+type Equals<T> = (value: T, other: T) => boolean;
+interface Comparable<T> {
+    equals(other: T): boolean;
+}
+
+interface Reader<T> {
+    read(): T;
+}
+
+type Callback = () => void;
+
+interface Subscription {
+    subscribe(callback: Callback): Callback;
+    unsubscribe(callback: Callback): void;
+}
+
+interface Writer<T> {
+    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 {
+}
+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>;
+}
+
+declare function computed<T>(compute: () => T, equals?: Equals<T>): Computed<T>;
+declare namespace computed {
+    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>;
+declare namespace composed {
+    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;
+}
+
+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_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, 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 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

@@ -20,13 +20,268 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  collector: () => collector,
+  composed: () => composed,
+  computed: () => computed,
+  config: () => config,
+  effect: () => effect,
+  internal: () => internal_exports,
   signal: () => signal
 });
 module.exports = __toCommonJS(index_exports);
-function signal() {
-  return "signal";
+
+// src/core/factory.ts
+function factory(name) {
+  let __default__ = null;
+  let __factory__ = null;
+  function object(...args) {
+    if (__factory__) return __factory__(...args);
+    if (__default__) return __default__(...args);
+    throw new Error(`${name}.factory() not configured!`);
+  }
+  object.default = (factory2) => {
+    __default__ = factory2;
+  };
+  object.factory = (factory2) => {
+    __factory__ = factory2;
+  };
+  object.configured = () => __default__ !== null || __factory__ !== null;
+  return object;
+}
+
+// src/core/collector.ts
+var collector = factory("collector");
+
+// src/core/composed.ts
+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");
+
+// src/internal/index.ts
+var internal_exports = {};
+__export(internal_exports, {
+  Collector: () => Collector,
+  Composed: () => Composed,
+  Computed: () => Computed,
+  Signal: () => Signal,
+  collector: () => collector2,
+  composed: () => composed2,
+  computed: () => computed2,
+  effect: () => effect2,
+  signal: () => signal2
+});
+
+// src/internal/collector.ts
+function collector2() {
+  return new Collector(null);
+}
+var Collector = class {
+  values;
+  constructor(values) {
+    this.values = values;
+  }
+  add(value) {
+    if (!this.values) return;
+    this.values.add(value);
+  }
+  collect(callback) {
+    const current = this.values;
+    this.values = /* @__PURE__ */ new Set();
+    callback();
+    const collected = this.values;
+    this.values = current;
+    return collected;
+  }
+};
+
+// src/internal/computed.ts
+function computed2(compute, equals) {
+  return new Computed(
+    true,
+    void 0,
+    [],
+    /* @__PURE__ */ new Set(),
+    /* @__PURE__ */ new Set(),
+    computed2.collector(),
+    compute,
+    equals
+  );
+}
+computed2.collector = factory("computed.collector");
+var Computed = class {
+  empty;
+  value;
+  values;
+  dependencies;
+  compute;
+  equalsFn;
+  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;
+  }
+  dirty() {
+    if (this.empty) return true;
+    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());
+    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;
+  }
+  equals(other) {
+    if (this.equalsFn) return this.equalsFn(this.read(), other);
+    return this.read() === other;
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    this.dependencies.forEach((dep) => dep.subscribe(callback));
+    return () => this.unsubscribe(callback);
+  }
+  unsubscribe(callback) {
+    this.listeners.delete(callback);
+    this.dependencies.forEach((dep) => dep.unsubscribe(callback));
+  }
+};
+
+// src/internal/composed.ts
+function composed2(compute, write, equals) {
+  return new Composed(
+    true,
+    void 0,
+    [],
+    /* @__PURE__ */ new Set(),
+    /* @__PURE__ */ new Set(),
+    composed2.collector(),
+    compute,
+    write,
+    equals
+  );
+}
+composed2.collector = factory("composed.collector");
+var Composed = class extends Computed {
+  writeFn;
+  constructor(empty, value, values, dependencies, listeners, collector3, compute, write, equals) {
+    super(empty, value, values, dependencies, listeners, collector3, compute, equals);
+    this.writeFn = write;
+  }
+  write(value) {
+    if (this.equals(value)) return;
+    this.writeFn(value);
+  }
+};
+
+// 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());
+}
+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;
+  }
+  read() {
+    if (this.collector) this.collector.add(this);
+    return this.value;
+  }
+  write(value) {
+    if (this.equals(value)) return;
+    this.value = value;
+    this.listeners.forEach((listener) => listener());
+  }
+  equals(other) {
+    if (this.equalsFn) return this.equalsFn(this.value, other);
+    return this.value === other;
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    return () => this.unsubscribe(callback);
+  }
+  unsubscribe(callback) {
+    this.listeners.delete(callback);
+  }
+};
+
+// src/index.ts
+function config(config2 = {}) {
+  collector.factory(config2.collector);
+  signal.factory(config2.signal);
+  effect.factory(config2.effect);
+  computed.factory(config2.computed);
+  composed.factory(config2.composed);
+}
+var __shared__ = null;
+function shared() {
+  if (!__shared__) __shared__ = collector();
+  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);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  collector,
+  composed,
+  computed,
+  config,
+  effect,
+  internal,
   signal
 });

package/dist/index.mjs

@@ -1,7 +1,260 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/factory.ts
+function factory(name) {
+  let __default__ = null;
+  let __factory__ = null;
+  function object(...args) {
+    if (__factory__) return __factory__(...args);
+    if (__default__) return __default__(...args);
+    throw new Error(`${name}.factory() not configured!`);
+  }
+  object.default = (factory2) => {
+    __default__ = factory2;
+  };
+  object.factory = (factory2) => {
+    __factory__ = factory2;
+  };
+  object.configured = () => __default__ !== null || __factory__ !== null;
+  return object;
+}
+
+// src/core/collector.ts
+var collector = factory("collector");
+
+// src/core/composed.ts
+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");
+
+// src/internal/index.ts
+var internal_exports = {};
+__export(internal_exports, {
+  Collector: () => Collector,
+  Composed: () => Composed,
+  Computed: () => Computed,
+  Signal: () => Signal,
+  collector: () => collector2,
+  composed: () => composed2,
+  computed: () => computed2,
+  effect: () => effect2,
+  signal: () => signal2
+});
+
+// src/internal/collector.ts
+function collector2() {
+  return new Collector(null);
+}
+var Collector = class {
+  values;
+  constructor(values) {
+    this.values = values;
+  }
+  add(value) {
+    if (!this.values) return;
+    this.values.add(value);
+  }
+  collect(callback) {
+    const current = this.values;
+    this.values = /* @__PURE__ */ new Set();
+    callback();
+    const collected = this.values;
+    this.values = current;
+    return collected;
+  }
+};
+
+// src/internal/computed.ts
+function computed2(compute, equals) {
+  return new Computed(
+    true,
+    void 0,
+    [],
+    /* @__PURE__ */ new Set(),
+    /* @__PURE__ */ new Set(),
+    computed2.collector(),
+    compute,
+    equals
+  );
+}
+computed2.collector = factory("computed.collector");
+var Computed = class {
+  empty;
+  value;
+  values;
+  dependencies;
+  compute;
+  equalsFn;
+  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;
+  }
+  dirty() {
+    if (this.empty) return true;
+    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());
+    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;
+  }
+  equals(other) {
+    if (this.equalsFn) return this.equalsFn(this.read(), other);
+    return this.read() === other;
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    this.dependencies.forEach((dep) => dep.subscribe(callback));
+    return () => this.unsubscribe(callback);
+  }
+  unsubscribe(callback) {
+    this.listeners.delete(callback);
+    this.dependencies.forEach((dep) => dep.unsubscribe(callback));
+  }
+};
+
+// src/internal/composed.ts
+function composed2(compute, write, equals) {
+  return new Composed(
+    true,
+    void 0,
+    [],
+    /* @__PURE__ */ new Set(),
+    /* @__PURE__ */ new Set(),
+    composed2.collector(),
+    compute,
+    write,
+    equals
+  );
+}
+composed2.collector = factory("composed.collector");
+var Composed = class extends Computed {
+  writeFn;
+  constructor(empty, value, values, dependencies, listeners, collector3, compute, write, equals) {
+    super(empty, value, values, dependencies, listeners, collector3, compute, equals);
+    this.writeFn = write;
+  }
+  write(value) {
+    if (this.equals(value)) return;
+    this.writeFn(value);
+  }
+};
+
+// 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());
+}
+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;
+  }
+  read() {
+    if (this.collector) this.collector.add(this);
+    return this.value;
+  }
+  write(value) {
+    if (this.equals(value)) return;
+    this.value = value;
+    this.listeners.forEach((listener) => listener());
+  }
+  equals(other) {
+    if (this.equalsFn) return this.equalsFn(this.value, other);
+    return this.value === other;
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    return () => this.unsubscribe(callback);
+  }
+  unsubscribe(callback) {
+    this.listeners.delete(callback);
+  }
+};
+
 // src/index.ts
-function signal() {
-  return "signal";
+function config(config2 = {}) {
+  collector.factory(config2.collector);
+  signal.factory(config2.signal);
+  effect.factory(config2.effect);
+  computed.factory(config2.computed);
+  composed.factory(config2.composed);
+}
+var __shared__ = null;
+function shared() {
+  if (!__shared__) __shared__ = collector();
+  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);
 export {
+  collector,
+  composed,
+  computed,
+  config,
+  effect,
+  internal_exports as internal,
   signal
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valentin30/signal",
-  "version": "0.0.1",
+  "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"
@@ -19,13 +20,14 @@
     "type": "git",
     "url": "git+https://github.com/valentin30/signal.git"
   },
-  "author": "Valentin Spasov",
+  "author": "Valentin",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/valentin30/signal/issues"
   },
   "homepage": "https://github.com/valentin30/signal#readme",
   "devDependencies": {
+    "@types/node": "^22.15.29",
     "rimraf": "^6.0.1",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",