@valentin30/signal 0.1.0 → 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,320 +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, {
-  batch: () => internal_batch,
-  collector: () => internal_collector,
-  composed: () => internal_composed,
-  computed: () => internal_computed,
-  effect: () => internal_effect,
-  ignore: () => internal_ignore,
-  shared: () => internal_shared,
-  signal: () => internal_signal
-});
+// src/utils/singleton.ts
+function singleton(factory2) {
+  function object() {
+    return object.instance ??= factory2();
+  }
+  object.instance = void 0;
+  return object;
+}
 
 // src/internal/batch.ts
-function internal_batch(callback, collector2 = internal_batch.collector()) {
-  if (collector2.collecting()) return callback();
-  collector2.collect(callback).forEach((listener) => listener());
-}
-((internal_batch2) => {
-  internal_batch2.collector = factory("batch.collector");
-})(internal_batch || (internal_batch = {}));
+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 internal_collector() {
-  return new internal_collector.Constructor(null);
-}
-((internal_collector2) => {
-  class Constructor {
-    #values;
-    constructor(values) {
-      this.#values = values;
-    }
-    collecting() {
-      return this.#values !== null;
-    }
-    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;
-    }
+var CollectorController = class {
+  values;
+  constructor(values = null) {
+    this.values = values;
   }
-  internal_collector2.Constructor = Constructor;
-})(internal_collector || (internal_collector = {}));
-
-// src/internal/computed.ts
-function internal_computed(compute, equals) {
-  return new internal_computed.Constructor(
-    true,
-    void 0,
-    [],
-    /* @__PURE__ */ new Set(),
-    /* @__PURE__ */ new Set(),
-    internal_computed.collector(),
-    compute,
-    equals
-  );
-}
-((internal_computed2) => {
-  internal_computed2.collector = factory("computed.collector");
-  class Constructor {
-    #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;
-    }
-    read() {
-      this.#collector.add(this);
-      return this.peek();
-    }
-    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;
-    }
-    equals(other) {
-      if (this.#equals) return this.#equals(this.read(), other);
-      return this.read() === other;
-    }
-    subscribe(callback) {
-      this.#listeners.add(callback);
-      this.#dependencies.forEach((dep) => dep.subscribe(callback));
-      return this.unsubscribe.bind(this, callback);
+  collecting() {
+    return !!this.values;
+  }
+  add(value) {
+    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;
     }
-    unsubscribe(callback) {
-      this.#listeners.delete(callback);
-      this.#dependencies.forEach((dep) => dep.unsubscribe(callback));
+  }
+  ignore(callback, ...args) {
+    const current = this.values;
+    this.values = null;
+    try {
+      return callback(...args);
+    } finally {
+      this.values = current;
     }
   }
-  internal_computed2.Constructor = Constructor;
-})(internal_computed || (internal_computed = {}));
+};
 
 // src/internal/composed.ts
-function internal_composed(compute, write, equals) {
-  return new internal_composed.Constructor(
-    true,
-    void 0,
-    [],
-    /* @__PURE__ */ new Set(),
-    /* @__PURE__ */ new Set(),
-    internal_composed.batcher(),
-    internal_composed.collector(),
-    compute,
-    write,
-    equals
-  );
-}
-((internal_composed2) => {
-  internal_composed2.batcher = factory("composed.batcher");
-  internal_composed2.collector = factory("composed.collector");
-  class Constructor extends internal_computed.Constructor {
-    #batcher;
-    #write;
-    constructor(empty, value, values, dependencies, listeners, batcher2, collector3, compute, write, equals) {
-      super(empty, value, values, dependencies, listeners, collector3, compute, equals);
-      this.#batcher = batcher2;
-      this.#write = write;
-    }
-    write(value) {
-      if (this.equals(value)) return;
-      batch(() => this.#write(value), this.#batcher);
+var Composed = class {
+  value;
+  writer;
+  constructor(value, writer2) {
+    this.value = value;
+    this.writer = writer2;
+  }
+  read() {
+    return this.value.read();
+  }
+  peek() {
+    return this.value.peek();
+  }
+  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) {
+    return this.value.subscribe(callback);
+  }
+  unsubscribe(callback) {
+    return this.value.unsubscribe(callback);
+  }
+};
+
+// src/internal/dependency.ts
+var Snapshot;
+((Snapshot2) => {
+  function changed([value, snapshot]) {
+    return !value.equals(value.peek(), snapshot);
+  }
+  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/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);
   }
-  internal_composed2.Constructor = Constructor;
-})(internal_composed || (internal_composed = {}));
+};
 
-// src/internal/effect.ts
-function internal_effect(cb) {
-  let cleanupFn = null;
-  let dependencies = internal_effect.collector().collect(() => cleanupFn = cb(true) ?? null);
-  dependencies.forEach((dependency) => dependency.subscribe(callback));
-  function callback() {
-    if (cleanupFn) cleanupFn(false);
-    const next = internal_effect.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;
-  };
+// 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.tracker.track(this);
+    return this.peek();
+  }
+  peek() {
+    return this.value.read();
+  }
+  write(value) {
+    return this.value.write(value);
+  }
+  equals(...args) {
+    const [value, other] = args.length === 1 ? [this.read(), args[0]] : args;
+    return this.value.equals(value, other);
+  }
+  subscribe(callback) {
+    return this.subscription.subscribe(callback);
+  }
+  unsubscribe(callback) {
+    return this.subscription.unsubscribe(callback);
+  }
+};
+
+// 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__;
 }
