@tschk/moonshine-svelte 0.0.0-stage → 0.4.4

package/src/each.ts

@@ -0,0 +1,306 @@
+/**
+ * Optional keyed each. Reconciliation visit/move ordering adapted from
+ * Svelte's MIT-licensed each.js (copyright 2016–2025 Svelte 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.
+ */
+import {
+  createInsertionRange,
+  insertionRangeEnd,
+  prepareInsertionRange,
+  moveInsertionRange,
+  type DOMChild,
+} from "@tschk/moonshine-dom/dom";
+import {
+  createRoot,
+  createComponentScope,
+  getOwner,
+  getRenderScheduler,
+  createSignal,
+  createRenderMemo,
+  onCleanup,
+  type Owner,
+  type Accessor,
+  type Setter,
+} from "@tschk/moonshine-dom/reactive";
+type Entry<T> = {
+  key: unknown;
+  node: Node;
+  stop: () => void;
+  scope: Owner;
+  setItem: Setter<T>;
+  setIndex: Setter<number>;
+  prev: Entry<T> | null;
+  next: Entry<T> | null;
+  fresh: boolean;
+};
+/** Source compiler-owned entry; no SSR dispatch or ordinary native policy. */
+export function keyedEach<T>(
+  read: () => ArrayLike<T> | Iterable<T> | null | undefined,
+  key: (item: T, index: number) => unknown,
+  map: (item: Accessor<T>, index: Accessor<number>) => DOMChild,
+  fallback?: () => DOMChild,
+  retain?: (node: Node) => boolean,
+): Node {
+  const parent = getOwner();
+  if (!parent || parent.disposed) throw new Error("Each requires a live owner");
+  const group = createComponentScope(() => getOwner()!);
+  const scheduler = getRenderScheduler();
+  const entries = new Map<unknown, Entry<T>>();
+  let first: Entry<T> | null = null,
+    last: Entry<T> | null = null,
+    initial = true,
+    closed = false;
+  let empty: Entry<T> | undefined;
+  let outer!: Node;
+  function unlink(row: Entry<T>) {
+    if (row.prev) row.prev.next = row.next;
+    else first = row.next;
+    if (row.next) row.next.prev = row.prev;
+    else last = row.prev;
+  }
+  function link(row: Entry<T>, prev: Entry<T> | null, next: Entry<T> | null) {
+    row.prev = prev;
+    row.next = next;
+    if (prev) prev.next = row;
+    else first = row;
+    if (next) next.prev = row;
+    else last = row;
+  }
+  function destroy(rows: Iterable<Entry<T>>) {
+    let failed = false,
+      failure: unknown;
+    for (const row of rows) {
+      unlink(row);
+      entries.delete(row.key);
+      try {
+        row.stop();
+      } catch (error) {
+        if (!failed) failure = error;
+        failed = true;
+      }
+    }
+    if (failed) throw failure;
+  }
+  function create(
+    value: T,
+    index: number,
+    id: unknown,
+    renderRow = map,
+  ): Entry<T> {
+    let stopRow: (() => void) | undefined;
+    try {
+      return createRoot((dispose) => {
+        stopRow = dispose;
+        const scope = getOwner()!;
+        const [item, setItem] = createSignal(value);
+        const [position, setIndex] = createSignal(index);
+        const build = () => {
+          const node = createInsertionRange(
+            renderRow(item, position),
+            undefined,
+            retain,
+          );
+          prepareInsertionRange(node);
+          return node;
+        };
+        const activeScheduler = getRenderScheduler();
+        const node = activeScheduler
+          ? activeScheduler.branch(build, position)
+          : build();
+        if (closed || group.disposed) {
+          dispose();
+          throw new Error("Each disposed during row setup");
+        }
+        scope.parent = group;
+        group.children.add(scope);
+        const row: Entry<T> = {
+          key: id,
+          node,
+          stop: dispose,
+          scope,
+          setItem,
+          setIndex,
+          prev: null,
+          next: null,
+          fresh: true,
+        };
+        link(row, last, null);
+        return row;
+      });
+    } catch (error) {
+      try {
+        stopRow?.();
+      } catch {}
+      throw error;
+    }
+  }
+  function stop() {
+    if (closed) return;
+    closed = true;
+    const rows = [...entries.values()];
+    if (empty) rows.push(empty);
+    empty = undefined;
+    destroy(rows);
+  }
+  onCleanup(stop);
+  const reconcile = () => {
+    if (closed) return null;
+    const input = read();
+    const items = Array.isArray(input) ? input : Array.from(input ?? []);
+    const length = items.length;
+    const keys = new Set<unknown>();
+    const preparedKeys: unknown[] = [];
+    const created: Entry<T>[] = [];
+    try {
+      for (let index = 0; index < length; index++) {
+        const value = items[index]!,
+          id = key(value, index);
+        if (keys.has(id)) throw new Error("Duplicate each key");
+        keys.add(id);
+        preparedKeys.push(id);
+        const row = entries.get(id);
+        if (row) {
+          row.setItem(() => value);
+          row.setIndex(index);
+        } else {
+          const createdRow = create(value, index, id);
+          created.push(createdRow);
+          entries.set(id, createdRow);
+        }
+      }
+      if (length && empty) {
+        const old = empty;
+        empty = undefined;
+        unlink(old);
+        old.stop();
+      }
+      if (!initial && (length > 0 || !empty)) {
+        let current = first,
+          prev: Entry<T> | null = null,
+          seen: Set<Entry<T>> | undefined;
+        let matched: Entry<T>[] = [],
+          stashed: Entry<T>[] = [];
+        for (let index = 0; index < length; index++) {
+          const id = key(items[index]!, index);
+          const prepared = preparedKeys[index];
+          if (id !== prepared && !(id !== id && prepared !== prepared))
+            throw new Error("Each key changed during reconciliation");
+          const row = entries.get(id);
+          if (!row) throw new Error("Each key changed during reconciliation");
+          if (row.fresh) {
+            row.fresh = false;
+            if (row === current) {
+              moveInsertionRange(row.node, insertionRangeEnd(outer));
+            } else {
+              const next = prev ? prev.next : current;
+              unlink(row);
+              link(row, prev, next);
+              moveInsertionRange(
+                row.node,
+                next?.node ?? insertionRangeEnd(outer),
+              );
+              prev = row;
+              matched = [];
+              stashed = [];
+              current = prev.next;
+              continue;
+            }
+          }
+          if (row !== current) {
+            if (seen?.has(row)) {
+              if (matched.length < stashed.length) {
+                const start = stashed[0]!,
+                  a = matched[0]!,
+                  b = matched[matched.length - 1]!;
+                prev = start.prev;
+                for (const part of matched)
+                  moveInsertionRange(part.node, start.node);
+                for (const part of stashed) seen.delete(part);
+                const beforeA = a.prev,
+                  afterB = b.next;
+                if (beforeA) beforeA.next = afterB;
+                else first = afterB;
+                if (afterB) afterB.prev = beforeA;
+                else last = beforeA;
+                if (prev) prev.next = a;
+                else first = a;
+                a.prev = prev;
+                b.next = start;
+                start.prev = b;
+                current = start;
+                prev = b;
+                index--;
+                matched = [];
+                stashed = [];
+              } else {
+                seen.delete(row);
+                moveInsertionRange(
+                  row.node,
+                  current?.node ?? insertionRangeEnd(outer),
+                );
+                unlink(row);
+                const next = prev === null ? first : prev.next;
+                link(row, prev, next);
+                prev = row;
+              }
+              continue;
+            }
+            matched = [];
+            stashed = [];
+            while (current && current !== row) {
+              (seen ??= new Set()).add(current);
+              stashed.push(current);
+              current = current.next;
+            }
+            if (!current) continue;
+          }
+          if (!row.fresh) matched.push(row);
+          prev = row;
+          current = row.next;
+        }
+        const removed = [...(seen ?? [])];
+        while (current) {
+          removed.push(current);
+          current = current.next;
+        }
+        destroy(removed);
+      }
+      initial = false;
+      for (const row of entries.values()) row.fresh = false;
+      if (!length && fallback && !empty)
+        empty = create(undefined as T, 0, Symbol("fallback"), () => fallback());
+      const tokens: Node[] = [];
+      for (let row = first; row; row = row.next) tokens.push(row.node);
+      // Preserve current source order for child-first owner teardown.
+      group.children.clear();
+      for (let row = first; row; row = row.next) group.children.add(row.scope);
+      scheduler?.reorder();
+      return tokens;
+    } catch (error) {
+      try {
+        destroy(created.filter((row) => entries.get(row.key) === row));
+      } catch {}
+      throw error;
+    }
+  };
+  outer = createInsertionRange(
+    reconcile,
+    scheduler ? createRenderMemo : undefined,
+    retain,
+  );
+  return outer;
+}

