@tschk/moonshine-svelte 0.0.0-stage → 0.4.4

package/src/store-binding.ts

@@ -0,0 +1,125 @@
+/** Component-owned store reads; compiler owns assignments and mutation lowering. */
+import {
+  createSignal,
+  getOwner,
+  onAfterDispose,
+  onCleanup,
+  runWithOwner,
+  untrack,
+} from "@tschk/moonshine-dom/reactive";
+import { subscribeTo, changed } from "./store-internal";
+import { withHistoryMutation, recordHistory, readHistory } from "./history";
+export {
+  setStoreValue,
+  mutateStoreValue,
+  updateStoreValue,
+} from "./store-write";
+export type StoreSource<T> = {
+  subscribe(
+    run: (value: T) => void,
+  ): void | (() => void) | { unsubscribe(): void };
+};
+export type StoreReference<T> = {
+  get(store: StoreSource<T> | null | undefined): T | undefined;
+  releaseIfChanged<S extends StoreSource<T> | null | undefined>(store: S): S;
+  /** Compiler calls this at the end of successful instance setup. */
+  finish(): void;
+};
+const noop = () => {};
+export function createStoreReference<T>(): StoreReference<T> {
+  const owner = getOwner();
+  if (!owner || owner.disposed)
+    throw Error("Store references require a live native owner");
+  let store: StoreSource<T> | null = null,
+    current: T | undefined,
+    stop: () => void = noop,
+    closed = false,
+    finished = false,
+    releasing = false;
+  const [version, bump] = createSignal(0);
+  function release() {
+    const previous = stop;
+    stop = noop;
+    const outer = releasing;
+    releasing = true;
+    try {
+      previous();
+    } finally {
+      releasing = outer;
+    }
+  }
+  function temporary(next: StoreSource<T> | null | undefined): T | undefined {
+    if (next == null) return undefined;
+    let value: T | undefined;
+    const unsubscribe = untrack(() => subscribeTo(next, (v) => (value = v)));
+    unsubscribe();
+    return value;
+  }
+  function close() {
+    if (closed) return;
+    closed = true;
+    release();
+  }
+  // A setup exception before finish() must still release acquired subscriptions.
+  onAfterDispose(close);
+  return {
+    get(next) {
+      // Unsubscribe reads cannot replace the subscription currently being released.
+      if (releasing)
+        return store === (next ?? null)
+          ? readHistory(version, "value", () => current)
+          : temporary(next);
+      if (closed || (owner.disposed && !owner.disposing)) {
+        if (next == null) return current;
+        return temporary(next);
+      }
+      if (store !== next) {
+        release();
+        if (closed || (owner.disposed && !owner.disposing))
+          return next == null ? current : temporary(next);
+        store = next ?? null;
+        if (!next) current = undefined;
+        else {
+          let synchronous = true,
+            active = true,
+            unsubscribe: (() => void) | undefined;
+          stop = () => {
+            active = false;
+            unsubscribe?.();
+          };
+          unsubscribe = untrack(() =>
+            subscribeTo(next, (value) => {
+              if (!active || closed || (owner.disposed && !owner.disposing))
+                return;
+              const previous = current;
+              if (synchronous || !changed(previous, value)) {
+                current = value;
+                return;
+              }
+              withHistoryMutation(() => {
+                recordHistory(version, "value", previous, value);
+                current = value;
+                if (!owner.disposed) bump((v) => v + 1);
+              });
+            }),
+          );
+          synchronous = false;
+          if (!active || closed || (owner.disposed && !owner.disposing))
+            unsubscribe();
+        }
+      }
+      version();
+      return readHistory(version, "value", () => current);
+    },
+    finish() {
+      if (finished) return;
+      finished = true;
+      if (owner.disposed) close();
+      else runWithOwner(owner, () => onCleanup(close));
+    },
+    releaseIfChanged(next) {
+      if (store !== next) release();
+      return next;
+    },
+  };
+}

package/src/store-internal.ts

@@ -0,0 +1,34 @@
+import type { Subscriber, Unsubscriber } from "./store";
+/** Observable subscriptions may return an object whose method needs its receiver. */
+export function subscribeTo<T>(
+  store: { subscribe(run: Subscriber<T>, invalidate?: () => void): unknown },
+  run: Subscriber<T>,
+  invalidate?: () => void,
+): Unsubscriber {
+  const subscription: unknown = store.subscribe(run, invalidate);
+  let active = true;
+  return () => {
+    if (!active) return;
+    active = false;
+    if (typeof subscription === "function") subscription();
+    else if (
+      subscription &&
+      typeof subscription === "object" &&
+      "unsubscribe" in subscription &&
+      typeof subscription.unsubscribe === "function"
+    )
+      subscription.unsubscribe();
+    else if (subscription !== undefined)
+      throw new TypeError(
+        "Store subscription must return a function or unsubscribe object",
+      );
+  };
+}
+
+export function changed<T>(previous: T, next: T): boolean {
+  return previous !== previous
+    ? next === next
+    : previous !== next ||
+        (previous !== null && typeof previous === "object") ||
+        typeof previous === "function";
+}