-((internal_effect2) => {
-  internal_effect2.collector = factory("effect.collector");
-})(internal_effect || (internal_effect = {}));
+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/internal/ignore.ts
-function internal_ignore(callback, ...args) {
-  let value;
-  internal_ignore.collector().ignore(() => value = typeof callback === "function" ? callback(...args) : callback.read());
-  return value;
+// src/core/batch.ts
+function batch(callback, ...args) {
+  return configuration().batcher().batch(callback, ...args);
 }
-((internal_ignore2) => {
-  internal_ignore2.collector = factory("signal.collector");
-})(internal_ignore || (internal_ignore = {}));
 
-// src/internal/shared.ts
-var internal_shared;
-((internal_shared2) => {
-  let __batcher__ = null;
-  let __collector__ = null;
-  function batcher() {
-    if (!__batcher__) __batcher__ = collector();
-    return __batcher__;
-  }
-  internal_shared2.batcher = batcher;
-  function collector2() {
-    if (!__collector__) __collector__ = collector();
-    return __collector__;
-  }
-  internal_shared2.collector = collector2;
-})(internal_shared || (internal_shared = {}));
+// src/core/composed.ts
+function composed(value, write) {
+  return configuration().composed(value, write);
+}
 
-// src/internal/signal.ts
-function internal_signal(value, equals) {
-  return new internal_signal.Constructor(value, equals, /* @__PURE__ */ new Set(), internal_signal.batcher(), internal_signal.collector());
+// src/core/computed.ts
+function computed(compute, equals) {
+  return configuration().computed(compute, equals);
 }
-((internal_signal2) => {
-  internal_signal2.batcher = factory("signal.batcher");
-  internal_signal2.collector = factory("signal.collector");
-  class Constructor {
-    #value;
-    #equals;
-    #listeners;
-    #batcher;
-    #collector;
-    constructor(value, equals, listeners, batcher2, collector3) {
-      this.#value = value;
-      this.#equals = equals;
-      this.#listeners = listeners;
-      this.#batcher = batcher2;
-      this.#collector = collector3;
-    }
-    read() {
-      this.#collector.add(this);
-      return this.peek();
-    }
-    peek() {
-      return this.#value;
-    }
-    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());
-    }
-    equals(other) {
-      if (this.#equals) return this.#equals(this.#value, other);
-      return this.#value === other;
-    }
-    subscribe(callback) {
-      this.#listeners.add(callback);
-      return this.unsubscribe.bind(this, callback);
-    }
-    unsubscribe(callback) {
-      this.#listeners.delete(callback);
-    }
-  }
-  internal_signal2.Constructor = Constructor;
-})(internal_signal || (internal_signal = {}));
 
-// 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/core/ignore.ts
+function ignore(callback, ...args) {
+  return configuration().ignorer().ignore(callback, ...args);
 }
 
-// src/index.ts
-internal_signal.collector.default(internal_shared.collector);
-internal_computed.collector.default(internal_shared.collector);
-internal_composed.collector.default(internal_shared.collector);
-internal_effect.collector.default(internal_shared.collector);
-internal_ignore.collector.default(internal_shared.collector);
-internal_signal.batcher.default(internal_shared.batcher);
-internal_composed.batcher.default(internal_shared.batcher);
-internal_batch.collector.default(internal_shared.batcher);
-collector.default(internal_collector);
-signal.default(internal_signal);
-computed.default(internal_computed);
-composed.default(internal_composed);
-effect.default(internal_effect);
-batch.default(internal_batch);
-ignore.default(internal_ignore);
+// 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
 };