package/src/effect.ts

@@ -0,0 +1,243 @@
+import { isSSRRendering } from "@tschk/moonshine-dom/ssr-owner";
+/** Post-DOM native rune effects; opt-in pre/render phases live on /pre. */
+import {
+  collectDeps,
+  subscribeInvalidation,
+  type Trackable,
+} from "@tschk/moonshine/tracking";
+import {
+  createRoot,
+  getRenderScheduler,
+  getOwner,
+  onCleanup,
+  runWithOwner,
+  untrack,
+} from "@tschk/moonshine-dom/reactive";
+import { peekComponentContext } from "@tschk/moonshine-dom/component";
+import { flushComponentReferences } from "@tschk/moonshine-dom/component-instance";
+
+import { holdHistory, releaseHistory, withHistoryCleanup } from "./history";
+import { queueTickWork, removeTickWork } from "./tick-queue";
+
+const pending = new Set<() => void>();
+let scheduled = false,
+  epoch = 0;
+function flush(): void {
+  removeTickWork(flush);
+  let failed = false,
+    failure: unknown;
+  const runs = new Map<() => void, number>();
+  try {
+    while (pending.size) {
+      try {
+        flushComponentReferences();
+      } catch (error) {
+        if (!failed) failure = error;
+        failed = true;
+      }
+      if (!pending.size) break;
+      const next = pending.values().next().value!;
+      pending.delete(next);
+      const count = (runs.get(next) ?? 0) + 1;
+      runs.set(next, count);
+      if (count > 1000) {
+        if (!failed)
+          failure = new Error("Native rune effect update limit exceeded");
+        failed = true;
+        continue;
+      }
+      try {
+        next();
+      } catch (error) {
+        if (!failed) failure = error;
+        failed = true;
+      }
+    }
+  } catch (error) {
+    if (!failed) failure = error;
+    failed = true;
+  } finally {
+    scheduled = false;
+    releaseHistory();
+  }
+  if (failed) throw failure;
+}
+
+function cancel(): void {
+  pending.clear();
+  if (scheduled) flush();
+}
+
+/** Untracked, manually disposed effect scope; deliberately independent of its caller. */
+export function createRuneRoot(fn: () => void | (() => void)): () => void {
+  if (isSSRRendering() || peekComponentContext()?.mode === "ssr")
+    return () => {};
+  return createRoot((stop) => {
+    const scope = getOwner();
+    const cleanup = fn();
+    if (typeof cleanup === "function") {
+      if (getOwner()?.disposed) withHistoryCleanup(() => untrack(cleanup));
+      else onCleanup(cleanup);
+    }
+    return () => runWithOwner(scope, () => withHistoryCleanup(stop));
+  });
+}
+
+/** Initial and invalidated callbacks run in a deduplicated microtask after DOM updates. */
+export function createRuneEffect(fn: () => void | (() => void)): void {
+  const owner = getOwner();
+  if (!owner || owner.disposed)
+    throw new Error("Rune effects require a live native owner");
+  if (isSSRRendering() || peekComponentContext()?.mode === "ssr") return;
+  const scheduler = getRenderScheduler();
+  const effectPending = scheduler ? new Set<() => void>() : pending;
+  const scheduledRun = scheduler
+    ? () => {
+        effectPending.delete(run);
+        run();
+      }
+    : run;
+  let disposed = false,
+    stopRun: (() => void) | undefined;
+  let subscriptions = new Map<Trackable, () => void>();
+  let lastVersions: Map<Trackable, number> | undefined;
+  let forced = false;
+  function enqueue(): void {
+    if (disposed || owner!.disposed) return;
+    effectPending.add(run);
+    if (scheduler) {
+      scheduler.post(scheduledRun);
+      return;
+    }
+    if (!scheduled) {
+      scheduled = true;
+      holdHistory();
+      queueTickWork(flush, cancel);
+      const token = ++epoch;
+      queueMicrotask(() => {
+        if (scheduled && token === epoch) flush();
+      });
+    }
+  }
+  function run(): void {
+    if (disposed || owner!.disposed) return;
+    if (lastVersions && !forced) {
+      let changed = false;
+      runWithOwner(owner, () =>
+        untrack(() => {
+          for (const [dep, version] of lastVersions!) {
+            dep.validate?.();
+            if (dep.version !== version) changed = true;
+          }
+        }),
+      );
+      if (!changed) return;
+    }
+    forced = false;
+    const previous = stopRun;
+    stopRun = undefined;
+    if (previous) untrack(previous);
+    const cleanupInvalidated = effectPending.has(run);
+    let failed = false,
+      failure: unknown;
+    const versions = new Map<Trackable, number>();
+    let dependencies: Trackable[] = [];
+    runWithOwner(owner, () =>
+      createRoot((stop) => {
+        const scope = getOwner();
+        stopRun = () => runWithOwner(scope, () => withHistoryCleanup(stop));
+        dependencies = collectDeps(
+          () => {
+            try {
+              const cleanup = fn();
+              if (typeof cleanup === "function") {
+                if (getOwner()?.disposed)
+                  withHistoryCleanup(() => untrack(cleanup));
+                else onCleanup(cleanup);
+              }
+            } catch (error) {
+              failed = true;
+              failure = error;
+            }
+          },
+          (dependency) => versions.set(dependency, dependency.version),
+        );
+      }),
+    );
+    if (disposed || owner!.disposed) {
+      const cleanup = stopRun as (() => void) | undefined;
+      stopRun = undefined;
+      untrack(() => cleanup?.());
+      if (failed) throw failure;
+      return;
+    }
+    const next = new Map<Trackable, () => void>();
+    try {
+      untrack(() => {
+        for (const dependency of dependencies)
+          next.set(
+            dependency,
+            subscriptions.get(dependency) ??
+              subscribeInvalidation(dependency, {
+                invalidate() {},
+                notify: enqueue,
+              }),
+          );
+        for (const [dependency, unsubscribe] of subscriptions)
+          if (!next.has(dependency)) unsubscribe();
+      });
+      subscriptions = next;
+    } catch (error) {
+      for (const [dependency, unsubscribe] of next)
+        if (!subscriptions.has(dependency)) unsubscribe();
+      if (!failed) failure = error;
+      failed = true;
+    }
+    // Cleanup writes retain their queued rerun even if setup drops that dependency.
+    // Setup-only old branch invalidations are discarded; current self-writes rerun.
+    effectPending.delete(run);
+    lastVersions = versions;
+    if (cleanupInvalidated) forced = true;
+    if (
+      cleanupInvalidated ||
+      dependencies.some(
+        (dependency) => dependency.version !== versions.get(dependency),
+      )
+    )
+      enqueue();
+    if (failed) {
+      const cleanup = stopRun as (() => void) | undefined;
+      stopRun = undefined;
+      try {
+        cleanup?.();
+      } catch {
+        /* Preserve callback/subscription failure. */
+      }
+      throw failure;
+    }
+  }
+  onCleanup(() => {
+    disposed = true;
+    effectPending.delete(run);
+    let failed = false,
+      failure: unknown;
+    for (const cleanup of [
+      ...subscriptions.values(),
+      ...(stopRun ? [stopRun] : []),
+    ]) {
+      try {
+        untrack(cleanup);
+      } catch (error) {
+        if (!failed) failure = error;
+        failed = true;
+      }
+    }
+    subscriptions.clear();
+    stopRun = undefined;
+    if (failed) throw failure;
+  });
+  enqueue();
+}
+
+/** Query synchronous tracking only; ownership alone does not imply tracking. */
+export { isTracking as runeTracking } from "@tschk/moonshine/tracking";

