@tschk/moonshine-svelte 0.0.0-stage → 0.4.4

package/src/prop.ts

@@ -0,0 +1,64 @@
+/** Compiler-facing prop cells; binding declaration checks belong to the compiler. */
+import { untrack } from "@tschk/moonshine";
+import { peekComponentContext } from "@tschk/moonshine-dom/component";
+import { createDerived } from "./derived";
+import { createState } from "./state";
+
+export function createProp<T>(
+  props: object,
+  key: PropertyKey,
+  options: {
+    bindable?: boolean;
+    fallback?: () => T;
+    mode?: "dom" | "ssr";
+  } = {},
+): { get value(): T; set value(value: T) } {
+  const mode = options.mode ?? peekComponentContext()?.mode ?? "dom";
+  const setter = options.bindable
+    ? Object.getOwnPropertyDescriptor(props, key)?.set
+    : undefined;
+  // Svelte 5.57 rune defaults are lazy derived values, independent of local
+  // prop overrides and reused across defined/undefined parent phases.
+  const fallbackCell = options.fallback
+    ? createDerived(options.fallback)
+    : undefined;
+  function fallback(): T {
+    return fallbackCell?.value as T;
+  }
+  const initial = untrack(() => Reflect.get(props, key));
+  if (initial === undefined && options.fallback) {
+    const value = fallback();
+    if (setter) {
+      if (mode === "dom")
+        throw new Error(
+          `Bound prop ${String(key)} cannot be undefined when it has a fallback`,
+        );
+      if (value !== undefined)
+        untrack(() => Reflect.apply(setter, props, [value]));
+    }
+  }
+  function read(): T {
+    const value = Reflect.get(props, key);
+    if (value === undefined) return fallback();
+    return value as T;
+  }
+  if (setter)
+    return {
+      get value() {
+        return read();
+      },
+      set value(value: T) {
+        untrack(() => Reflect.apply(setter, props, [value]));
+      },
+    };
+  const local = createDerived(read);
+  return {
+    get value() {
+      return local.value;
+    },
+    set value(value: T) {
+      const next = options.bindable ? createState(value).value : value;
+      local.value = next;
+    },
+  };
+}

package/src/raw-snippet-dom.ts

