@formwright/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Formwright contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-EZUHEI5F.js

@@ -0,0 +1,162 @@
+// src/reactive.ts
+var activeObserver = null;
+var batchDepth = 0;
+var pendingEffects = /* @__PURE__ */ new Set();
+var flushing = false;
+function link(source) {
+  const obs = activeObserver;
+  if (obs === null) return;
+  if (!source.observers.has(obs)) {
+    source.observers.add(obs);
+    obs.sources.add(source);
+  }
+}
+function clearSources(obs) {
+  for (const src of obs.sources) src.observers.delete(obs);
+  obs.sources.clear();
+}
+function flush() {
+  if (flushing) return;
+  flushing = true;
+  try {
+    while (pendingEffects.size > 0) {
+      const next = pendingEffects.values().next().value;
+      pendingEffects.delete(next);
+      next.run();
+    }
+  } finally {
+    flushing = false;
+  }
+}
+var SignalNode = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  observers = /* @__PURE__ */ new Set();
+  get() {
+    link(this);
+    return this.value;
+  }
+  peek() {
+    return this.value;
+  }
+  set(next) {
+    if (Object.is(next, this.value)) return;
+    this.value = next;
+    for (const obs of [...this.observers]) obs.notify();
+    if (batchDepth === 0) flush();
+  }
+  update(fn) {
+    this.set(fn(this.value));
+  }
+};
+var ComputedNode = class {
+  constructor(fn) {
+    this.fn = fn;
+  }
+  fn;
+  observers = /* @__PURE__ */ new Set();
+  sources = /* @__PURE__ */ new Set();
+  value;
+  dirty = true;
+  notify() {
+    if (this.dirty) return;
+    this.dirty = true;
+    for (const obs of [...this.observers]) obs.notify();
+  }
+  get() {
+    link(this);
+    if (this.dirty) this.recompute();
+    return this.value;
+  }
+  peek() {
+    if (this.dirty) this.recompute();
+    return this.value;
+  }
+  recompute() {
+    clearSources(this);
+    const prev = activeObserver;
+    activeObserver = this;
+    try {
+      this.value = this.fn();
+      this.dirty = false;
+    } finally {
+      activeObserver = prev;
+    }
+  }
+};
+var EffectNode = class {
+  constructor(fn) {
+    this.fn = fn;
+    this.run();
+  }
+  fn;
+  sources = /* @__PURE__ */ new Set();
+  cleanup = void 0;
+  disposed = false;
+  notify() {
+    if (this.disposed) return;
+    pendingEffects.add(this);
+  }
+  run() {
+    if (this.disposed) return;
+    this.runCleanup();
+    clearSources(this);
+    const prev = activeObserver;
+    activeObserver = this;
+    try {
+      this.cleanup = this.fn();
+    } finally {
+      activeObserver = prev;
+    }
+  }
+  runCleanup() {
+    if (typeof this.cleanup === "function") {
+      this.cleanup();
+      this.cleanup = void 0;
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.runCleanup();
+    clearSources(this);
+    pendingEffects.delete(this);
+  }
+};
+function signal(initial) {
+  return new SignalNode(initial);
+}
+function computed(fn) {
+  return new ComputedNode(fn);
+}
+function effect(fn) {
+  const node = new EffectNode(fn);
+  return () => node.dispose();
+}
+function untrack(fn) {
+  const prev = activeObserver;
+  activeObserver = null;
+  try {
+    return fn();
+  } finally {
+    activeObserver = prev;
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) flush();
+  }
+}
+function isTracking() {
+  return activeObserver !== null;
+}
+
+export { batch, computed, effect, isTracking, signal, untrack };
+//# sourceMappingURL=chunk-EZUHEI5F.js.map
+//# sourceMappingURL=chunk-EZUHEI5F.js.map

