bruh 2.0.0-beta.4 → 2.0.0-beta.5

package/dist/reactive.mjs

@@ -1,192 +1,292 @@
-import { attempt } from './utils.mjs';
+import { isSameValueZero, attempt } from './utils.mjs';
 
-const isReactiveSymbol = /* @__PURE__ */ Symbol.for("bruh reactive");
-const isReactive = (x) => (
-  // @ts-ignore
-  x?.[isReactiveSymbol] === true
-);
-class SimpleReactive {
-  [isReactiveSymbol] = true;
+let currentObserver;
+const observerStack = [];
+const pushObserver = (next) => {
+  observerStack.push(currentObserver);
+  currentObserver = next;
+};
+const popObserver = () => {
+  currentObserver = observerStack.pop();
+};
+const trackWith = (observer, f) => {
+  pushObserver(observer);
+  try {
+    return f();
+  } finally {
+    popObserver();
+  }
+};
+const untrack = (f) => {
+  return trackWith(void 0, f);
+};
+const dirtyEffects = /* @__PURE__ */ new Set();
+let isFlushScheduled = false;
+let isFlushing = false;
+const scheduleFlush = () => {
+  if (isFlushScheduled || isFlushing)
+    return;
+  isFlushScheduled = true;
+  queueMicrotask(flush);
+};
+const flush = () => {
+  if (isFlushing)
+    return;
+  isFlushing = true;
+  isFlushScheduled = false;
+  try {
+    while (dirtyEffects.size) {
+      const wave = [...dirtyEffects];
+      dirtyEffects.clear();
+      for (const effect of wave)
+        if (!effect.isDisposed)
+          effect.run();
+    }
+  } finally {
+    isFlushing = false;
+  }
+};
+class Reactive {
+  static get context() {
+    return {
+      isTracking: currentObserver !== void 0,
+      dependencies: currentObserver ? [...currentObserver.dependencies] : [],
+      stackDepth: observerStack.length
+    };
+  }
   #value;
-  #reactions = /* @__PURE__ */ new Set();
-  constructor(value) {
-    this.#value = value;
+  #getter;
+  #memoKey;
+  #lastMemoKey;
+  #isEqual = isSameValueZero;
+  #dependencies = /* @__PURE__ */ new Set();
+  #observers = /* @__PURE__ */ new Set();
+  #isDirty = false;
+  #isComputing = false;
+  #ownObserver;
+  constructor(options) {
+    this.#ownObserver = {
+      dependencies: this.#dependencies,
+      isDisposed: false,
+      weakRef: void 0,
+      markDirty: () => {
+        if (this.#isDirty)
+          return;
+        this.#isDirty = true;
+        this.#markObserversDirty();
+      }
+    };
+    this.#ownObserver.weakRef = new WeakRef(this.#ownObserver);
+    if ("getter" in options) {
+      this.#memoKey = options.memoKey;
+      this.#getter = options.getter;
+      this.#isDirty = true;
+      this.#value = void 0;
+    } else {
+      this.#value = options.value;
+    }
+    if (options.isEqual)
+      this.#isEqual = options.isEqual;
   }
-  get value() {
+  static source(value, options) {
+    return new Reactive({
+      value,
+      isEqual: options?.isEqual
+    });
+  }
+  static derived(getter, options) {
+    const result = new Reactive({
+      getter,
+      memoKey: options?.memoKey,
+      isEqual: options?.isEqual
+    });
+    result.#compute();
+    return result;
+  }
+  peek() {
+    if (this.#isDirty)
+      this.#compute();
     return this.#value;
   }
-  set value(newValue) {
-    if (newValue === this.#value)
+  get value() {
+    this.#trackAccess();
+    return this.peek();
+  }
+  set value(next) {
+    if (this.#getter)
+      throw new Error("Reactive value is readonly");
+    if (this.#isEqual(this.#value, next))
       return;
-    this.#value = newValue;
-    for (const reaction of this.#reactions)
-      attempt(reaction);
+    this.#value = next;
+    this.#markObserversDirty();
   }
   /**
-   * @param reaction called every time that the value changes
-   * @returns a function that stops the reactions
+   * @internal
    */
-  addReaction(reaction) {
-    this.#reactions.add(reaction);
-    return () => this.#reactions.delete(reaction);
+  removeObserver(observer) {
+    this.#observers.delete(observer.weakRef);
   }
-}
-class FunctionalReactive {
-  [isReactiveSymbol] = true;
-  #weakRef = new WeakRef(this);
-  // @ts-ignore
-  #value;
-  #reactions = /* @__PURE__ */ new Set();
-  // For derived nodes, this is the derivation function
-  // @ts-ignore
-  #f;
-  isEqual;
-  // Source nodes are 0 deep in the derivation graph
-  // This is for topological sort
-  #depth = 0;
-  // All nodes have a set of derivatives that update when the node changes
-  #derivatives = /* @__PURE__ */ new Set();
-  // Keep track of all the pending changes from the value setter
-  static #settersQueue = /* @__PURE__ */ new Map();
-  // A queue of derivatives to potentially update, sorted into sets by depth
-  // This starts with depth 1 and can potentially have holes
-  static #derivativesQueue = [];
-  // A queue of reactions to run after the graph is fully updated
-  static #reactionsQueue = [];
-  constructor(xOrDependencies, optionsOrF, options) {
-    if (typeof optionsOrF !== "function") {
-      const this_2 = this;
-      const value = xOrDependencies;
-      const options2 = optionsOrF;
-      this_2.#value = value;
-      this_2.isEqual = options2?.isEqual;
+  #trackAccess() {
+    if (!currentObserver)
       return;
+    this.#observers.add(currentObserver.weakRef);
+    currentObserver.dependencies.add(this);
+  }
+  #markObserversDirty() {
+    for (const ref of this.#observers) {
+      const observer = ref.deref();
+      if (observer)
+        observer.markDirty();
+      else
+        this.#observers.delete(ref);
     }
-    const this_ = this;
-    const dependencies = xOrDependencies;
-    const f = optionsOrF;
-    this_.#value = attempt(f);
-    this_.#f = f;
-    this_.isEqual = options?.isEqual;
-    this_.#depth = Math.max(0, ...dependencies.map((dependency) => dependency.#depth)) + 1;
-    dependencies.forEach((dependency) => dependency.#derivatives.add(this_.#weakRef));
   }
-  get value() {
-    if (FunctionalReactive.#settersQueue.size) {
-      if (this.#depth === 0) {
-        const this_ = this;
-        if (FunctionalReactive.#settersQueue.has(this_))
-          return FunctionalReactive.#settersQueue.get(this_);
-      } else {
-        FunctionalReactive.applyUpdates();
+  #clearDependencies() {
+    for (const dependency of this.#dependencies)
+      dependency.removeObserver(this.#ownObserver);
+    this.#dependencies.clear();
+  }
+  #compute() {
+    if (!this.#getter || !this.#isDirty)
+      return;
+    if (this.#isComputing)
+      throw new Error("Cycle detected while computing derivation");
+    this.#isComputing = true;
+    this.#isDirty = false;
+    this.#clearDependencies();
+    try {
+      if (this.#memoKey) {
+        const key = trackWith(this.#ownObserver, this.#memoKey);
+        if (isSameValueZero(key, this.#lastMemoKey))
+          return;
+        this.#lastMemoKey = key;
       }
+      const next = trackWith(this.#ownObserver, this.#getter);
+      const changed = !this.#isEqual(this.#value, next);
+      if (changed)
+        this.#value = next;
+    } catch (e) {
+      console.error(e);
+    } finally {
+      this.#isComputing = false;
     }
-    return this.#value;
   }
-  set value(newValue) {
-    if (this.#depth !== 0)
-      return;
-    const this_ = this;
-    const isEqual = this.isEqual ? this.isEqual(newValue, this.#value) : newValue === this.#value;
-    if (isEqual) {
-      FunctionalReactive.#settersQueue.delete(this_);
+}
+const activeEffects = /* @__PURE__ */ new Set();
+class Effect {
+  weakRef = new WeakRef(this);
+  dependencies = /* @__PURE__ */ new Set();
+  isDisposed = false;
+  #f;
+  #cleanup;
+  constructor(f) {
+    this.#f = f;
+    activeEffects.add(this);
+    this.markDirty();
+  }
+  markDirty() {
+    if (this.isDisposed)
       return;
-    }
-    if (!FunctionalReactive.#settersQueue.size)
-      queueMicrotask(FunctionalReactive.applyUpdates);
-    FunctionalReactive.#settersQueue.set(this_, newValue);
+    dirtyEffects.add(this);
+    scheduleFlush();
   }
-  /**
-   * @param reaction called every time that the value changes
-   * @returns a function that stops the reactions
-   */
-  addReaction(reaction) {
-    this.#reactions.add(reaction);
-    return () => this.#reactions.delete(reaction);
-  }
-  // Apply an update for a node and queue its derivatives if it actually changed
-  #applyUpdate(newValue) {
-    const isEqual = this.isEqual ? this.isEqual(newValue, this.#value) : newValue === this.#value;
-    if (isEqual)
+  run() {
+    if (this.isDisposed)
       return;
-    this.#value = newValue;
-    FunctionalReactive.#reactionsQueue.push(...this.#reactions);
-    this.#derivatives.forEach((weakRef) => {
-      const derivative = weakRef.deref();
-      if (!derivative) {
-        this.#derivatives.delete(weakRef);
-        return;
-      }
-      const depthSet = FunctionalReactive.#derivativesQueue[derivative.#depth] ??= /* @__PURE__ */ new Set();
-      depthSet.add(derivative);
-    });
+    if (this.#cleanup) {
+      attempt(this.#cleanup);
+      this.#cleanup = void 0;
+    }
+    for (const dependency of this.dependencies)
+      dependency.removeObserver(this);
+    this.dependencies.clear();
+    const result = trackWith(this, () => attempt(this.#f));
+    if (typeof result === "function")
+      this.#cleanup = result;
   }
-  /**
-   * Apply pending updates from actually changed source nodes
-   */
-  static applyUpdates() {
-    if (!FunctionalReactive.#settersQueue.size)
+  dispose() {
+    if (this.isDisposed)
       return;
-    for (const [sourceNode, newValue] of FunctionalReactive.#settersQueue.entries())
-      sourceNode.#applyUpdate(newValue);
-    FunctionalReactive.#settersQueue.clear();
-    for (const depthSet of FunctionalReactive.#derivativesQueue) if (depthSet)
-      for (const derivative of depthSet)
-        derivative.#applyUpdate(
-          attempt(
-            () => derivative.#f()
-          )
-        );
-    FunctionalReactive.#derivativesQueue.length = 0;
-    for (const reaction of FunctionalReactive.#reactionsQueue)
-      attempt(reaction);
-    FunctionalReactive.#reactionsQueue.length = 0;
+    this.isDisposed = true;
+    activeEffects.delete(this);
+    dirtyEffects.delete(this);
+    if (this.#cleanup)
+      attempt(this.#cleanup);
+    for (const dependency of this.dependencies)
+      dependency.removeObserver(this);
+    this.dependencies.clear();
   }
 }
-const r = (xOrDependencies, optionsOrF, options) => (
-  // @ts-ignore
-  new FunctionalReactive(xOrDependencies, optionsOrF, options)
-);
-const reactiveDo = (x, f) => {
-  if (isReactive(x)) {
-    f(x.value);
-    return x.addReaction(() => f(x.value));
+const watch = (fOrDependencies, fOrOptions, options) => {
+  if (typeof fOrDependencies === "function" && (fOrOptions === void 0 || typeof fOrOptions !== "function")) {
+    const f2 = fOrDependencies;
+    const effect2 = new Effect(f2);
+    return () => {
+      effect2.dispose();
+    };
   }
-  f(x);
-};
-const flat = (source) => {
-  const chain = [];
-  const reactive = new FunctionalReactive(void 0);
-  const reaction = () => {
-    let lastInCommon = source;
-    let i = 0;
-    while (lastInCommon.value === chain[i + 1]?.reactive) {
-      lastInCommon = lastInCommon.value;
-      i++;
-    }
-    if (i + 1 < chain.length) {
-      for (let j = i + 1; j < chain.length; j++)
-        chain[j].stopReacting();
-      chain.length = i;
+  const dependenciesOrGet = fOrDependencies;
+  const f = fOrOptions;
+  let isFirst = true;
+  const effect = new Effect(() => {
+    const dependencies = typeof dependenciesOrGet === "function" ? untrack(dependenciesOrGet) : dependenciesOrGet;
+    for (const dependency of dependencies)
+      dependency.value;
+    if (isFirst) {
+      isFirst = false;
+      if (options?.skipFirst)
+        return;
     }
-    updateChain(lastInCommon.value);
+    return untrack(f);
+  });
+  return () => {
+    effect.dispose();
   };
-  const updateChain = (newStart) => {
-    while (isReactive(newStart)) {
-      chain.push({
-        reactive: newStart,
-        stopReacting: newStart.addReaction(reaction)
-      });
-      newStart = newStart.value;
+};
+const r = (xOrFOrDependencies, optionsOrF, options) => {
+  const isExplicit = (Array.isArray(xOrFOrDependencies) || typeof xOrFOrDependencies === "function") && typeof optionsOrF === "function";
+  if (isExplicit) {
+    const dependenciesOrGet = xOrFOrDependencies;
+    const f = optionsOrF;
+    return Reactive.derived(() => {
+      const dependencies = typeof dependenciesOrGet === "function" ? untrack(dependenciesOrGet) : dependenciesOrGet;
+      for (const dependency of dependencies)
+        dependency.value;
+      return untrack(f);
+    }, options);
+  } else {
+    const options2 = optionsOrF;
+    if (typeof xOrFOrDependencies === "function") {
+      const f = xOrFOrDependencies;
+      return Reactive.derived(f, options2);
     }
-    const innerMost = chain[chain.length - 1].reactive;
-    reactive.isEqual = innerMost.isEqual;
-    reactive.value = innerMost.value;
-    FunctionalReactive.applyUpdates();
-  };
-  updateChain(source);
-  return reactive;
+    const x = xOrFOrDependencies;
+    return Reactive.source(x, options2);
+  }
+};
+const getValue = (x) => x instanceof Reactive ? x.value : x;
+const reactiveDo = (x, f) => {
+  if (x instanceof Reactive)
+    return watch(() => {
+      const value = x.value;
+      untrack(() => f(value));
+    });
+  f(x);
+};
+const flatCache = /* @__PURE__ */ new WeakMap();
+const flat = (nested) => {
+  const cached = flatCache.get(nested);
+  if (cached)
+    return cached;
+  const derived = r(() => {
+    let cursor = nested.value;
+    while (cursor instanceof Reactive)
+      cursor = cursor.value;
+    return cursor;
+  });
+  flatCache.set(nested, derived);
+  return derived;
 };
 
-export { FunctionalReactive, SimpleReactive, flat, isReactive, isReactiveSymbol, r, reactiveDo };
+export { Reactive, flat, flush, getValue, r, reactiveDo, untrack, watch };
 //# sourceMappingURL=reactive.mjs.map

package/dist/reactive.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"reactive.mjs","sources":["../src/reactive/index.mts"],"sourcesContent":["import { attempt } from \"../utils/index.mts\"\n\nexport const isReactiveSymbol = Symbol.for(\"bruh reactive\")\n\nexport const isReactive = (x: unknown): x is Reactive<unknown> =>\n  // @ts-ignore\n  x?.[isReactiveSymbol] === true\n\ntype Reaction = () => void\ntype StopReacting = () => void\n\nexport interface Reactive<T> {\n  [isReactiveSymbol]: true\n\n  value: T\n\n  addReaction(reaction: Reaction): StopReacting\n}\n\nexport type Unreactive<T = unknown> = Exclude<T, { [isReactiveSymbol]: true }>\n\nexport type MaybeReactive<T> = Reactive<T> | Unreactive<T>\n\nexport type NestedReactive<T extends Unreactive> = Reactive<T | NestedReactive<T>>\n\n/**\n * A super simple and performant reactive value implementation\n */\nexport class SimpleReactive<T> implements Reactive<T> {\n  [isReactiveSymbol] = true as const\n\n  #value: T\n  #reactions = new Set<Reaction>()\n\n  constructor(value: T) {\n    this.#value = value\n  }\n\n  get value() {\n    return this.#value\n  }\n\n  set value(newValue) {\n    if (newValue === this.#value)\n      return\n\n    this.#value = newValue\n    for (const reaction of this.#reactions)\n      attempt(reaction)\n  }\n\n  /**\n   * @param reaction called every time that the value changes\n   * @returns a function that stops the reactions\n   */\n  addReaction(reaction: Reaction) {\n    this.#reactions.add(reaction)\n\n    return () =>\n      this.#reactions.delete(reaction)\n  }\n}\n\nexport type IsEqual<T> = {\n  bivarianceHack(a: T, b: T): boolean\n}[\"bivarianceHack\"]\n\nexport type ReactiveOptions<T> = {\n  isEqual?: IsEqual<T>\n}\n\nexport type SourceNode<T>     = FunctionalReactive<T, \"source\">\nexport type DerivativeNode<T> = FunctionalReactive<T, \"derivative\">\n\n/**\n * A reactive implementation for building functional reactive graphs.\n * Ensures state consistency, minimal node updates, and transparent update batching.\n */\nexport class FunctionalReactive<T, U extends \"source\" | \"derivative\" = any> implements Reactive<T> {\n  [isReactiveSymbol] = true as const\n\n  #weakRef = new WeakRef(this)\n\n  // @ts-ignore\n  #value: T\n  #reactions = new Set<Reaction>()\n\n  // For derived nodes, this is the derivation function\n  // @ts-ignore\n  #f:\n    U extends \"derivative\"\n      ? () => T\n      : never\n\n  isEqual?: IsEqual<T>\n\n  // Source nodes are 0 deep in the derivation graph\n  // This is for topological sort\n  #depth:\n    U extends \"source\"\n      ? 0\n      : number // natural, > 0\n    = 0\n\n  // All nodes have a set of derivatives that update when the node changes\n  #derivatives = new Set<WeakRef<DerivativeNode<unknown>>>()\n\n  // Keep track of all the pending changes from the value setter\n  static #settersQueue = new Map<SourceNode<unknown>, unknown>()\n\n  // A queue of derivatives to potentially update, sorted into sets by depth\n  // This starts with depth 1 and can potentially have holes\n  static #derivativesQueue: Array<Set<DerivativeNode<unknown>> | undefined> = []\n\n  // A queue of reactions to run after the graph is fully updated\n  static #reactionsQueue: Array<Reaction> = []\n\n  constructor(value: T, options?: ReactiveOptions<T>)\n  constructor(\n    dependencies: ReadonlyArray<FunctionalReactive<unknown>>,\n    f: () => T,\n    options?: ReactiveOptions<T>\n  )\n  constructor(\n    xOrDependencies: T | ReadonlyArray<FunctionalReactive<unknown>>,\n    optionsOrF?: ReactiveOptions<T> | (() => T),\n    options?: ReactiveOptions<T>\n  ) {\n    // No derivation function means this is a source node\n    if (typeof optionsOrF !== \"function\") {\n      const this_ = this as SourceNode<T>\n      const value = xOrDependencies as T\n      const options = optionsOrF as ReactiveOptions<T> | undefined\n\n      this_.#value = value\n      this_.isEqual = options?.isEqual\n      return\n    }\n\n    // Derived node\n    const this_ = this as DerivativeNode<T>\n    const dependencies = xOrDependencies as ReadonlyArray<FunctionalReactive<unknown>>\n    const f = optionsOrF as () => T\n\n    this_.#value = attempt(f)\n    this_.#f = f\n    this_.isEqual = options?.isEqual\n\n    this_.#depth = Math.max(0, ...dependencies.map(dependency => dependency.#depth)) + 1\n\n    dependencies.forEach(dependency => dependency.#derivatives.add(this_.#weakRef))\n  }\n\n  get value(): T {\n    // If there are any pending updates\n    if (FunctionalReactive.#settersQueue.size) {\n      // If this is a source node that was updated, just return that\n      // new value without actually updating any derived nodes yet\n      if (this.#depth === 0) {\n        const this_ = this as SourceNode<T>\n        if (FunctionalReactive.#settersQueue.has(this_))\n          return FunctionalReactive.#settersQueue.get(this_) as T\n      }\n      // Heuristic quick invalidation for derived nodes\n      // Apply updates now, it's ok that there's already a microtask queued for this\n      else {\n        FunctionalReactive.applyUpdates()\n      }\n    }\n\n    return this.#value\n  }\n\n  set value(newValue) {\n    // Only allow source nodes to be directly updated\n    if (this.#depth !== 0)\n      return\n\n    const this_ = this as SourceNode<T>\n\n    const isEqual = this.isEqual\n      ? this.isEqual(newValue, this.#value)\n      : newValue === this.#value\n\n    if (isEqual) {\n      FunctionalReactive.#settersQueue.delete(this_)\n      return\n    }\n\n    // Unless asked for earlier, these updates are just queued up until the microtasks run\n    if (!FunctionalReactive.#settersQueue.size)\n      queueMicrotask(FunctionalReactive.applyUpdates)\n\n    FunctionalReactive.#settersQueue.set(this_, newValue)\n  }\n\n  /**\n   * @param reaction called every time that the value changes\n   * @returns a function that stops the reactions\n   */\n  addReaction(reaction: Reaction) {\n    this.#reactions.add(reaction)\n\n    return () =>\n      this.#reactions.delete(reaction)\n  }\n\n  // Apply an update for a node and queue its derivatives if it actually changed\n  #applyUpdate(newValue: T) {\n    const isEqual = this.isEqual\n      ? this.isEqual(newValue, this.#value)\n      : newValue === this.#value\n\n    if (isEqual)\n      return\n\n    this.#value = newValue\n    FunctionalReactive.#reactionsQueue.push(...this.#reactions)\n\n    this.#derivatives.forEach(weakRef => {\n      const derivative = weakRef.deref()\n      if (!derivative) {\n        this.#derivatives.delete(weakRef)\n        return\n      }\n\n      const depthSet = FunctionalReactive.#derivativesQueue[derivative.#depth] ??= new Set()\n      depthSet.add(derivative)\n    })\n  }\n\n  /**\n   * Apply pending updates from actually changed source nodes\n   */\n  static applyUpdates() {\n    if (!FunctionalReactive.#settersQueue.size)\n      return\n\n    // Bootstrap by applying the updates from the pending setters\n    for (const [sourceNode, newValue] of FunctionalReactive.#settersQueue.entries())\n      sourceNode.#applyUpdate(newValue)\n    FunctionalReactive.#settersQueue.clear()\n\n    // Iterate down the depths, ignoring holes\n    // Note that both the queue (Array) and each depth Set iterators update as items are added\n    for (const depthSet of FunctionalReactive.#derivativesQueue) if (depthSet)\n      for (const derivative of depthSet)\n        derivative.#applyUpdate(\n          attempt(() =>\n            derivative.#f()\n          )\n        )\n\n    FunctionalReactive.#derivativesQueue.length = 0\n\n    // Call all reactions now that the graph has a fully consistent state\n    for (const reaction of FunctionalReactive.#reactionsQueue)\n      attempt(reaction)\n    FunctionalReactive.#reactionsQueue.length = 0\n  }\n}\n\ntype R = {\n  /**\n   * An initially undefined source node\n   */\n  <T>(): SourceNode<T | undefined>\n\n  /**\n   * A source node\n   */\n  <T>(value: T, options?: ReactiveOptions<T>): SourceNode<T>\n\n  /**\n   * A derived node\n   */\n  <T>(\n    dependencies: ReadonlyArray<FunctionalReactive<unknown>>,\n    f: () => T,\n    options?: ReactiveOptions<T>\n  ): DerivativeNode<T>\n}\n/**\n * A convenient wrapper for FunctionalReactive\n */\nexport const r: R = <T extends unknown>(\n  xOrDependencies?: T | ReadonlyArray<FunctionalReactive<unknown>>,\n  optionsOrF?: ReactiveOptions<T> | (() => T),\n  options?: ReactiveOptions<T>\n) =>\n  // @ts-ignore\n  new FunctionalReactive(xOrDependencies, optionsOrF, options)\n\ntype ReactiveDo = {\n  /**\n   * Calls the given function with the reactive's value whenever it changes\n   * @returns a function that stops the reactions\n   */\n  <T>(\n    reactive: Reactive<T>,\n    f: (value: T) => unknown\n  ): StopReacting\n\n  /**\n   * Calls the given function with the value once\n   */\n  <T>(\n    value: Unreactive<T>,\n    f: (value: Unreactive<T>) => unknown\n  ): undefined\n\n  /**\n   * If the value is not reactive, it calls the given function with that value once.\n   * If it is a reactive value, it calls the given function with the reactive's value whenever it changes.\n   * @returns a function that stops the reactions, if the value is reactive\n   */\n  <T>(\n    x: MaybeReactive<T>,\n    f: (value: T) => unknown\n  ): StopReacting | undefined\n}\n/**\n * Do something with a value, updating if it is reactive\n */\nexport const reactiveDo: ReactiveDo = <T extends unknown>(\n  x: MaybeReactive<T>,\n  f: (value: T) => unknown\n): any => {\n  if (isReactive(x)) {\n    f(x.value)\n    return x.addReaction(() => f(x.value))\n  }\n\n  f(x)\n}\n\nexport const flat = <T extends Unreactive>(source: NestedReactive<T>): FunctionalReactive<T> => {\n  const chain: Array<{\n    reactive: NestedReactive<T>,\n    stopReacting: StopReacting\n  }> = []\n\n  const reactive = new FunctionalReactive<T>(undefined as T)\n\n  const reaction = () => {\n    let lastInCommon: NestedReactive<T> = source\n    let i = 0\n    while (lastInCommon.value === chain[i + 1]?.reactive) {\n      lastInCommon = lastInCommon.value as NestedReactive<T>\n      i++\n    }\n\n    if (i + 1 < chain.length) {\n      for (let j = i + 1; j < chain.length; j++)\n        chain[j].stopReacting()\n\n      chain.length = i\n    }\n\n    updateChain(lastInCommon.value)\n  }\n\n  const updateChain = (newStart: T | NestedReactive<T>) => {\n    while (isReactive(newStart)) {\n      chain.push({\n        reactive: newStart,\n        stopReacting: newStart.addReaction(reaction)\n      })\n      newStart = newStart.value\n    }\n\n    const innerMost = chain[chain.length - 1].reactive as Reactive<T>\n    reactive.isEqual = (innerMost as FunctionalReactive<T>).isEqual\n    reactive.value = innerMost.value\n    FunctionalReactive.applyUpdates()\n  }\n\n  updateChain(source)\n\n  return reactive\n}\n"],"names":["this_","options"],"mappings":"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"}
+{"version":3,"file":"reactive.mjs","sources":["../src/reactive/index.mts"],"sourcesContent":["import { attempt, isSameValueZero } from \"../utils/index.mts\"\n\ninterface Observer {\n  weakRef: WeakRef<Observer>,\n  dependencies: Set<Reactive<unknown>>,\n  isDisposed: boolean,\n  markDirty: () => void\n}\n\nlet currentObserver: Observer | undefined\nconst observerStack: (Observer | undefined)[] = []\n\nconst pushObserver = (next: Observer | undefined) => {\n  observerStack.push(currentObserver)\n  currentObserver = next\n}\n\nconst popObserver = () => {\n  currentObserver = observerStack.pop()\n}\n\nconst trackWith = <T extends unknown>(observer: Observer | undefined, f: () => T): T => {\n  pushObserver(observer)\n  try {\n    return f()\n  }\n  finally {\n    popObserver()\n  }\n}\n\nexport const untrack = <T extends unknown>(f: () => T): T => {\n  return trackWith(undefined, f)\n}\n\nconst dirtyEffects = new Set<Effect>()\nlet isFlushScheduled = false\nlet isFlushing = false\n\nconst scheduleFlush = () => {\n  if (isFlushScheduled || isFlushing)\n    return\n\n  isFlushScheduled = true\n  queueMicrotask(flush)\n}\n\nexport const flush = () => {\n  if (isFlushing)\n    return\n\n  isFlushing = true\n  isFlushScheduled = false\n\n  try {\n    while (dirtyEffects.size) {\n      const wave = [...dirtyEffects]\n      dirtyEffects.clear()\n      for (const effect of wave)\n        if (!effect.isDisposed)\n          effect.run()\n    }\n  }\n  finally {\n    isFlushing = false\n  }\n}\n\ntype StopReacting = () => void\n\nexport type NonReactive<T = unknown> = T extends Reactive<any> ? never : T\n\nexport type MaybeReactive<T> = Reactive<T> | NonReactive<T>\n\nexport type NestedReactive<T extends NonReactive> = Reactive<T | NestedReactive<T>>\n\nexport type IsEqual<T> = {\n  bivarianceHack(a: T, b: T): boolean\n}[\"bivarianceHack\"]\n\nexport type SourceOptions<T> = {\n  isEqual?: IsEqual<T>\n}\n\nexport type DerivativeOptions<T> = {\n  memoKey?: () => unknown,\n  isEqual?: IsEqual<T>\n}\n\nexport type ReadonlyReactive<T> = {\n  readonly value: T,\n  peek(): T\n}\n\nexport type WritableReactive<T> = {\n  value: T,\n  peek(): T\n}\n\nexport type SourceNode<T>     = Reactive<T> & WritableReactive<T>\nexport type DerivativeNode<T> = Reactive<T> & ReadonlyReactive<T>\n\nexport type ReactiveContext = {\n  readonly isTracking: boolean,\n  readonly dependencies: ReadonlyArray<Reactive<unknown>>,\n  readonly stackDepth: number\n}\n\nexport class Reactive<T> {\n  static get context(): ReactiveContext {\n    return {\n      isTracking: currentObserver !== undefined,\n      dependencies: currentObserver ? [...currentObserver.dependencies] : [],\n      stackDepth: observerStack.length\n    }\n  }\n\n  #value: T\n  #getter?: () => T\n  #memoKey?: () => unknown\n  #lastMemoKey?: unknown\n  #isEqual: IsEqual<T> = isSameValueZero\n  #dependencies = new Set<Reactive<unknown>>()\n  #observers = new Set<WeakRef<Observer>>()\n  #isDirty = false\n  #isComputing = false\n\n  #ownObserver: Observer\n\n  private constructor(\n    options: (\n      {\n        value: T\n      } |\n      {\n        memoKey?: () => unknown,\n        getter: () => T\n      }\n    ) & {\n      isEqual?: IsEqual<T>\n    }\n  ) {\n    this.#ownObserver = {\n      dependencies: this.#dependencies,\n      isDisposed: false,\n      weakRef: undefined!,\n      markDirty: () => {\n        if (this.#isDirty)\n          return\n\n        this.#isDirty = true\n        this.#markObserversDirty()\n      }\n    }\n    this.#ownObserver.weakRef = new WeakRef(this.#ownObserver)\n\n    if (\"getter\" in options) {\n      this.#memoKey = options.memoKey\n      this.#getter = options.getter\n      this.#isDirty = true\n      this.#value = undefined as T\n    }\n    else {\n      this.#value = options.value\n    }\n\n    if (options.isEqual)\n      this.#isEqual = options.isEqual\n  }\n\n  static source<T>(value: T, options?: SourceOptions<T>): SourceNode<T> {\n    return new Reactive({\n      value,\n      isEqual: options?.isEqual\n    })\n  }\n\n  static derived<T>(getter: () => T, options?: DerivativeOptions<T>): DerivativeNode<T> {\n    const result = new Reactive({\n      getter,\n      memoKey: options?.memoKey,\n      isEqual: options?.isEqual\n    })\n    result.#compute()\n    return result\n  }\n\n  peek() {\n    if (this.#isDirty)\n      this.#compute()\n\n    return this.#value\n  }\n\n  get value() {\n    this.#trackAccess()\n\n    return this.peek()\n  }\n\n  set value(next: T) {\n    if (this.#getter)\n      throw new Error(\"Reactive value is readonly\")\n\n    if (this.#isEqual(this.#value, next))\n      return\n\n    this.#value = next\n    this.#markObserversDirty()\n  }\n\n  /**\n   * @internal\n   */\n  removeObserver(observer: Observer) {\n    this.#observers.delete(observer.weakRef)\n  }\n\n  #trackAccess() {\n    if (!currentObserver)\n      return\n\n    this.#observers.add(currentObserver.weakRef)\n    currentObserver.dependencies.add(this)\n  }\n\n  #markObserversDirty() {\n    for (const ref of this.#observers) {\n      const observer = ref.deref()\n      if (observer)\n        observer.markDirty()\n      else\n        this.#observers.delete(ref)\n    }\n  }\n\n  #clearDependencies() {\n    for (const dependency of this.#dependencies)\n      dependency.removeObserver(this.#ownObserver)\n\n    this.#dependencies.clear()\n  }\n\n  #compute() {\n    if (!this.#getter || !this.#isDirty)\n      return\n\n    if (this.#isComputing)\n      throw new Error(\"Cycle detected while computing derivation\")\n\n    this.#isComputing = true\n    this.#isDirty = false\n    this.#clearDependencies()\n\n    try {\n      if (this.#memoKey) {\n        const key = trackWith(this.#ownObserver, this.#memoKey)\n        if (isSameValueZero(key, this.#lastMemoKey))\n          return\n        this.#lastMemoKey = key\n      }\n\n      const next = trackWith(this.#ownObserver, this.#getter)\n      const changed = !this.#isEqual(this.#value, next)\n      if (changed)\n        this.#value = next\n    }\n    catch (e) {\n      console.error(e)\n    }\n    finally {\n      this.#isComputing = false\n    }\n  }\n}\n\ntype Cleanup = () => void\n\nconst activeEffects = new Set<Effect>()\n\nclass Effect implements Observer {\n  weakRef = new WeakRef(this)\n  dependencies = new Set<Reactive<unknown>>()\n  isDisposed = false\n\n  #f: () => void | Cleanup\n  #cleanup?: () => void\n\n  constructor(f: () => void | Cleanup) {\n    this.#f = f\n\n    activeEffects.add(this)\n\n    this.markDirty()\n  }\n\n  markDirty() {\n    if (this.isDisposed)\n      return\n\n    dirtyEffects.add(this)\n    scheduleFlush()\n  }\n\n  run() {\n    if (this.isDisposed)\n      return\n\n    if (this.#cleanup) {\n      attempt(this.#cleanup)\n      this.#cleanup = undefined\n    }\n\n    for (const dependency of this.dependencies)\n      dependency.removeObserver(this)\n    this.dependencies.clear()\n\n    const result = trackWith(this, () => attempt(this.#f))\n    if (typeof result === \"function\")\n      this.#cleanup = result\n  }\n\n  dispose() {\n    if (this.isDisposed)\n      return\n\n    this.isDisposed = true\n\n    activeEffects.delete(this)\n\n    dirtyEffects.delete(this)\n\n    if (this.#cleanup)\n      attempt(this.#cleanup)\n\n    for (const dependency of this.dependencies)\n      dependency.removeObserver(this)\n    this.dependencies.clear()\n  }\n}\n\ntype WatchOptionsAuto = {\n}\n\ntype WatchOptionsExplicit = {\n  skipFirst?: boolean\n}\n\ntype Watch = {\n  /**\n   * Auto-tracking effect: tracks all .value reads in the callback\n   */\n  (f: () => void | Cleanup, options?: WatchOptionsAuto): StopReacting\n\n  /**\n   * Explicit dependency effect: tracks only the specified dependencies,\n   * runs the callback untracked when any dependency changes\n   */\n  <Dependencies extends ReadonlyArray<Reactive<unknown>>>(\n    dependencies: Dependencies | (() => Dependencies),\n    f: () => void | Cleanup,\n    options?: WatchOptionsExplicit\n  ): StopReacting\n}\n\nexport const watch: Watch = <\n  Dependencies extends ReadonlyArray<Reactive<unknown>>\n>(\n  fOrDependencies: (() => void | Cleanup) | Dependencies | (() => Dependencies),\n  fOrOptions?: (() => void | Cleanup) | WatchOptionsAuto,\n  options?: WatchOptionsExplicit\n): StopReacting => {\n  // Auto-tracking mode: watch(f) or watch(f, options)\n  if (typeof fOrDependencies === \"function\" && (fOrOptions === undefined || typeof fOrOptions !== \"function\")) {\n    const f = fOrDependencies as () => void | Cleanup\n    const options = fOrOptions\n\n    const effect = new Effect(f)\n    return () => {\n      effect.dispose()\n    }\n  }\n\n  // Explicit dependencies mode: watch(dependencies, f, options?)\n  const dependenciesOrGet = fOrDependencies as Dependencies | (() => Dependencies)\n  const f = fOrOptions as () => void | Cleanup\n\n  let isFirst = true\n  const effect = new Effect(() => {\n    const dependencies =\n      typeof dependenciesOrGet === \"function\"\n        ? untrack(dependenciesOrGet)\n        : dependenciesOrGet\n    for (const dependency of dependencies)\n      dependency.value\n\n    if (isFirst) {\n      isFirst = false\n      if (options?.skipFirst)\n        return\n    }\n\n    return untrack(f)\n  })\n  return () => {\n    effect.dispose()\n  }\n}\n\ntype R = {\n  /**\n   * A derived node with auto-tracking\n   */\n  <T>(\n    f: () => T,\n    options?: DerivativeOptions<T>\n  ): DerivativeNode<T>\n\n  /**\n   * A derived node with explicit dependencies:\n   * tracks only the specified dependencies, runs the getter untracked\n   */\n  <T, Dependencies extends ReadonlyArray<Reactive<unknown>>>(\n    dependencies: Dependencies | (() => Dependencies),\n    f: () => T,\n    options?: DerivativeOptions<T>\n  ): DerivativeNode<T>\n\n  /**\n   * An initially undefined source node\n   */\n  <T>(): SourceNode<T | undefined>\n\n  /**\n   * A source node\n   */\n  <T>(value: T, options?: SourceOptions<T>): SourceNode<T>\n}\n/**\n * A convenient wrapper for Reactive\n */\nexport const r: R = <T extends unknown, Dependencies extends ReadonlyArray<Reactive<unknown>>>(\n  xOrFOrDependencies?: T | (() => T) | Dependencies | (() => Dependencies),\n  optionsOrF?: SourceOptions<T> | DerivativeOptions<T> | (() => T),\n  options?: DerivativeOptions<T>\n) => {\n  // r(dependencies, f) or r(() => dependencies, f) - explicit dependency mode\n  const isExplicit =\n    (Array.isArray(xOrFOrDependencies) || typeof xOrFOrDependencies === \"function\") &&\n    typeof optionsOrF === \"function\"\n\n  if (isExplicit) {\n    const dependenciesOrGet = xOrFOrDependencies as Dependencies | (() => Dependencies)\n    const f = optionsOrF\n\n    return Reactive.derived(() => {\n      const dependencies =\n      typeof dependenciesOrGet === \"function\"\n        ? untrack(dependenciesOrGet)\n        : dependenciesOrGet\n      for (const dependency of dependencies)\n        dependency.value\n\n      return untrack(f)\n    }, options)\n  }\n  else {\n    const options = optionsOrF as SourceOptions<T> | DerivativeOptions<T>\n\n    // r(f) - auto-tracking derived\n    if (typeof xOrFOrDependencies === \"function\") {\n      const f = xOrFOrDependencies as () => T\n\n      return Reactive.derived(f, options as DerivativeOptions<T>)\n    }\n\n    // r() or r(value) - source node\n    const x = xOrFOrDependencies as T\n\n    return Reactive.source(x, options as SourceOptions<T>)\n  }\n}\n\nexport const getValue = <T extends unknown>(x: MaybeReactive<T>) =>\n  x instanceof Reactive\n    ? x.value\n    : x\n\ntype ReactiveDo = {\n  /**\n   * Calls the given function with the reactive's value whenever it changes\n   * @returns a function that stops the reactions\n   */\n  <T>(\n    reactive: Reactive<T>,\n    f: (value: T) => unknown\n  ): StopReacting\n\n  /**\n   * Calls the given function with the value once\n   */\n  <T>(\n    value: NonReactive<T>,\n    f: (value: NonReactive<T>) => unknown\n  ): undefined\n\n  /**\n   * If the value is not reactive, it calls the given function with that value once.\n   * If it is a reactive value, it calls the given function with the reactive's value whenever it changes.\n   * @returns a function that stops the reactions, if the value is reactive\n   */\n  <T>(\n    x: MaybeReactive<T>,\n    f: (value: T) => unknown\n  ): StopReacting | undefined\n}\n/**\n * Do something with a value, updating if it is reactive\n */\nexport const reactiveDo: ReactiveDo = <T extends unknown>(\n  x: MaybeReactive<T>,\n  f: (value: T) => unknown\n): any => {\n  if (x instanceof Reactive)\n    return watch(() => {\n      const value = x.value\n      untrack(() => f(value))\n    })\n\n  f(x)\n}\n\nconst flatCache = new WeakMap<Reactive<unknown>, Reactive<unknown>>()\n\nexport const flat = <T extends unknown>(nested: NestedReactive<T>): Reactive<T> => {\n  const cached = flatCache.get(nested)\n  if (cached)\n    return cached as Reactive<T>\n\n  const derived = r(() => {\n    let cursor: unknown = nested.value\n    while (cursor instanceof Reactive)\n      cursor = cursor.value\n    return cursor as T\n  })\n\n  flatCache.set(nested, derived)\n  return derived\n}\n"],"names":["f","effect","options"],"mappings":"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"}

package/dist/types/components/misc.d.mts

@@ -0,0 +1,35 @@
+import { MaybeReactive } from '../reactive/index.mts';
+/**
+ * Prefer this over `{items.map()}`; it handles reactive and nonreactive iterables with arbitrary memo keys.
+ * Memoization is scoped by [MemoMap, ...scope], so different MemoMaps won't collide even with the same items.
+ *
+ * ```tsx
+ * <MemoMap
+ *   items={maybeReactiveItems}
+ *   scope={[maybeReactiveItems]} // Optional: defaults to [items]
+ *   getKey={item => item} // Optional: defaults to the item itself
+ * >
+ *   {item =>
+ *     <Item>{item}</Item> // Results are memoized within the scope by the key
+ *   }
+ * </MemoMap>
+ * ```
+ *
+ * If rendering the same items in multiple different views, provide distinct scopes:
+ * ```tsx
+ * <MemoMap items={users} scope={[UserCard, users]}>{...}</MemoMap>
+ * <MemoMap items={users} scope={[UserRow, users]}>{...}</MemoMap>
+ * ```
+ */
+export declare const MemoMap: <In extends unknown, Out extends unknown>({ items, scope, getKey, children: f }: {
+    items: MaybeReactive<Iterable<In>>;
+    /**
+     * Defaults to [items]
+     */
+    scope?: ReadonlyArray<unknown>;
+    /**
+     * Defaults to the item itself
+     */
+    getKey?: (x: In) => unknown;
+    children: (x: In) => Out;
+}) => import('../reactive/index.mts').DerivativeNode<Out[]>;

package/dist/types/dom/index.browser.test-d.d.mts

@@ -0,0 +1 @@
+export {};