@@ -0,0 +1,214 @@
+import {
+  renderSchedulerKey,
+  type RenderScheduler,
+} from "@tschk/moonshine-dom/render-scheduler";
+import {
+  isRawSnippet,
+  getRawSnippetFactory,
+  type RawSnippet,
+} from "./raw-snippet";
+import { insertedNode } from "@tschk/moonshine-dom/dom";
+import { rawHTML } from "@tschk/moonshine-dom/html";
+import {
+  withComponentConsumer,
+  type ComponentContext,
+} from "@tschk/moonshine-dom/component";
+import {
+  createRoot,
+  getOwner,
+  onCleanup,
+  onBeforeDispose,
+  runWithOwner,
+  untrack,
+  type Owner,
+} from "@tschk/moonshine-dom/reactive";
+type Cell<T> = { readonly value: T };
+export function invokeRawDOM<P extends unknown[]>(
+  snippet: RawSnippet<P>,
+  cells: { [K in keyof P]: Cell<P[K]> },
+  frame: ComponentContext,
+  initial: boolean,
+  consumerScheduler: RenderScheduler | undefined,
+) {
+  const factory = getRawSnippetFactory(snippet);
+  const invocation = getOwner();
+  if (!invocation || invocation.disposed || frame.owner.disposed)
+    throw Error("Raw snippet requires live authored consumer");
+  const lifetime = initial ? frame.owner : invocation;
+  let work: Owner | undefined,
+    stopWork: () => void = () => {},
+    element: Element | undefined,
+    done = false,
+    branchClosed = false,
+    returned: (() => void) | undefined;
+  const activate = <T>(fn: () => T): T =>
+    withComponentConsumer(frame, () => untrack(fn));
+  const finish = () => {
+    branchClosed = true;
+    element?.remove();
+    const cleanup = returned;
+    returned = undefined;
+    try {
+      cleanup?.();
+    } finally {
+      if (!done) stopWork();
+    }
+  };
+  onCleanup(finish);
+  const result = createRoot((stop) => {
+    stopWork = stop;
+    work = getOwner()!;
+    if (initial) {
+      // Initial setup effects belong to the consumer's post group, not this branch.
+      work.context = new Map(work.context);
+      if (consumerScheduler)
+        work.context.set(renderSchedulerKey, consumerScheduler);
+      else work.context.delete(renderSchedulerKey);
+      runWithOwner(lifetime, () => onCleanup(stopWork));
+    }
+    const rendered = activate(() =>
+      factory(
+        ...(cells.map((cell) => () => cell.value) as {
+          [K in keyof P]: () => P[K];
+        }),
+      ),
+    );
+    const html = activate(() => rendered.render().trim()),
+      nodes = rawHTML(() => html)();
+    if (nodes.length !== 1 || !(nodes[0] instanceof Element))
+      throw TypeError("Raw snippet render requires one element");
+    element = nodes[0];
+    onBeforeDispose(() => element?.remove());
+    Object.defineProperty(element, insertedNode, {
+      configurable: true,
+      value: () => {
+        if (invocation.disposed || lifetime.disposed || work!.disposed) {
+          element!.remove();
+          stopWork();
+          return;
+        }
+        if (!initial) {
+          work!.parent = lifetime;
+          lifetime.children.add(work!);
+        }
+        try {
+          const cleanup = runWithOwner(work!, () =>
+            activate(() => rendered.setup?.(element!)),
+          );
+          done = true;
+          if (typeof cleanup === "function") {
+            if (branchClosed || invocation.disposed || lifetime.disposed)
+              cleanup();
+            else returned = cleanup as () => void;
+          }
+        } catch (error) {
+          try {
+            stopWork();
+          } catch {}
+          throw error;
+        }
+      },
+    });
+    return element;
+  });
+  return result;
+}
+/** Internal @render dispatch: ordinary compiled snippets keep their cell ABI. */
+export function invokeSnippetDOM<P extends unknown[]>(
+  snippet:
+    | RawSnippet<P>
+    | ((
+        ...cells: { [K in keyof P]: Cell<P[K]> }
+      ) => import("@tschk/moonshine-dom/dom").DOMChild),
+  cells: { [K in keyof P]: Cell<P[K]> },
+  consumer: ComponentContext,
+  initial: boolean,
+  consumerScheduler: RenderScheduler | undefined,
+): import("@tschk/moonshine-dom/dom").DOMChild {
+  if (isRawSnippet(snippet))
+    return invokeRawDOM(
+      snippet as RawSnippet<P>,
+      cells,
+      consumer,
+      initial,
+      consumerScheduler,
+    );
+  return (
+    snippet as (
+      ...cells: { [K in keyof P]: Cell<P[K]> }
+    ) => import("@tschk/moonshine-dom/dom").DOMChild
+  )(...cells);
+}
+
+/** Internal compiler bridge: one queue/commit marker per rendered snippet slot. */
+export function createRawSnippetSlot() {
+  const pending = new Set<() => void>(),
+    marker = document.createComment("");
+  function drain() {
+    let failed = false,
+      failure: unknown;
+    const stops = [...pending];
+    pending.clear();
+    for (const stop of stops)
+      try {
+        untrack(stop);
+      } catch (error) {
+        if (!failed) failure = error;
+        failed = true;
+      }
+    if (failed) throw failure;
+  }
+  onCleanup(drain);
+  return {
+    deferRemoved(stop: () => void) {
+      pending.add(stop);
+    },
+    render(fn: () => import("@tschk/moonshine-dom/dom").DOMChild) {
+      let value: import("@tschk/moonshine-dom/dom").DOMChild;
+      try {
+        value = fn();
+      } catch (error) {
+        try {
+          drain();
+        } catch {}
+        throw error;
+      }
+      if (value instanceof Node) {
+        const setup = (value as Node & { [insertedNode]?: () => void })[
+          insertedNode
+        ];
+        if (setup)
+          Object.defineProperty(value, insertedNode, {
+            configurable: true,
+            value() {
+              let failed = false,
+                failure: unknown;
+              try {
+                setup();
+              } catch (error) {
+                failure = error;
+                failed = true;
+              }
+              try {
+                drain();
+              } catch (error) {
+                if (!failed) failure = error;
+                failed = true;
+              }
+              if (failed) throw failure;
+            },
+          });
+      }
+      return value;
+    },
+    commit(
+      value: import("@tschk/moonshine-dom/dom").DOMChild,
+    ): import("@tschk/moonshine-dom/dom").DOMChild {
+      Object.defineProperty(marker, insertedNode, {
+        configurable: true,
+        value: drain,
+      });
+      return [value, marker];
+    },
+  };
+}