package/src/framework.ts

@@ -0,0 +1 @@
+export { crepusRenderer } from "@tschk/moonshine-dom/framework-lazy";

package/src/history.ts

@@ -0,0 +1,104 @@
+/** Svelte teardown reads use the first values preceding the current flush. */
+import { getOwner, type Owner } from "@tschk/moonshine-dom/reactive";
+export type HistoryRead = { target: object; key: PropertyKey };
+let values = new Map<object, Map<PropertyKey, unknown>>();
+let historical = new Map<object, unknown>();
+let scheduledEpoch: number | undefined;
+let epoch = 0,
+  holds = 0,
+  mutationDepth = 0;
+let cleanupOwner: Owner | null | undefined;
+const collectors: HistoryRead[][] = [];
+function clear(): void {
+  values.clear();
+  historical.clear();
+  epoch++;
+}
+function schedule(): void {
+  if (holds || (!values.size && !historical.size) || scheduledEpoch === epoch)
+    return;
+  const expected = epoch;
+  scheduledEpoch = expected;
+  queueMicrotask(() => {
+    if (scheduledEpoch === expected) scheduledEpoch = undefined;
+    if (expected === epoch && !holds && !mutationDepth) clear();
+  });
+}
+export function holdHistory(): void {
+  holds++;
+}
+export function releaseHistory(): void {
+  if (!holds) throw new Error("Unbalanced history release");
+  if (--holds === 0 && !mutationDepth) clear();
+}
+export function withHistoryMutation<T>(fn: () => T): T {
+  mutationDepth++;
+  try {
+    return fn();
+  } finally {
+    if (--mutationDepth === 0) schedule();
+  }
+}
+export function isHistoryReading(): boolean {
+  return cleanupOwner !== undefined && cleanupOwner === getOwner();
+}
+export function withHistoryCleanup<T>(fn: () => T): T {
+  const previous = cleanupOwner;
+  cleanupOwner = getOwner();
+  try {
+    return fn();
+  } finally {
+    cleanupOwner = previous;
+    if (cleanupOwner === undefined && !mutationDepth) schedule();
+  }
+}
+export function recordHistory(
+  target: object,
+  key: PropertyKey,
+  before: unknown,
+  after: unknown,
+): void {
+  let entries = values.get(target);
+  if (!entries) values.set(target, (entries = new Map()));
+  if (isHistoryReading()) entries.set(key, after);
+  else if (!entries.has(key)) entries.set(key, before);
+}
+export function trackHistoryRead(target: object, key: PropertyKey): void {
+  for (const collector of collectors)
+    if (!collector.some((read) => read.target === target && read.key === key))
+      collector.push({ target, key });
+}
+export function readHistory<T>(
+  target: object,
+  key: PropertyKey,
+  live: () => T,
+): T {
+  trackHistoryRead(target, key);
+  const entries = values.get(target);
+  return isHistoryReading() && entries?.has(key)
+    ? (entries.get(key) as T)
+    : live();
+}
+export function collectHistoryReads<T>(fn: () => T): {
+  value: T;
+  reads: HistoryRead[];
+} {
+  const reads: HistoryRead[] = [];
+  collectors.push(reads);
+  try {
+    return { value: fn(), reads };
+  } finally {
+    collectors.pop();
+  }
+}
+export function hasHistory(reads: readonly HistoryRead[]): boolean {
+  return reads.some(
+    ({ target, key }) => values.get(target)?.has(key) || historical.has(target),
+  );
+}
+export function historicalValue<T>(token: object, compute: () => T): T {
+  if (historical.has(token)) return historical.get(token) as T;
+  const value = compute();
+  historical.set(token, value);
+  return value;
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+/** Independent store bridge; component-language parsing belongs in Crepus. */
+import {
+  createSignal as msCreateSignal,
+  type Signal as MsSignal,
+} from "@tschk/moonshine";
+import { writable, type Writable } from "./store";
+
+export type SvelteWritable<T> = Writable<T>;
+
+/** Store subscribers share one kernel subscription while they are active. */
+export function fromMoonshineSignal<T>(signal: MsSignal<T>): SvelteWritable<T> {
+  let mirrored = signal.peek();
+  const store = writable(mirrored, (set) => {
+    mirrored = signal.peek();
+    set(mirrored);
+    return signal.subscribe(() => {
+      const current = signal.peek();
+      if (!Object.is(mirrored, current)) {
+        mirrored = current;
+        set(current);
+      }
+    });
+  });
+  function set(next: T): void {
+    const previous = signal.peek();
+    signal.set(() => next);
+    const current = signal.peek();
+    // Preserve store object notifications without duplicating deferred kernel writes.
+    if (Object.is(previous, current) || !Object.is(mirrored, current)) {
+      mirrored = current;
+      store.set(current);
+    }
+  }
+  return {
+    subscribe: store.subscribe,
+    set,
+    update: (fn) => set(fn(signal.peek())),
+  };
+}
+
+export function createBridgedWritable<T>(initial: T): SvelteWritable<T> {
+  return fromMoonshineSignal(msCreateSignal(initial));
+}
+
+export { msCreateSignal as createMoonshineSignal };
+export type { MsSignal as MoonshineSignal };
+export {
+  createResource,
+  createSignal as createMsSignal,
+  createMemo,
+  batch,
+  untrack,
+} from "@tschk/moonshine";
+export type { Resource, ResourceStatus } from "@tschk/moonshine";
+export { crepusRenderer } from "./framework";