package/src/store-write.ts

@@ -0,0 +1,38 @@
+import type { StoreSource } from "./store-binding.js";
+export interface WritableStoreSource<T> extends StoreSource<T> {
+  set(value: T): void;
+}
+export function setStoreValue<T, V extends T>(
+  store: WritableStoreSource<T>,
+  value: V,
+): V {
+  store.set(value);
+  return value;
+}
+export function mutateStoreValue<T, R>(
+  store: WritableStoreSource<T>,
+  expression: R,
+  payload: NoInfer<T>,
+): R {
+  store.set(payload);
+  return expression;
+}
+export function updateStoreValue<T>(
+  store: WritableStoreSource<T>,
+  old: NoInfer<T>,
+  delta: 1 | -1,
+  prefix: boolean,
+): T {
+  // Svelte's store update helpers use addition, including its string/BigInt behavior.
+  const value = ((old as unknown as number) + delta) as T;
+  store.set(value);
+  return prefix ? value : old;
+}
+export function mutateServerStore<T, R>(
+  reference: { get(store: StoreSource<T>): T | undefined },
+  store: WritableStoreSource<T>,
+  expression: R,
+): R {
+  store.set(reference.get(store)!);
+  return expression;
+}

package/src/store.ts

@@ -0,0 +1,208 @@
+/** Independent synchronous Svelte store protocol; no component runtime needed. */
+import { subscribeTo, changed } from "./store-internal";
+export type Subscriber<T> = (value: T) => void;
+export type Invalidator<T> = (value?: T) => void;
+export type Unsubscriber = () => void;
+export type Updater<T> = (value: T) => T;
+export type StartStopNotifier<T> = (
+  set: (value: T) => void,
+  update: (fn: Updater<T>) => void,
+) => void | Unsubscriber;
+export interface Readable<T> {
+  subscribe(run: Subscriber<T>, invalidate?: Invalidator<T>): Unsubscriber;
+}
+export interface Writable<T> extends Readable<T> {
+  set(value: T): void;
+  update(fn: Updater<T>): void;
+}
+type Subscription<T> = { run: Subscriber<T>; invalidate: Invalidator<T> };
+const notifications: Array<() => void> = [];
+const noop = () => {};
+
+export function writable<T>(
+  initial?: T,
+  start: StartStopNotifier<T> = noop,
+): Writable<T> {
+  let value = initial as T;
+  let stop: Unsubscriber | undefined;
+  const subscribers = new Set<Subscription<T>>();
+  function set(next: T): void {
+    if (!changed(value, next)) return;
+    value = next;
+    if (!stop) return;
+    const flush = notifications.length === 0;
+    let failure: unknown;
+    let failed = false;
+    for (const subscriber of subscribers) {
+      try {
+        subscriber.invalidate();
+      } catch (error) {
+        if (!failed) failure = error;
+        failed = true;
+      }
+      const current = value;
+      notifications.push(() => subscriber.run(current));
+    }
+    if (flush) {
+      try {
+        for (let index = 0; index < notifications.length; index++) {
+          try {
+            notifications[index]!();
+          } catch (error) {
+            if (!failed) failure = error;
+            failed = true;
+          }
+        }
+      } finally {
+        notifications.length = 0;
+      }
+    }
+    if (failed) throw failure;
+  }
+  const update = (fn: Updater<T>) => set(fn(value));
+  function subscribe(
+    run: Subscriber<T>,
+    invalidate: Invalidator<T> = noop,
+  ): Unsubscriber {
+    const subscriber = { run, invalidate };
+    subscribers.add(subscriber);
+    try {
+      if (subscribers.size === 1) stop = start(set, update) || noop;
+      run(value);
+    } catch (error) {
+      subscribers.delete(subscriber);
+      if (!subscribers.size) {
+        const cleanup = stop;
+        stop = undefined;
+        try {
+          cleanup?.();
+        } catch {
+          /* Preserve subscription failure. */
+        }
+      }
+      throw error;
+    }
+    return () => {
+      if (!subscribers.delete(subscriber)) return;
+      if (!subscribers.size) {
+        const cleanup = stop;
+        stop = undefined;
+        cleanup?.();
+      }
+    };
+  }
+  return { subscribe, set, update };
+}
+
+export function readable<T>(
+  initial?: T,
+  start?: StartStopNotifier<T>,
+): Readable<T> {
+  return { subscribe: writable(initial, start).subscribe };
+}
+
+type Stores = Readable<any> | readonly Readable<any>[];
+type Values<S> =
+  S extends Readable<infer T>
+    ? T
+    : { [K in keyof S]: S[K] extends Readable<infer T> ? T : never };
+export function derived<S extends Stores, T>(
+  stores: S,
+  fn: (values: Values<S>) => T,
+  initial?: T,
+): Readable<T>;
+export function derived<S extends Stores, T>(
+  stores: S,
+  fn: (
+    values: Values<S>,
+    set: (value: T) => void,
+    update: (fn: Updater<T>) => void,
+  ) => void | Unsubscriber,
+  initial?: T,
+): Readable<T>;
+export function derived<S extends Stores, T>(
+  stores: S,
+  fn: (
+    values: Values<S>,
+    set: (value: T) => void,
+    update: (fn: Updater<T>) => void,
+  ) => T | void | Unsubscriber,
+  initial?: T,
+): Readable<T> {
+  const multiple = Array.isArray(stores);
+  const inputs = (multiple ? stores : [stores]) as readonly Readable<unknown>[];
+  if (!inputs.every((store) => store && typeof store.subscribe === "function"))
+    throw new TypeError("derived expects readable stores");
+  const automatic = fn.length < 2;
+  return readable(initial, (set, update) => {
+    const values: unknown[] = [];
+    const pending = new Set<number>();
+    const subscriptions: Unsubscriber[] = [];
+    let active = false;
+    let cleanup: Unsubscriber = noop;
+    function sync(): void {
+      if (pending.size) return;
+      const previous = cleanup;
+      cleanup = noop;
+      previous();
+      const result = fn(
+        (multiple ? values : values[0]) as Values<S>,
+        set,
+        update,
+      );
+      if (automatic) set(result as T);
+      else if (typeof result === "function") cleanup = result as Unsubscriber;
+    }
+    function release(): void {
+      active = false;
+      let failed = false;
+      let failure: unknown;
+      for (const unsubscribe of [...subscriptions, cleanup]) {
+        try {
+          unsubscribe();
+        } catch (error) {
+          if (!failed) failure = error;
+          failed = true;
+        }
+      }
+      subscriptions.length = 0;
+      cleanup = noop;
+      if (failed) throw failure;
+    }
+    try {
+      inputs.forEach((store, index) =>
+        subscriptions.push(
+          subscribeTo(
+            store,
+            (value) => {
+              values[index] = value;
+              pending.delete(index);
+              if (active) sync();
+            },
+            () => {
+              pending.add(index);
+            },
+          ),
+        ),
+      );
+      active = true;
+      sync();
+    } catch (error) {
+      try {
+        release();
+      } catch {
+        /* Preserve derivation failure. */
+      }
+      throw error;
+    }
+    return release;
+  });
+}
+
+export function get<T>(store: Readable<T>): T {
+  let value!: T;
+  subscribeTo(store, (current) => {
+    value = current;
+  })();
+  return value;
+}