package/src/raw-snippet-ssr.ts

@@ -0,0 +1,75 @@
+import {
+  isRawSnippet,
+  getRawSnippetFactory,
+  type RawSnippet,
+} from "./raw-snippet";
+import { rawHTML } from "@tschk/moonshine-dom/ssr";
+import {
+  withComponentConsumer,
+  type ComponentContext,
+} from "@tschk/moonshine-dom/component";
+import {
+  untrack,
+  getOwner,
+  runWithOwner,
+  onCleanup,
+} from "@tschk/moonshine-dom/reactive";
+import {
+  captureSSRRenderAttempt,
+  isSSRRenderAccepted,
+} from "@tschk/moonshine-dom/ssr-attempt";
+import { rawSSRRegistrar, type Registrar } from "./raw-ssr-lifecycle";
+/** Internal invocation ABI: explicitly supplied authored consumer; source values, not DOM cells. */
+export function invokeRawSSR<P extends unknown[]>(
+  snippet: RawSnippet<P>,
+  values: P,
+  consumer: ComponentContext,
+) {
+  const factory = getRawSnippetFactory(snippet);
+  const owner = getOwner();
+  if (!owner || owner.disposed) throw Error("Live raw SSR invocation required");
+  const consumerAttempt = runWithOwner(consumer.owner, captureSSRRenderAttempt),
+    context = owner.context;
+  owner.context = new Map(context);
+  owner.context.set(rawSSRRegistrar, {
+    consumer,
+    register(fn) {
+      runWithOwner(consumer.owner, () =>
+        onCleanup(() => {
+          if (isSSRRenderAccepted(consumerAttempt)) fn();
+        }),
+      );
+    },
+  } satisfies Registrar);
+  try {
+    return withComponentConsumer(consumer, () =>
+      untrack(() =>
+        rawHTML(
+          factory(
+            ...(values.map((value) => () => value) as {
+              [K in keyof P]: () => P[K];
+            }),
+          )
+            .render()
+            .trim(),
+        ),
+      ),
+    );
+  } finally {
+    owner.context = context;
+  }
+}
+/** Internal @render dispatch: ordinary server snippets keep source value arguments. */
+export function invokeSnippetSSR<P extends unknown[]>(
+  snippet:
+    | RawSnippet<P>
+    | ((...values: P) => import("@tschk/moonshine-dom/ssr").SSRChild),
+  values: P,
+  consumer: ComponentContext,
+): import("@tschk/moonshine-dom/ssr").SSRChild {
+  if (isRawSnippet(snippet))
+    return invokeRawSSR(snippet as RawSnippet<P>, values, consumer);
+  return (
+    snippet as (...values: P) => import("@tschk/moonshine-dom/ssr").SSRChild
+  )(...values);
+}

package/src/raw-snippet.ts

