@valentin30/signal 0.0.9 → 0.2.0

package/dist/index.mjs

@@ -4,14 +4,74 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/core/factory.ts
+// src/core/contracts/comparable.ts
+var Equals;
+((Equals2) => {
+  function strict(value, other) {
+    if (value === other) return true;
+    if (value !== value && other !== other) return true;
+    return false;
+  }
+  Equals2.strict = strict;
+})(Equals || (Equals = {}));
+function comparator(equals = Equals.strict) {
+  return { equals };
+}
+
+// src/core/contracts/readable.ts
+function reader(read) {
+  return { read };
+}
+
+// src/core/contracts/writable.ts
+function writer(write) {
+  return {
+    write(value) {
+      const result = write(value);
+      if (typeof result === "boolean") return result;
+      return true;
+    }
+  };
+}
+
+// src/internal/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  BasicValue: () => BasicValue,
+  BatchWriter: () => BatchWriter,
+  CallbackScheduler: () => CallbackScheduler,
+  CollectorBasedBatcher: () => CollectorBasedBatcher,
+  CollectorController: () => CollectorController,
+  Composed: () => Composed,
+  ComputedValue: () => ComputedValue,
+  DependencyManager: () => DependencyManager,
+  EmittingValue: () => EmittingValue,
+  Reactive: () => Reactive,
+  ScheduledEmitter: () => ScheduledEmitter,
+  Snapshot: () => Snapshot
+});
+
+// src/utils/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  call: () => call,
+  factory: () => factory,
+  singleton: () => singleton
+});
+
+// src/utils/call.ts
+function call(callback) {
+  callback();
+}
+
+// src/utils/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!`);
+    throw new Error(`${name}::factory() not configured!`);
   }
   object.configured = () => __default__ !== null || __factory__ !== null;
   object.default = (factory2) => {
@@ -23,303 +83,383 @@ function factory(name) {
   return object;
 }
 
-// src/core/batch.ts
-var batch = factory("batch");
-
-// 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/ignore.ts
-var ignore = factory("ignore");
-
-// 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,
-  batch: () => batch2,
-  collector: () => collector2,
-  composed: () => composed2,
-  computed: () => computed2,
-  effect: () => effect2,
-  ignore: () => ignore2,
-  shared: () => shared,
-  signal: () => signal2
-});
+// src/utils/singleton.ts
+function singleton(factory2) {
+  function object() {
+    return object.instance ??= factory2();
+  }
+  object.instance = void 0;
+  return object;
+}
 
 // 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");
+var CollectorBasedBatcher = class {
+  collector;
+  constructor(collector) {
+    this.collector = collector;
+  }
+  batch(callback, ...args) {
+    if (this.collector.collecting()) return callback(...args);
+    const [value, collected] = this.collector.collect(callback, ...args);
+    collected.forEach(utils_exports.call);
+    return value;
+  }
+};
 
 // src/internal/collector.ts