package/dist/chunk-EZUHEI5F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/reactive.ts"],"names":[],"mappings":"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","file":"chunk-EZUHEI5F.js","sourcesContent":["/**\n * Fine-grained reactivity — the engine behind Formwright's surgical DOM updates.\n *\n * This is a small, correct, **zero-dependency** push-pull implementation:\n *  - {@link signal} holds a value and the set of observers that read it.\n *  - {@link computed} is lazy and cached: it recomputes only when read *after* a\n *    dependency changed.\n *  - {@link effect} runs immediately and re-runs when any signal/computed it read\n *    changes — this is what binds a single value to a single DOM node.\n *\n * Writing a signal marks the dependency graph dirty and synchronously flushes the\n * affected effects (so DOM updates are immediate and deterministic). Only effects\n * that actually read the changed value re-run — there is no diffing and no virtual\n * DOM. The public surface here is intentionally framework-agnostic and swappable\n * (e.g. for `alien-signals`) without touching the rest of the library.\n */\n\nexport interface ReadSignal<T> {\n  /** Read the value and subscribe the current effect/computed to changes. */\n  get(): T;\n  /** Read the value without subscribing. */\n  peek(): T;\n}\n\nexport interface WriteSignal<T> extends ReadSignal<T> {\n  set(value: T): void;\n  update(fn: (prev: T) => T): void;\n}\n\nexport type Dispose = () => void;\n\ninterface Observer {\n  /** Sources this observer currently depends on. */\n  readonly sources: Set<Source>;\n  /** Called when a dependency changed; the observer reacts (recompute or queue). */\n  notify(): void;\n}\n\ninterface Source {\n  /** Observers currently subscribed to this source. */\n  readonly observers: Set<Observer>;\n}\n\nlet activeObserver: Observer | null = null;\nlet batchDepth = 0;\nconst pendingEffects = new Set<EffectNode>();\nlet flushing = false;\n\nfunction link(source: Source): void {\n  const obs = activeObserver;\n  if (obs === null) return;\n  if (!source.observers.has(obs)) {\n    source.observers.add(obs);\n    obs.sources.add(source);\n  }\n}\n\nfunction clearSources(obs: Observer): void {\n  for (const src of obs.sources) src.observers.delete(obs);\n  obs.sources.clear();\n}\n\nfunction flush(): void {\n  if (flushing) return;\n  flushing = true;\n  try {\n    // Re-check each iteration: running an effect may queue more effects.\n    while (pendingEffects.size > 0) {\n      const next = pendingEffects.values().next().value as EffectNode;\n      pendingEffects.delete(next);\n      next.run();\n    }\n  } finally {\n    flushing = false;\n  }\n}\n\nclass SignalNode<T> implements Source {\n  readonly observers = new Set<Observer>();\n  constructor(private value: T) {}\n\n  get(): T {\n    link(this);\n    return this.value;\n  }\n\n  peek(): T {\n    return this.value;\n  }\n\n  set(next: T): void {\n    if (Object.is(next, this.value)) return;\n    this.value = next;\n    // Snapshot observers: notify() may mutate downstream sets, not ours.\n    for (const obs of [...this.observers]) obs.notify();\n    if (batchDepth === 0) flush();\n  }\n\n  update(fn: (prev: T) => T): void {\n    this.set(fn(this.value));\n  }\n}\n\nclass ComputedNode<T> implements Source, Observer {\n  readonly observers = new Set<Observer>();\n  readonly sources = new Set<Source>();\n  private value!: T;\n  private dirty = true;\n\n  constructor(private readonly fn: () => T) {}\n\n  notify(): void {\n    if (this.dirty) return; // already invalidated; observers already notified\n    this.dirty = true;\n    for (const obs of [...this.observers]) obs.notify();\n  }\n\n  get(): T {\n    link(this);\n    if (this.dirty) this.recompute();\n    return this.value;\n  }\n\n  peek(): T {\n    if (this.dirty) this.recompute();\n    return this.value;\n  }\n\n  private recompute(): void {\n    clearSources(this);\n    const prev = activeObserver;\n    activeObserver = this;\n    try {\n      this.value = this.fn();\n      this.dirty = false;\n    } finally {\n      activeObserver = prev;\n    }\n  }\n}\n\nclass EffectNode implements Observer {\n  readonly sources = new Set<Source>();\n  private cleanup: (() => void) | void = undefined;\n  private disposed = false;\n\n  constructor(private readonly fn: () => void | (() => void)) {\n    this.run();\n  }\n\n  notify(): void {\n    if (this.disposed) return;\n    pendingEffects.add(this);\n  }\n\n  run(): void {\n    if (this.disposed) return;\n    this.runCleanup();\n    clearSources(this);\n    const prev = activeObserver;\n    activeObserver = this;\n    try {\n      this.cleanup = this.fn();\n    } finally {\n      activeObserver = prev;\n    }\n  }\n\n  private runCleanup(): void {\n    if (typeof this.cleanup === \"function\") {\n      this.cleanup();\n      this.cleanup = undefined;\n    }\n  }\n\n  dispose(): void {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.runCleanup();\n    clearSources(this);\n    pendingEffects.delete(this);\n  }\n}\n\n/** Create a writable reactive value. */\nexport function signal<T>(initial: T): WriteSignal<T> {\n  return new SignalNode(initial);\n}\n\n/** Create a lazily-evaluated, cached derived value. */\nexport function computed<T>(fn: () => T): ReadSignal<T> {\n  return new ComputedNode(fn);\n}\n\n/**\n * Run `fn` immediately and again whenever a signal/computed it read changes.\n * `fn` may return a cleanup function, run before each re-run and on dispose.\n * Returns a {@link Dispose} to stop the effect.\n */\nexport function effect(fn: () => void | (() => void)): Dispose {\n  const node = new EffectNode(fn);\n  return () => node.dispose();\n}\n\n/** Read reactive values inside `fn` without subscribing the current observer. */\nexport function untrack<T>(fn: () => T): T {\n  const prev = activeObserver;\n  activeObserver = null;\n  try {\n    return fn();\n  } finally {\n    activeObserver = prev;\n  }\n}\n\n/** Batch multiple writes so effects flush once, after `fn` returns. */\nexport function batch<T>(fn: () => T): T {\n  batchDepth++;\n  try {\n    return fn();\n  } finally {\n    batchDepth--;\n    if (batchDepth === 0) flush();\n  }\n}\n\n/** True when called inside an effect/computed tracking context. */\nexport function isTracking(): boolean {\n  return activeObserver !== null;\n}\n"]}