@@ -0,0 +1,36 @@
+const rawSnippet = /* @__PURE__ */ Symbol("moonshine raw snippet");
+export type RawSnippetFactory<P extends unknown[]> = (
+  ...getters: { [K in keyof P]: () => P[K] }
+) => { render(): string; setup?: (element: Element) => unknown };
+/** Tagged source callable; direct execution rejects until @render is compiler-lowered. */
+export interface RawSnippet<P extends unknown[] = []> {
+  (...values: number extends P["length"] ? never : P): unknown;
+  readonly [rawSnippet]: RawSnippetFactory<P>;
+}
+export function createRawSnippet<P extends unknown[]>(
+  factory: RawSnippetFactory<P>,
+): RawSnippet<P> {
+  if (typeof factory !== "function")
+    throw new TypeError("Raw snippet requires a factory");
+  const snippet = (
+    ..._values: number extends P["length"] ? never : P
+  ): never => {
+    throw new Error("Raw snippets require compiler-lowered @render invocation");
+  };
+  return Object.assign(snippet, { [rawSnippet]: factory });
+}
+/** Internal compiler adapter validation, not a source invocation API. */
+export function getRawSnippetFactory<P extends unknown[]>(
+  snippet: RawSnippet<P>,
+): RawSnippetFactory<P> {
+  if (!snippet || typeof snippet[rawSnippet] !== "function")
+    throw new TypeError("Expected native raw snippet descriptor");
+  return snippet[rawSnippet];
+}
+/** Internal dynamic @render discrimination; ordinary source snippets are untagged. */
+export function isRawSnippet(value: unknown): value is RawSnippet<unknown[]> {
+  return (
+    typeof value === "function" &&
+    typeof (value as RawSnippet<unknown[]>)[rawSnippet] === "function"
+  );
+}

package/src/raw-ssr-lifecycle.ts

@@ -0,0 +1,8 @@
+import type { ComponentContext } from "@tschk/moonshine-dom/component";
+export const rawSSRRegistrar = /* @__PURE__ */ Symbol(
+  "raw SSR consumer lifecycle",
+);
+export type Registrar = {
+  consumer: ComponentContext;
+  register(fn: () => void): void;
+};

package/src/raw-state.ts

@@ -0,0 +1,19 @@
+/** Shallow compiler cell: assignments track; nested values retain their identity. */
+import { createSignal, untrack } from "@tschk/moonshine-dom/reactive";
+import { readHistory, recordHistory, withHistoryMutation } from "./history";
+
+export function createRawState<T>(initial: T): { value: T } {
+  const [read, write] = createSignal(initial);
+  return {
+    get value() {
+      return readHistory(read, "value", read);
+    },
+    set value(next: T) {
+      withHistoryMutation(() => {
+        const previous = untrack(read);
+        if (previous !== next) recordHistory(read, "value", previous, next);
+        write(() => next);
+      });
+    },
+  };
+}

package/src/runes.ts

@@ -0,0 +1,11 @@
+/** Compiler-facing native state and post-DOM effects; syntax lowering is Crepus's. */
+export { createState, stateSnapshot } from "./state";
+export { createRuneEffect, createRuneRoot, runeTracking } from "./effect";
+export { createDerived } from "./derived";
+export { createProp } from "./prop";
+export { createRawState } from "./raw-state";
+export { spreadProps } from "./spread-props";
+export {
+  createPrivateState,
+  createPrivateRawState,
+} from "./private-class-state";

package/src/server-mount.ts

@@ -0,0 +1,31 @@
+import type {
+  ComponentExports,
+  ComponentProps,
+  MountOptions,
+  UnmountOptions,
+} from "./mount-types";
+export type {
+  ComponentView,
+  ComponentFactory,
+  ComponentProps,
+  ComponentExports,
+  MountOptions,
+  UnmountOptions,
+} from "./mount-types";
+function unavailable(name: string): never {
+  throw new Error(
+    `lifecycle_function_unavailable\n\`${name}(...)\` is not available on the server\nhttps://svelte.dev/e/lifecycle_function_unavailable`,
+  );
+}
+export function mount<C extends (...args: never[]) => unknown>(
+  _component: C & ([ComponentExports<C>] extends [never] ? never : unknown),
+  _options: MountOptions<ComponentProps<C>>,
+): ComponentExports<C> {
+  return unavailable("mount");
+}
+export function unmount(
+  _instance: object,
+  _options?: UnmountOptions,
+): Promise<void> {
+  return unavailable("unmount");
+}

