ilha 0.14.10 → 0.15.0

package/dist/renderer.d.ts

@@ -0,0 +1,119 @@
+import { b as View, i as Component, m as PropValue, p as PropBag, u as IlhaRuntime } from "./types-DsdtZMhG.js";
+import { n as getFiber, t as FiberLocal } from "./runtime-B-sEGtAa.js";
+//#region src/shared.d.ts
+declare const KEEP: unique symbol;
+//#endregion
+//#region src/paint-core.d.ts
+/** Structural element API shared by DOM `Element` and the SSR `SsrEl` shim. */
+interface PaintEl<Node> {
+  readonly tagName: string;
+  dataset: DOMStringMap;
+  setAttribute: (name: string, value: string) => void;
+  removeAttribute: (name: string) => void;
+  appendChild: (node: Node) => void;
+  append: (...nodes: Node[]) => void;
+}
+type FormControlKey = "value" | "checked" | "selected";
+interface PaintOps<Node, El extends PaintEl<Node>> {
+  createElement: (tag: string, ns?: string) => El;
+  createText: (text: string) => Node;
+  /**
+   * Parse pre-rendered HTML into nodes under `parent` (DOM:
+   * context-aware fragment parse; SSR: raw node, parent unused).
+   */
+  createRaw: (html: string, parent: ParentNode) => Node[];
+  /** Display-contents span marking a dynamic hole; `null` omits the slot attr. */
+  createSlotHost: (slotId: string | null) => El;
+  /** Fiber root for a host element (SSR: cast SsrEl up to ParentNode). */
+  asRoot: (el: El) => ParentNode;
+  /** Insertable node for a reused fiber/island host. */
+  asNode: (host: ParentNode) => Node;
+  /**
+   * Node a render returns for a reused live host (DOM: a stand-in the morph
+   * swaps for the host in place, so the host is never detached).
+   */
+  reuseNode: (host: ParentNode) => Node;
+  /** Make `root`'s children exactly `nodes`, moving as little as possible. */
+  placeChildren: (root: ParentNode, nodes: Node[]) => void;
+  /** Append one node to `root`. Only `Painter.insert` calls it. */
+  appendRoot: (root: ParentNode, node: Node) => void;
+  /** Element view of a host (SSR: SsrEl masquerades as Element). */
+  asElement: (el: El) => Element;
+  /**
+   * The element a rendered element ended up as (DOM: the live node the morph
+   * kept in its place; SSR: itself).
+   */
+  committed: (el: El) => El;
+  /** Mark a host disconnected (SSR: flag flip; DOM: noop, the DOM tracks it). */
+  disconnect: (el: El) => void;
+  /**
+   * Take a prop as the component wrote it, before it is stringified. Return
+   * `true` to claim it; anything else falls through to the attribute, style
+   * and form-control handling below. A host that is not a DOM uses it to keep
+   * object values. Event props, `children`, `key` and `ref` never reach it.
+   */
+  setProp?: (el: El, key: string, value: PropValue) => boolean;
+  setStyle: (el: El, css: string) => void;
+  setFormControl: (el: El, key: FormControlKey, v: PropValue) => void;
+  bindEvents: (el: El, props: PropBag, fiber: FiberLocal) => void;
+}
+/** Painter surface returned by `createPainter`, shared by every host. */
+interface Painter<Node, El> {
+  applyProps: (el: El, props: PropBag, fiber: FiberLocal) => void;
+  /** Runs `fn` and flushes queued refs once the outermost paint commits. */
+  commit: (fn: () => void) => void;
+  /**
+   * Runs `fn` as one paint of `fiber`: the keyed components it materializes
+   * stay alive, and the ones it no longer reaches are closed afterwards.
+   */
+  pass: (fiber: FiberLocal, fn: () => void) => void;
+  disposeHoles: (fiber: FiberLocal, opts?: {
+    morph?: boolean;
+  }) => void;
+  insert: (fiber: FiberLocal, nodes: Node[]) => void;
+  materialize: (view: View, fiber: FiberLocal) => Node[];
+  paintHole: (fiber: FiberLocal, view: View | typeof KEEP) => void;
+}
+//#endregion
+//#region src/events.d.ts
+export declare const bindEvents: (node: Element, props: PropBag, fiber: FiberLocal) => void;
+//#endregion
+//#region src/renderer.d.ts
+export interface RendererMountOptions {
+  /**
+   * Called with a failing root component, and with a nested component no
+   * `ErrorBoundary` caught, before the error view paints.
+   */
+  onError?: (error: Error) => void;
+  /**
+   * Called with the mount's runtime before the root component runs. Every
+   * fiber of the mount carries it, so a host can key its own per-mount state
+   * on it and read that state from inside a component through `getFiber()`.
+   */
+  onRuntime?: (runtime: IlhaRuntime) => void;
+}
+export interface RendererHandle {
+  /** Stop the tree: closes every fiber, releases the registry, clears the root. */
+  unmount: () => void;
+  /** Resolves once in-flight work (async components, streams) goes idle. */
+  ready: Promise<null>;
+  runtime: IlhaRuntime;
+}
+export interface HostRenderer<Node, El extends PaintEl<Node> & Node> {
+  /** The shared painter, for advanced callers that paint holes themselves. */
+  readonly painter: Painter<Node, El>;
+  mount: (root: ParentNode, fn: Component, options?: RendererMountOptions) => RendererHandle;
+}
+/**
+ * Build a renderer for a host described by `ops`.
+ *
+ * Unlike the DOM painter this materializes fresh host nodes on every paint and
+ * attempts no morph: the host receives the new child list through
+ * `ops.placeChildren` and decides what to keep. Holes that must survive a
+ * repaint (atoms, islands, keyed rows, positional components) stay alive across
+ * paints and hand their host node back through `ops.reuseNode`, so their state
+ * is never remounted.
+ */
+export declare const createRenderer: <Node, El extends PaintEl<Node> & Node>(ops: PaintOps<Node, El>) => HostRenderer<Node, El>;
+//#endregion
+export { type Component, type FiberLocal, type FormControlKey, type IlhaRuntime, type PaintEl, type PaintOps, type Painter, type PropBag, type PropValue, type View, getFiber };

