@valentin30/signal 0.0.9 → 0.1.0

package/dist/index.js

@@ -76,163 +76,170 @@ 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
+  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/internal/batch.ts
-function batch2(callback, collector3 = batch2.collector()) {
-  if (collector3.collecting()) return callback();
-  collector3.collect(callback).forEach((listener) => listener());
+function internal_batch(callback, collector2 = internal_batch.collector()) {
+  if (collector2.collecting()) return callback();
+  collector2.collect(callback).forEach((listener) => listener());
 }
-batch2.collector = factory("batch.collector");
+((internal_batch2) => {
+  internal_batch2.collector = factory("batch.collector");
+})(internal_batch || (internal_batch = {}));
 
 // src/internal/collector.ts
-function collector2() {
-  return new Collector(null);
+function internal_collector() {
+  return new internal_collector.Constructor(null);
 }
-var Collector = class {
-  #values;
-  constructor(values) {
-    this.#values = values;
+((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;
+    }
   }
-  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;
-  }
-};
+  internal_collector2.Constructor = Constructor;
+})(internal_collector || (internal_collector = {}));
 
 // src/internal/computed.ts
-function computed2(compute, equals) {
-  return new Computed(
+function internal_computed(compute, equals) {
+  return new internal_computed.Constructor(
     true,
     void 0,
     [],
     /* @__PURE__ */ new Set(),
     /* @__PURE__ */ new Set(),
-    computed2.collector(),
+    internal_computed.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;
-  }
-  read() {
-    this.#collector.add(this);
-    return this.peek();
+((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);
+    }
+    unsubscribe(callback) {
+      this.#listeners.delete(callback);
+      this.#dependencies.forEach((dep) => dep.unsubscribe(callback));
+    }
   }
-  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);
-  }
-  unsubscribe(callback) {
-    this.#listeners.delete(callback);
-    this.#dependencies.forEach((dep) => dep.unsubscribe(callback));
-  }
-};
+  internal_computed2.Constructor = Constructor;
+})(internal_computed || (internal_computed = {}));
 
 // src/internal/composed.ts
-function composed2(compute, write, equals) {
-  return new Composed(
+function internal_composed(compute, write, equals) {
+  return new internal_composed.Constructor(
     true,
     void 0,
     [],
     /* @__PURE__ */ new Set(),
     /* @__PURE__ */ new Set(),
-    composed2.batcher(),
-    composed2.collector(),
+    internal_composed.batcher(),
+    internal_composed.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;
+((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);
+    }
   }
-  write(value) {
-    if (this.equals(value)) return;
-    batch(() => this.#write(value), this.#batcher);
-  }
-};
+  internal_composed2.Constructor = Constructor;
+})(internal_composed || (internal_composed = {}));
 
 // src/internal/effect.ts
-function effect2(cb) {
+function internal_effect(cb) {
   let cleanupFn = null;
-  let dependencies = effect2.collector().collect(() => cleanupFn = cb(true) ?? 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 = effect2.collector().collect(() => cleanupFn = cb(false) ?? null);
+    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;
@@ -244,74 +251,84 @@ function effect2(cb) {
     cleanupFn = null;
   };
 }
-effect2.collector = factory("effect.collector");
+((internal_effect2) => {
+  internal_effect2.collector = factory("effect.collector");
+})(internal_effect || (internal_effect = {}));
 
 // src/internal/ignore.ts
-function ignore2(callback, ...args) {
+function internal_ignore(callback, ...args) {
   let value;
-  ignore2.collector().ignore(() => value = typeof callback === "function" ? callback(...args) : callback.read());
+  internal_ignore.collector().ignore(() => value = typeof callback === "function" ? callback(...args) : callback.read());
   return value;
 }
-ignore2.collector = factory("signal.collector");
+((internal_ignore2) => {
+  internal_ignore2.collector = factory("signal.collector");
+})(internal_ignore || (internal_ignore = {}));
 
 // src/internal/shared.ts
-var __batcher__ = null;
-var __collector__ = null;
-var shared = {
-  batcher() {
+var internal_shared;
+((internal_shared2) => {
+  let __batcher__ = null;
+  let __collector__ = null;
+  function batcher() {
     if (!__batcher__) __batcher__ = collector();
     return __batcher__;
-  },
-  collector() {
+  }
+  internal_shared2.batcher = batcher;
+  function collector2() {
     if (!__collector__) __collector__ = collector();
     return __collector__;
   }
-};
+  internal_shared2.collector = collector2;
+})(internal_shared || (internal_shared = {}));
 
 // src/internal/signal.ts
-function signal2(value, equals) {
-  return new Signal(value, equals, /* @__PURE__ */ new Set(), signal2.batcher(), signal2.collector());
+function internal_signal(value, equals) {
+  return new internal_signal.Constructor(value, equals, /* @__PURE__ */ new Set(), internal_signal.batcher(), internal_signal.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;
-  }
-  read() {
-    this.#collector.add(this);
-    return this.peek();
-  }
-  peek() {
-    return this.#value;
+((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);
+    }
   }
-  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 = {}) {
@@ -325,21 +342,21 @@ function config(config2 = {}) {
 }
 
 // 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);
+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);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   batch,