-function collector2() {
-  return new Collector(null);
-}
-var Collector = class {
-  #values;
-  constructor(values) {
-    this.#values = values;
+var CollectorController = class {
+  values;
+  constructor(values = null) {
+    this.values = values;
   }
   collecting() {
-    return this.#values !== null;
+    return !!this.values;
   }
   add(value) {
-    if (!this.collecting() || !this.#values) return;
-    this.#values.add(value);
-  }
-  collect(callback) {
-    const current = this.#values;
-    this.#values = /* @__PURE__ */ new Set();
-    callback();
-    const collected = this.#values;
-    this.#values = current;
-    return collected;
-  }
-  ignore(callback) {
-    const current = this.#values;
-    this.#values = null;
-    callback();
-    this.#values = current;
+    if (!this.values) return;
+    this.values.add(value);
+  }
+  track(value) {
+    if (!this.values) return;
+    this.values.add(value);
+  }
+  collect(callback, ...args) {
+    const current = this.values;
+    this.values = /* @__PURE__ */ new Set();
+    const response = [];
+    try {
+      response[0] = callback(...args);
+    } finally {
+      response[1] = this.values;
+      this.values = current;
+      return response;
+    }
+  }
+  ignore(callback, ...args) {
+    const current = this.values;
+    this.values = null;
+    try {
+      return callback(...args);
+    } finally {
+      this.values = current;
+    }
   }
 };
 
-// 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;
-  #equals;
-  #listeners;
-  #collector;
-  constructor(empty, value, values, dependencies, listeners, collector3, compute, equals) {
-    this.#empty = empty;
-    this.#value = value;
-    this.#values = values;
-    this.#dependencies = dependencies;
-    this.#listeners = listeners;
-    this.#collector = collector3;
-    this.#compute = compute;
-    this.#equals = equals;
+// src/internal/composed.ts
+var Composed = class {
+  value;
+  writer;
+  constructor(value, writer2) {
+    this.value = value;
+    this.writer = writer2;
   }
   read() {
-    this.#collector.add(this);
-    return this.peek();
+    return this.value.read();
   }
   peek() {
-    if (!this.#empty && !this.#values.some(([dep, value]) => !dep.equals(value))) return this.#value;
-    const current = this.#dependencies;
-    const next = this.#collector.collect(() => this.#value = this.#compute());
-    this.#dependencies = next;
-    this.#values = Array.from(next).map((dep) => [dep, dep.read()]);
-    this.#empty = false;
-    if (!current.size && !next.size) return this.#value;
-    if (!this.#listeners.size) return this.#value;
-    current.forEach((dep) => !next.has(dep) && this.#listeners.forEach((listener) => dep.unsubscribe(listener)));
-    next.forEach((dep) => !current.has(dep) && this.#listeners.forEach((listener) => dep.subscribe(listener)));
-    return this.#value;
+    return this.value.peek();
   }
-  equals(other) {
-    if (this.#equals) return this.#equals(this.read(), other);
-    return this.read() === other;
+  write(value) {
+    if (this.value.equals(this.peek(), value)) return false;
+    return this.writer.write(value);
+  }
+  equals(...args) {
+    const [value, other] = args.length === 1 ? [this.read(), args[0]] : args;
+    return this.value.equals(value, other);
   }
   subscribe(callback) {
-    this.#listeners.add(callback);
-    this.#dependencies.forEach((dep) => dep.subscribe(callback));
-    return this.unsubscribe.bind(this, callback);
+    return this.value.subscribe(callback);
   }
   unsubscribe(callback) {
-    this.#listeners.delete(callback);
-    this.#dependencies.forEach((dep) => dep.unsubscribe(callback));
+    return this.value.unsubscribe(callback);
   }
 };
 
-// src/internal/composed.ts
-function composed2(compute, write, equals) {
-  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;
-  #write;
-  constructor(empty, value, values, dependencies, listeners, batcher, collector3, compute, write, equals) {
-    super(empty, value, values, dependencies, listeners, collector3, compute, equals);
-    this.#batcher = batcher;
-    this.#write = write;
+// src/internal/dependency.ts
+var Snapshot;
+((Snapshot2) => {
+  function changed([value, snapshot]) {
+    return !value.equals(value.peek(), snapshot);
   }
-  write(value) {
-    if (this.equals(value)) return;
-    batch(() => this.#write(value), this.#batcher);
+  Snapshot2.changed = changed;
+  function from(values) {
+    if (!values.size) return [];
+    return Array.from(values).map(create);
+  }
+  Snapshot2.from = from;
+  function create(value) {
+    return [value, value.peek()];
+  }
+})(Snapshot || (Snapshot = {}));
+var DependencyManager = class {
+  snapshot;
+  dependencies;
+  collector;
+  listeners;
+  constructor(collector, listeners = /* @__PURE__ */ new Set(), dependencies = /* @__PURE__ */ new Set(), snapshot = null) {
+    this.collector = collector;
+    this.listeners = listeners;
+    this.dependencies = dependencies;
+    this.snapshot = snapshot;
+  }
+  changed() {
+    if (!this.snapshot) return true;
+    return this.snapshot.some(Snapshot.changed);
+  }
+  track(callback) {
+    const [_, dependencies] = this.collector.collect(callback);
+    if (!this.dependencies.size && !dependencies.size) return;
+    this.snapshot = Snapshot.from(dependencies);
+    if (this.equals(dependencies)) return;
+    if (this.listeners.size) {
+      this.dependencies.forEach((dep) => !dependencies.has(dep) && this.listeners.forEach((cb) => dep.unsubscribe(cb)));
+      dependencies.forEach((dep) => !this.dependencies.has(dep) && this.listeners.forEach((cb) => dep.subscribe(cb)));
+    }
+    this.dependencies = dependencies;
+  }
+  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));
+  }
+  equals(other) {
+    if (this.dependencies === other) return true;
+    if (this.dependencies.size !== other.size) return false;
+    for (const item of this.dependencies) if (!other.has(item)) return false;
+    return true;
   }
 };
 
-// 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/shared.ts
-var __batcher__ = null;
-var __collector__ = null;
-var shared = {
-  batcher() {
-    if (!__batcher__) __batcher__ = collector();
-    return __batcher__;
-  },
-  collector() {
-    if (!__collector__) __collector__ = collector();
-    return __collector__;
+// src/internal/emitter.ts
+var ScheduledEmitter = class {
+  listeners;
+  scheduler;
+  constructor(scheduler, listeners = /* @__PURE__ */ new Set()) {
+    this.scheduler = scheduler;
+    this.listeners = listeners;
+  }
+  emit() {
+    this.scheduler.schedule(...this.listeners);
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    return () => this.unsubscribe(callback);
+  }
+  unsubscribe(callback) {
+    this.listeners.delete(callback);
   }
 };
 
-// src/internal/signal.ts
-function signal2(value, equals) {
-  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;
-  #equals;
-  #listeners;
-  #batcher;
-  #collector;
-  constructor(value, equals, listeners, batcher, collector3) {
-    this.#value = value;
-    this.#equals = equals;
-    this.#listeners = listeners;
-    this.#batcher = batcher;
-    this.#collector = collector3;
+// src/internal/reactive.ts
+var Reactive = class {
+  value;
+  tracker;
+  subscription;
+  constructor(value, tracker, subscription) {
+    this.value = value;
+    this.tracker = tracker;
+    this.subscription = subscription;
   }
   read() {
-    this.#collector.add(this);
+    this.tracker.track(this);
     return this.peek();
   }
   peek() {
-    return this.#value;
+    return this.value.read();
   }
   write(value) {
-    if (this.equals(value)) return;
-    this.#value = value;
-    if (this.#batcher.collecting()) this.#listeners.forEach((listener) => this.#batcher.add(listener));
-    else this.#listeners.forEach((listener) => listener());
+    return this.value.write(value);
   }
-  equals(other) {
-    if (this.#equals) return this.#equals(this.#value, other);
-    return this.#value === other;
+  equals(...args) {
+    const [value, other] = args.length === 1 ? [this.read(), args[0]] : args;
+    return this.value.equals(value, other);
   }
   subscribe(callback) {
-    this.#listeners.add(callback);
-    return this.unsubscribe.bind(this, callback);
+    return this.subscription.subscribe(callback);
   }
   unsubscribe(callback) {
-    this.#listeners.delete(callback);
+    return this.subscription.unsubscribe(callback);
   }
 };
 
-// src/core/config.ts
-function config(config2 = {}) {
-  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);
+// src/internal/scheduler.ts
+var CallbackScheduler = class {
+  collector;
+  add;
+  constructor(collector) {
+    this.collector = collector;
+    this.add = this.collector.add.bind(this.collector);
+  }
+  schedule(...args) {
+    if (args.length === 0) return;
+    if (!this.collector.collecting()) return args.forEach(utils_exports.call);
+    args.forEach(this.add);
+  }
+};
+
+// src/internal/value.ts
+var BasicValue = class {
+  value;
+  comparator;
+  constructor(value, comparator2) {
+    this.value = value;
+    this.comparator = comparator2;
+  }
+  read() {
+    return this.value;
+  }
+  write(value) {
+    if (this.comparator.equals(this.value, value)) return false;
+    this.value = value;
+    return true;
+  }
+  equals(...args) {
+    const [value, other] = args.length === 1 ? [this.read(), args[0]] : args;
+    return this.comparator.equals(value, other);
+  }
+};
+var EmittingValue = class {
+  value;
+  emitter;
+  constructor(value, emitter) {
+    this.value = value;
+    this.emitter = emitter;
+  }
+  read() {
+    return this.value.read();
+  }
+  write(value) {
+    const changed = this.value.write(value);
+    if (changed) this.emitter.emit();
+    return changed;
+  }
+  equals(...args) {
+    const [value, other] = args.length === 1 ? [this.read(), args[0]] : args;
+    return this.value.equals(value, other);
+  }
+};
+var ComputedValue = class {
+  cache;
+  computation;
+  dependencies;
+  constructor(cache, computation, dependencies) {
+    this.cache = cache;
+    this.computation = computation;
+    this.dependencies = dependencies;
+    this.recompute = this.recompute.bind(this);
+  }
+  read() {
+    if (this.dependencies.changed()) this.dependencies.track(this.recompute);
+    return this.cache.read();
+  }
+  recompute() {
+    this.cache.write(this.computation.read());
+  }
+  write(_) {
+    return false;
+  }
+  equals(...args) {
+    const [value, other] = args.length === 1 ? [this.read(), args[0]] : args;
+    return this.cache.equals(value, other);
+  }
+};
+
+// src/internal/writable.ts
+var BatchWriter = class {
+  writer;
+  batcher;
+  constructor(writer2, batcher) {
+    this.writer = writer2;
+    this.batcher = batcher;
+  }
+  write(value) {
+    const result = this.batcher.batch(() => this.writer.write(value));
+    if (typeof result === "boolean") return result;
+    return true;
+  }
+};
+
+// src/app/index.ts
+function configuration() {
+  return __configuration__;
+}
+var __configuration__ = {
+  signal: utils_exports.factory("@configuration.signal"),
+  computed: utils_exports.factory("@configuration.computed"),
+  composed: utils_exports.factory("@configuration.composed"),
+  batcher: utils_exports.factory("@configuration.batch"),
+  ignorer: utils_exports.factory("@configuration.ignore"),
+  // Internal
+  scheduler: utils_exports.factory("@configuration.scheduler"),
+  tracker: utils_exports.factory("@configuration.tracker"),
+  collector: utils_exports.factory("@configuration.collector"),
+  dependency_tracker: utils_exports.factory("@configuration.dependency.tracker"),
+  dependency_collector: utils_exports.factory("@configuration.dependency.collector"),
+  callback_collector: utils_exports.factory("@configuration.callback.collector")
+};
+__configuration__.signal.default((value, equals) => {
+  const emitter = new internal_exports.ScheduledEmitter(configuration().scheduler());
+  const state = new internal_exports.EmittingValue(new internal_exports.BasicValue(value, comparator(equals)), emitter);
+  return new internal_exports.Reactive(state, configuration().tracker(), emitter);
+});
+__configuration__.computed.default((compute, equals) => {
+  const dependency = configuration().dependency_tracker();
+  const cache = new internal_exports.BasicValue(void 0, comparator(equals));
+  const value = new internal_exports.ComputedValue(cache, reader(compute), dependency);
+  return new internal_exports.Reactive(value, configuration().tracker(), dependency);
+});
+__configuration__.composed.default(
+  (value, write) => new internal_exports.Composed(value, new internal_exports.BatchWriter(writer(write), configuration().batcher()))
+);
+__configuration__.batcher.default(utils_exports.singleton(() => new internal_exports.CollectorBasedBatcher(configuration().callback_collector())));
+__configuration__.ignorer.default(configuration().dependency_collector);
+__configuration__.scheduler.default(utils_exports.singleton(() => new internal_exports.CallbackScheduler(configuration().callback_collector())));
+__configuration__.collector.default(configuration().dependency_collector);
+__configuration__.tracker.default(configuration().dependency_collector);
+__configuration__.dependency_tracker.default(() => new internal_exports.DependencyManager(configuration().collector()));
+__configuration__.dependency_collector.default(utils_exports.singleton(() => new internal_exports.CollectorController()));
+__configuration__.callback_collector.default(utils_exports.singleton(() => new internal_exports.CollectorController()));
+
+// src/core/batch.ts
+function batch(callback, ...args) {
+  return configuration().batcher().batch(callback, ...args);
 }
 
-// src/index.ts
-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);
-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);
+// src/core/composed.ts
+function composed(value, write) {
+  return configuration().composed(value, write);
+}
+
+// src/core/computed.ts
+function computed(compute, equals) {
+  return configuration().computed(compute, equals);
+}
+
+// src/core/ignore.ts
+function ignore(callback, ...args) {
+  return configuration().ignorer().ignore(callback, ...args);
+}
+
+// src/core/signal.ts
+function signal(value, equals) {
+  return configuration().signal(value, equals);
+}
 export {
+  Equals,
+  internal_exports as Internal,
   batch,
-  collector,
+  comparator,
   composed,
   computed,
-  config,
-  effect,
-  factory,
+  configuration,
   ignore,
-  internal_exports as internal,
-  signal
+  reader,
+  signal,
+  utils_exports as utils,
+  writer
 };