package/dist/renderer.js

@@ -0,0 +1,75 @@
+import { d as defer } from "./vnode-BHUY61Rm.js";
+import { S as getFiber, T as makeRuntime, c as bindEvents, t as createPainter, u as runSetup, w as makeRootFiber, x as closeFiber } from "./paint-core-Cw1HbMp6.js";
+
+//#region src/renderer.ts
+/**
+* Host renderer seam.
+*
+* `mount()` and `renderToString()` ship the two painters ilha uses on the web:
+* the DOM painter and the SSR string painter. This entry exposes the same
+* machinery for a third host — a native toolkit, a test harness, or any tree
+* that is not a DOM — by letting the caller supply `PaintOps`.
+*
+* The painter is host-agnostic: props, holes, keyed reconciliation, refs,
+* events, atoms and generators all run through `PaintOps`. The only host
+* differences are element creation, text creation, placement and teardown.
+*
+* A host mounted through `createRenderer` is placed with `placeChildren` only:
+* every paint hands over the complete child list of the root it painted.
+* `appendRoot` is never called on this path.
+*/
+/**
+* Build a renderer for a host described by `ops`.
+*
+* Unlike the DOM painter this materializes fresh host nodes on every paint and
+* attempts no morph: the host receives the new child list through
+* `ops.placeChildren` and decides what to keep. Holes that must survive a
+* repaint (atoms, islands, keyed rows, positional components) stay alive across
+* paints and hand their host node back through `ops.reuseNode`, so their state
+* is never remounted.
+*/
+const createRenderer = (ops) => {
+	const painter = createPainter(ops);
+	const paint = (fiber, view) => {
+		painter.commit(() => {
+			painter.pass(fiber, () => {
+				fiber.islandFrame ??= {
+					i: 0,
+					slots: []
+				};
+				painter.disposeHoles(fiber, { morph: true });
+				ops.placeChildren(fiber.root, painter.materialize(view, fiber));
+			});
+		});
+	};
+	return {
+		mount(root, fn, options = {}) {
+			const runtime = makeRuntime({ onError: options.onError });
+			options.onRuntime?.(runtime);
+			const { promise: ready, resolve } = defer();
+			const fiber = makeRootFiber({
+				paint,
+				root,
+				runtime,
+				settle: resolve
+			});
+			runtime.begin();
+			runtime.setIdle(resolve);
+			runSetup(fiber, fn);
+			runtime.end();
+			return {
+				ready,
+				runtime,
+				unmount: () => {
+					closeFiber(fiber);
+					runtime.close();
+					ops.placeChildren(root, []);
+				}
+			};
+		},
+		painter
+	};
+};
+
+//#endregion
+export { bindEvents, createRenderer, getFiber };