package/src/server-prop.ts

@@ -0,0 +1,29 @@
+/** Server bindings publish final local values only after successful rendering. */
+import { untrack } from "@tschk/moonshine";
+
+export function createServerProp<T>(
+  props: object,
+  key: PropertyKey,
+  fallback?: () => T,
+): { value: T; commit(): void } {
+  let value = untrack(() => {
+    const initial = Reflect.get(props, key);
+    return initial === undefined ? fallback?.() : initial;
+  }) as T;
+  return {
+    get value() {
+      return value;
+    },
+    set value(next: T) {
+      value = next;
+    },
+    commit() {
+      untrack(() => {
+        if (Reflect.get(props, key) !== undefined || value === undefined)
+          return;
+        const setter = Object.getOwnPropertyDescriptor(props, key)?.set;
+        if (setter) Reflect.apply(setter, props, [value]);
+      });
+    },
+  };
+}

package/src/server-store.ts

@@ -0,0 +1,113 @@
+/** Compiler-owned synchronous SSR subscriptions; completion is explicit after serialization. */
+import {
+  getOwner,
+  onAfterDispose,
+  untrack,
+} from "@tschk/moonshine-dom/reactive";
+import { subscribeTo } from "./store-internal";
+import type { StoreSource } from "./store-binding";
+export type ServerStoreReference<T> = {
+  get(store: StoreSource<T> | null | undefined): T | undefined;
+  releaseIfChanged<S extends StoreSource<T> | null | undefined>(store: S): S;
+};
+export type ServerStoreReferences = {
+  create<T>(): ServerStoreReference<T>;
+  finish(): void;
+};
+const noop = () => {};
+export function createServerStoreReferences(): ServerStoreReferences {
+  const owner = getOwner();
+  if (!owner || owner.disposed)
+    throw Error("Server store references require a live native owner");
+  const accessed: Array<() => void> = [];
+  let closed = false;
+  function finish() {
+    if (closed) return;
+    closed = true;
+    let failed = false,
+      failure: unknown;
+    for (const release of accessed.splice(0)) {
+      try {
+        release();
+      } catch (error) {
+        if (!failed) failure = error;
+        failed = true;
+      }
+    }
+    if (failed) throw failure;
+  }
+  // Resource cleanup runs for failed/discarded attempts too; it is not public onDestroy.
+  onAfterDispose(finish);
+  return {
+    finish,
+    create<T>(): ServerStoreReference<T> {
+      if (closed || owner.disposed)
+        throw Error("Cannot create a server store reference after completion");
+      let store: StoreSource<T> | null = null,
+        current: T | undefined,
+        seen = false,
+        releasing = false,
+        stop: () => void = noop;
+      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;
+      }
+      return {
+        releaseIfChanged(next) {
+          return next;
+        },
+        get(next) {
+          const identity = next ?? null;
+          if (seen && store === identity) return current;
+          // Late/new reads cannot leak subscriptions from public destroy callbacks.
+          if (releasing || closed || (owner.disposed && !owner.disposing))
+            return temporary(next);
+          if (!seen) {
+            seen = true;
+            accessed.push(release);
+          }
+          release();
+          if (closed || (owner.disposed && !owner.disposing))
+            return temporary(next);
+          store = identity;
+          current = undefined;
+          if (next) {
+            let active = true,
+              unsubscribe: (() => void) | undefined;
+            stop = () => {
+              if (!active) return;
+              active = false;
+              unsubscribe?.();
+            };
+            unsubscribe = untrack(() =>
+              subscribeTo(next, (value) => {
+                if (active) current = value;
+              }),
+            );
+            if (!active || closed || (owner.disposed && !owner.disposing))
+              unsubscribe();
+          }
+          return current;
+        },
+      };
+    },
+  };
+}