@valentin30/signal 0.0.1 → 0.0.2

package/dist/index.d.mts

@@ -1,3 +1,203 @@
-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>>
+}
+interface CollectorFactoryFunction {
+    <T>(): Collector$1<T>
+}
+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
+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 {}
+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>
+
+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 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 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>
+}
+interface 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
+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,
+    }
+}
+
+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,
+}

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>>;
+}
+interface CollectorFactoryFunction {
+    <T>(): Collector$1<T>;
+}
+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;
+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 {
+}
+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>;
+
+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 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 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>;
+}
+interface 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;
+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 };
+}
+
+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 };

package/dist/index.js

@@ -20,13 +20,252 @@ 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,
+  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/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,
+  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) {
+  if (!computed2.collector()) {
+    throw new Error("computed: collector is not configured.");
+  }
+  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((dependency, index) => !dependency.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(this.dependencies).map((dependency) => dependency.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));
+    });
+    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((dependency) => dependency.subscribe(callback));
+    return () => this.unsubscribe(callback);
+  }
+  unsubscribe(callback) {
+    this.listeners.delete(callback);
+    this.dependencies.forEach((dependency) => dependency.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.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/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 = {}) {
+  signal.factory(config2.signal);
+  collector.factory(config2.collector);
+  computed.factory(config2.computed);
+  composed.factory(config2.composed);
+}
+var __shared__ = null;
+function shared() {
+  if (!__shared__) __shared__ = collector();
+  return __shared__;
 }
+signal2.collector.default(shared);
+computed2.collector.default(shared);
+composed2.collector.default(shared);
+signal.default(signal2);
+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,
+  internal,
   signal
 });

package/dist/index.mjs

@@ -1,7 +1,245 @@
+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/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,
+  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) {
+  if (!computed2.collector()) {
+    throw new Error("computed: collector is not configured.");
+  }
+  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((dependency, index) => !dependency.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(this.dependencies).map((dependency) => dependency.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));
+    });
+    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((dependency) => dependency.subscribe(callback));
+    return () => this.unsubscribe(callback);
+  }
+  unsubscribe(callback) {
+    this.listeners.delete(callback);
+    this.dependencies.forEach((dependency) => dependency.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.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/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 = {}) {
+  signal.factory(config2.signal);
+  collector.factory(config2.collector);
+  computed.factory(config2.computed);
+  composed.factory(config2.composed);
+}
+var __shared__ = null;
+function shared() {
+  if (!__shared__) __shared__ = collector();
+  return __shared__;
 }
+signal2.collector.default(shared);
+computed2.collector.default(shared);
+composed2.collector.default(shared);
+signal.default(signal2);
+collector.default(collector2);
+computed.default(computed2);
+composed.default(composed2);
 export {
+  collector,
+  composed,
+  computed,
+  config,
+  internal_exports as internal,
   signal
 };

package/package.json

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