package/dist/runtime-B-sEGtAa.d.ts

@@ -0,0 +1,95 @@
+import { C as WatchOnceCleanup, S as WatchContext, a as ComponentFn, b as View, d as Instruction, l as Fragment, n as AtomHandle, p as PropBag, u as IlhaRuntime, x as WatchCallback } from "./types-DsdtZMhG.js";
+import * as Atom from "effect/reactivity/Atom";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { AtomRegistry } from "effect/reactivity/AtomRegistry";
+import * as Scope from "effect/Scope";
+//#region src/watch.d.ts
+/** Values delivered to watch callbacks. */
+type WatchValue = string | number | boolean | bigint | null | undefined | readonly WatchValue[] | WatchRecord;
+interface WatchRecord {
+  readonly [key: string]: WatchValue | undefined;
+}
+declare const WATCH_ONCE: unique symbol;
+/** Discriminator for watch slot identity (atom/stream instance). */
+type WatchKey = Atom.Atom<WatchValue> | Stream.Stream<WatchValue, unknown, unknown> | AtomHandle<WatchValue> | typeof WATCH_ONCE;
+interface WatchSlot {
+  key: WatchKey;
+  fnRef?: {
+    current: (value: WatchValue) => void;
+  };
+  dispose: () => void;
+}
+interface WatchFn {
+  <A extends WatchValue>(source: AtomHandle<A> | Atom.Atom<A> | Stream.Stream<A, unknown, unknown>, fn: WatchCallback<A>): Instruction<undefined>;
+  once: (fn: (ctx: WatchContext) => WatchOnceCleanup | undefined | Promise<WatchOnceCleanup | undefined>) => Instruction<undefined>;
+}
+declare const watch: WatchFn;
+//#endregion
+//#region src/runtime.d.ts
+interface Hole {
+  dispose: () => void;
+  keepOnMorph?: boolean;
+  atom?: Atom.Atom<unknown>;
+  host?: Element;
+  holeFiber?: FiberLocal;
+  islandSlot?: IslandSlot;
+}
+interface IslandSlot {
+  type: string | Fragment | ComponentFn;
+  host: Element;
+  updateProps?: (props?: PropBag) => void;
+  unmount?: () => void;
+}
+interface IslandFrame {
+  i: number;
+  slots: (IslandSlot | undefined)[];
+}
+interface ComponentSlot {
+  type: unknown;
+  hole: FiberLocal;
+}
+interface ComponentFrame {
+  i: number;
+  slots: ComponentSlot[];
+}
+interface FiberLocal {
+  root: ParentNode;
+  registry: AtomRegistry;
+  scope: Scope.Closeable;
+  runtime: IlhaRuntime;
+  holes: Hole[];
+  inFlight: boolean;
+  closed: boolean;
+  hydrate?: boolean;
+  keyedHoles?: Map<string, FiberLocal>;
+  /** Counts this fiber's paints; a keyed hole records the last one it was in. */
+  keyedGen?: number;
+  /** On a keyed hole: the parent's `keyedGen` of the last paint that reached it. */
+  keyedSeen?: number;
+  liveEl?: Element;
+  primitiveI?: number;
+  primitives?: Atom.Atom<unknown>[];
+  /** Releases for the state atoms this fiber keeps in the registry. */
+  primitiveHolds?: (() => void)[];
+  watchI?: number;
+  watchSlots?: WatchSlot[];
+  islandFrame?: IslandFrame;
+  componentFrame?: ComponentFrame;
+  componentType?: unknown;
+  renderSub?: () => void;
+  trackRestore?: () => void;
+  propsBox?: {
+    current: PropBag;
+  };
+  parent?: FiberLocal;
+  contexts?: Map<symbol, Atom.Atom<unknown>>;
+  handleError?: (error: Error) => void;
+  paintFn: (fiber: FiberLocal, view: View) => void;
+  paint: (view: View) => void;
+  run: <A, E>(effect: Effect.Effect<A, E, AtomRegistry>, onOk?: (a: A) => void, onErr?: (e: E) => void) => void;
+  fail: <E>(e: E) => void;
+}
+declare const getFiber: () => FiberLocal;
+//#endregion
+export { getFiber as n, watch as r, FiberLocal as t };