package/src/svelte.ts

@@ -0,0 +1,152 @@
+import { rawSSRRegistrar, type Registrar } from "./raw-ssr-lifecycle";
+import { isSSRRendering } from "@tschk/moonshine-dom/ssr-owner";
+import {
+  captureSSRRenderAttempt,
+  isSSRRenderAccepted,
+} from "@tschk/moonshine-dom/ssr-attempt";
+import {
+  componentEvents,
+  getComponentContext,
+  peekComponentContext,
+  getContext as nativeGetContext,
+  setContext as nativeSetContext,
+  hasContext as nativeHasContext,
+} from "@tschk/moonshine-dom/component";
+import { createRuneEffect } from "./effect";
+import { drainTickWork } from "./tick-queue";
+import { withHistoryCleanup } from "./history";
+
+/** Source snippet parameters; compiled render cells are private to Crepus. */
+export type Snippet<Parameters extends unknown[] = []> = (
+  ...args: number extends Parameters["length"] ? never : Parameters
+) => unknown;
+
+/** Native owner lifecycle helpers; Svelte compiler output is not supported. */
+import {
+  assertNotCleanupComputation,
+  getOwner,
+  onCleanup,
+  runWithOwner,
+  untrack,
+} from "@tschk/moonshine-dom/reactive";
+
+function componentOwner(hook: string) {
+  assertNotCleanupComputation();
+  const owner = getOwner();
+  const frame = peekComponentContext();
+  if (!owner || owner.disposed || (frame && !frame.active))
+    throw new Error(
+      `${hook} must be called during native component initialization`,
+    );
+  return owner;
+}
+
+export function onMount(fn: () => unknown): void {
+  componentOwner("onMount");
+  if (isSSRRendering() || peekComponentContext()?.mode === "ssr") return;
+  createRuneEffect(() => {
+    const cleanup = untrack(fn);
+    if (typeof cleanup === "function") return cleanup as () => void;
+  });
+}
+
+export function onDestroy(fn: () => void): void {
+  const owner = componentOwner("onDestroy");
+  const server = isSSRRendering() || peekComponentContext()?.mode === "ssr";
+  const registrar = getOwner()?.context?.get(rawSSRRegistrar) as
+    Registrar | undefined;
+  if (server && registrar && registrar.consumer === peekComponentContext()) {
+    registrar.register(fn);
+    return;
+  }
+  const attempt = server ? captureSSRRenderAttempt() : undefined;
+  const cleanup = server
+    ? () => {
+        if (isSSRRenderAccepted(attempt)) fn();
+      }
+    : () => runWithOwner(owner, () => withHistoryCleanup(fn));
+  // Server hooks belong to the authored component, not compiler memo scopes.
+  const consumer = server ? peekComponentContext()?.owner : undefined;
+  runWithOwner(consumer ?? owner, () => onCleanup(cleanup));
+}
+
+/** Commit pending native rune work; future promise/timer updates are separate. */
+export async function tick(): Promise<void> {
+  await Promise.resolve();
+  drainTickWork();
+}
+
+export type EventDispatcher<EventMap extends Record<string, any>> = <
+  Type extends keyof EventMap,
+>(
+  type: Type,
+  ...args: undefined extends EventMap[Type]
+    ? [detail?: EventMap[Type], options?: { cancelable?: boolean }]
+    : null extends EventMap[Type]
+      ? [detail?: EventMap[Type], options?: { cancelable?: boolean }]
+      : [detail: EventMap[Type], options?: { cancelable?: boolean }]
+) => boolean;
+
+export function createEventDispatcher<
+  EventMap extends Record<string, any> = any,
+>(): EventDispatcher<EventMap> {
+  const frame = getComponentContext();
+  return ((
+    type: string,
+    detail?: unknown,
+    options?: { cancelable?: boolean },
+  ) => {
+    if (frame.owner.disposed) return true;
+    return untrack(() => {
+      const props = frame.props;
+      if (!props || (typeof props !== "object" && typeof props !== "function"))
+        return true;
+      const events = Reflect.get(props, componentEvents);
+      if (!events || !Object.hasOwn(events, type)) return true;
+      const listeners = events[type];
+      if (listeners == null) return true;
+      const callbacks = Array.isArray(listeners)
+        ? listeners.slice()
+        : [listeners];
+      if (!callbacks.every((listener) => typeof listener === "function"))
+        throw new TypeError("Component event listeners must be functions");
+      const event = new CustomEvent(type, {
+        detail,
+        cancelable: options?.cancelable ?? false,
+        bubbles: false,
+      });
+      // Native function components have no legacy exported-instance `this`.
+      for (const callback of callbacks)
+        Reflect.apply(callback, undefined, [event]);
+      return !event.defaultPrevented;
+    });
+  }) as EventDispatcher<EventMap>;
+}
+
+export function getContext<T>(key: unknown): T {
+  return nativeGetContext<T>(key) as T;
+}
+export function setContext<T>(key: unknown, value: T): T {
+  return nativeSetContext(key, value);
+}
+export function hasContext(key: unknown): boolean {
+  return nativeHasContext(key);
+}
+/** The live per-instance map, including inherited entries. */
+export function getAllContexts<T extends Map<any, any> = Map<any, any>>(): T {
+  return getComponentContext().contexts as T;
+}
+export function createContext<T>(): [() => T, (value: T) => T, () => boolean] {
+  const key = Symbol("svelte-context");
+  return [
+    () => {
+      if (!hasContext(key))
+        throw new Error(
+          "Context has not been set in this component or its ancestors",
+        );
+      return getContext<T>(key);
+    },
+    (value) => setContext(key, value),
+    () => hasContext(key),
+  ];
+}

package/src/tick-queue.ts

@@ -0,0 +1,31 @@
+/** Private coordination of the optional rune queues; no kernel scheduling policy. */
+const pending = /* @__PURE__ */ new Map<() => void, () => void>();
+
+export function queueTickWork(run: () => void, cancel: () => void): void {
+  pending.set(run, cancel);
+}
+export function removeTickWork(run: () => void): void {
+  pending.delete(run);
+}
+export function drainTickWork(): void {
+  const counts = new Map<() => void, number>();
+  let failed = false,
+    failure: unknown;
+  while (pending.size) {
+    const [run, cancel] = pending.entries().next().value!;
+    pending.delete(run);
+    const count = (counts.get(run) ?? 0) + 1;
+    counts.set(run, count);
+    try {
+      if (count > 1000) {
+        if (!failed) failure = Error("Native tick update limit exceeded");
+        failed = true;
+        cancel();
+      } else run();
+    } catch (error) {
+      if (!failed) failure = error;
+      failed = true;
+    }
+  }
+  if (failed) throw failure;
+}