package/dist/{types-CJF2qMK6.d.ts → types-DsdtZMhG.d.ts}

@@ -1,6 +1,6 @@
 import { Effect, Stream } from "effect";
 import { AtomRegistry } from "effect/reactivity/AtomRegistry";
-import "effect/Scope";
+import { Closeable } from "effect/Scope";
 import { Atom } from "effect/reactivity";
 //#region src/types.d.ts
 type JsonText = string | number | bigint | boolean | null | undefined;
@@ -12,6 +12,11 @@ type EventHandler = (event: Event) => void;
 interface PropBag {
   readonly [key: string]: PropValue | undefined;
 }
+type ActionArg = JsonText | PropBag | readonly ActionArg[];
+interface SsrAction {
+  readonly k: string;
+  readonly a: readonly ActionArg[];
+}
 type View = VNode | UnsafeHtml | JsonText | AtomHandle<unknown> | Stream.Stream<View, unknown, unknown> | GeneratorFn | Component | View[] | Iterable<View>;
 declare const Fragment: unique symbol;
 type Fragment = typeof Fragment;
@@ -37,6 +42,28 @@ interface Instruction<A, E = Error> extends Iterable<Instruction<A, E>, A>, Prom
   readonly effect: Effect.Effect<A, E, AtomRegistry>;
 }
 type Component = (() => View | undefined | Promise<View | undefined>) | GeneratorFn;
+interface IlhaRuntime {
+  readonly registry: AtomRegistry;
+  readonly scope: Closeable;
+  readonly ssr: boolean;
+  readonly ssrValues: unknown[];
+  ssrActions: Record<string, SsrAction>;
+  ssrEventI: number;
+  ssrCapture: boolean;
+  hydrateValues?: unknown[];
+  hydrateI: number;
+  nextHole: () => number;
+  begin: () => void;
+  end: () => void;
+  later: (fn: () => void) => void;
+  setIdle: (cb: () => void) => void;
+  close: () => void;
+  /**
+   * The mount's failure hook. Called for a failing root component and for a
+   * nested component no `ErrorBoundary` caught, before the error view paints.
+   */
+  onError?: (error: Error) => void;
+}
 interface AtomHandle<A> {
   readonly $$atom: 1;
   readonly atom: Atom.Atom<A>;
@@ -97,4 +124,4 @@ interface EventSourceFeed<T = string> {
   readonly latest: AtomHandle<T | undefined>;
 }
 //#endregion
-export { Yielded as S, VNode as _, ComponentFn as a, WatchContext as b, EventSourceStatus as c, JsxComponent as d, PropBag as f, UnsafeHtml as g, ResourceOptions as h, Component as i, Fragment as l, ResourceFetcher as m, AtomHandle as n, EventSourceFeed as o, Resource as p, AtomOptions as r, EventSourceOptions as s, AtomEquality as t, Instruction as u, View as v, WatchOnceCleanup as x, WatchCallback as y };
+export { WatchOnceCleanup as C, WatchContext as S, ResourceOptions as _, ComponentFn as a, View as b, EventSourceStatus as c, Instruction as d, JsxComponent as f, ResourceFetcher as g, Resource as h, Component as i, Fragment as l, PropValue as m, AtomHandle as n, EventSourceFeed as o, PropBag as p, AtomOptions as r, EventSourceOptions as s, AtomEquality as t, IlhaRuntime as u, UnsafeHtml as v, Yielded as w, WatchCallback as x, VNode as y };

package/dist/{vnode-M-oJMKcv.js → vnode-BHUY61Rm.js}

@@ -1,6 +1,6 @@
-import * as AsyncResult from "effect/reactivity/AsyncResult";
 import * as Option from "effect/Option";
 import * as Result from "effect/Result";
+import * as AsyncResult from "effect/reactivity/AsyncResult";
 
 //#region src/errors.ts
 const asFailure = (e) => {
@@ -46,6 +46,15 @@ const unwrap = (value, keep) => {
 	}
 	return value;
 };
+const defer = () => {
+	const { promise, resolve } = Promise.withResolvers();
+	return {
+		promise,
+		resolve: () => {
+			resolve(null);
+		}
+	};
+};
 const errorView = (e) => ({
 	$$ilha: 1,
 	children: [failureMessage(e)],
@@ -88,4 +97,4 @@ const isSetupFn = (x) => {
 };
 
 //#endregion
-export { skip as _, ISLAND as a, failureMessage as b, KEEP as c, errorView as d, isBigInt as f, isString as g, isObject as h, Fragment as i, KEY_ATTR as l, isNumber as m, isSetupFn as n, ISLAND_MOUNT_INTERNAL as o, isFunction as p, isVNode as r, ISLAND_SLOT_TAG as s, h as t, SLOT_ATTR as u, unwrap as v, toError as x, asFailure as y };
+export { toError as S, isString as _, ISLAND as a, asFailure as b, KEEP as c, defer as d, errorView as f, isObject as g, isNumber as h, Fragment as i, KEY_ATTR as l, isFunction as m, isSetupFn as n, ISLAND_MOUNT_INTERNAL as o, isBigInt as p, isVNode as r, ISLAND_SLOT_TAG as s, h as t, SLOT_ATTR as u, skip as v, failureMessage as x, unwrap as y };

package/dist/{vnode-CUTNGblA.d.ts → vnode-CpSQZnLM.d.ts}

@@ -1,4 +1,4 @@
-import { _ as VNode, a as ComponentFn, d as JsxComponent, f as PropBag, l as Fragment, n as AtomHandle, v as View } from "./types-CJF2qMK6.js";
+import { a as ComponentFn, b as View, f as JsxComponent, l as Fragment, n as AtomHandle, p as PropBag, y as VNode } from "./types-DsdtZMhG.js";
 //#region src/jsx-types.d.ts
 declare namespace JSX {
   export type Element = View;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilha",
-  "version": "0.14.10",
+  "version": "0.15.0",
   "description": "Generator-first island UI on Effect",
   "keywords": [
     "effect",
@@ -52,6 +52,10 @@
     "./define": {
       "types": "./dist/define.d.ts",
       "import": "./dist/define.js"
+    },
+    "./renderer": {
+      "types": "./dist/renderer.d.ts",
+      "import": "./dist/renderer.js"
     }
   },
   "publishConfig": {