ilha 0.15.0 → 0.15.1

package/dist/define.js

@@ -1,4 +1,4 @@
-import { t as mount } from "./mount-qJHX_CfF.js";
+import { t as mount } from "./mount-DCu8b0hE.js";
 
 //#region src/define.ts
 const define = (name, component) => {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { C as WatchOnceCleanup, S as WatchContext, _ as ResourceOptions, b as View, c as EventSourceStatus, d as Instruction, g as ResourceFetcher, h as Resource, i as Component, l as Fragment, n as AtomHandle, o as EventSourceFeed, r as AtomOptions, s as EventSourceOptions, t as AtomEquality, v as UnsafeHtml, w as Yielded, x as WatchCallback } from "./types-DsdtZMhG.js";
 import { t as h } from "./vnode-CpSQZnLM.js";
-import { r as watch } from "./runtime-B-sEGtAa.js";
+import { r as watch } from "./runtime-Baq7MtkE.js";
 import * as Atom from "effect/reactivity/Atom";
 import { Equal } from "effect";
 import * as Effect$1 from "effect/Effect";

package/dist/index.js

@@ -1,6 +1,6 @@
 import { _ as isString, f as errorView, i as Fragment, m as isFunction, t as h } from "./vnode-BHUY61Rm.js";
-import { C as makeFiber, S as getFiber, _ as structuralEqual, b as clearFiberView, d as interpret, f as atom, g as isAtomHandle, h as instr, m as handleOwner, n as unsafe, p as batch, u as runSetup, v as untrack, x as closeFiber, y as wrapHandle } from "./paint-core-Cw1HbMp6.js";
-import { n as renderToString, t as mount } from "./mount-qJHX_CfF.js";
+import { C as makeFiber, S as getFiber, _ as structuralEqual, b as clearFiberView, d as interpret, f as atom, g as isAtomHandle, h as instr, m as handleOwner, n as unsafe, p as batch, u as runSetup, v as untrack, x as closeFiber, y as wrapHandle } from "./paint-core-D9VO-oUM.js";
+import { n as renderToString, t as mount } from "./mount-DCu8b0hE.js";
 import * as Atom from "effect/reactivity/Atom";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";

package/dist/{mount-qJHX_CfF.js → mount-DCu8b0hE.js}

@@ -1,5 +1,5 @@
 import { _ as isString, c as KEEP, d as defer, g as isObject, m as isFunction, r as isVNode, u as SLOT_ATTR, y as unwrap } from "./vnode-BHUY61Rm.js";
-import { T as makeRuntime, a as morphInner, c as bindEvents, i as insertRendered, l as eventTypeFromProp, o as placeChildren, r as committedElement, s as standInFor, t as createPainter, u as runSetup, w as makeRootFiber, x as closeFiber } from "./paint-core-Cw1HbMp6.js";
+import { T as makeRuntime, a as morphInner, c as bindEvents, i as insertRendered, l as eventTypeFromProp, o as placeChildren, r as committedElement, s as standInFor, t as createPainter, u as runSetup, w as makeRootFiber, x as closeFiber } from "./paint-core-D9VO-oUM.js";
 
 //#region src/paint.ts
 const noopDisconnect = () => {};

package/dist/{paint-core-Cw1HbMp6.js → paint-core-D9VO-oUM.js}

@@ -362,8 +362,10 @@ const subscribeRenderDeps = (fiber, deps, run) => {
 	const schedule = () => {
 		if (scheduled) return;
 		scheduled = true;
+		const seen = fiber.renderGen;
 		fiber.runtime.later(() => {
 			scheduled = false;
+			if (fiber.renderGen !== seen) return;
 			run();
 		});
 	};
@@ -507,6 +509,7 @@ const runSetup = (fiber, fn) => {
 		},
 		render: () => {
 			if (fiber.closed) return;
+			fiber.renderGen = (fiber.renderGen ?? 0) + 1;
 			fiber.runtime.begin();
 			beginPrimitiveFrame(fiber);
 			withTrackGetRun(fiber, () => fn(), ({ value: out, deps }) => {
@@ -1133,36 +1136,26 @@ const elementNs = (lower, parentNs) => {
 	if (parentNs === "http://www.w3.org/2000/svg" || parentNs === "http://www.w3.org/1998/Math/MathML") return parentNs;
 };
 const canMorphRoot = (root) => typeof Element !== "undefined" && typeof document !== "undefined" && root instanceof Element && root.childNodes.length > 0;
+/** Close a child hole through the parent's hole list, so it disposes once. */
+const releaseHole = (fiber, hole) => {
+	const idx = fiber.holes.findIndex((h) => h.holeFiber === hole);
+	if (idx === -1) closeFiber(hole);
+	else {
+		const [removed] = fiber.holes.splice(idx, 1);
+		removed?.dispose();
+	}
+};
 const sweepComponentSlots = (fiber) => {
 	const cframe = fiber.componentFrame;
 	if (!cframe) return;
 	const { slots } = cframe;
 	for (let j = cframe.i; j < slots.length; j += 1) {
 		const s = slots[j];
-		if (s) {
-			const { hole } = s;
-			if (!hole.closed) {
-				const idx = fiber.holes.findIndex((h) => h.holeFiber === hole);
-				if (idx === -1) closeFiber(hole);
-				else {
-					const [removed] = fiber.holes.splice(idx, 1);
-					removed?.dispose();
-				}
-			}
-		}
+		if (s && !s.hole.closed) releaseHole(fiber, s.hole);
 		slots[j] = void 0;
 	}
 	slots.length = cframe.i;
 };
-/** Close a child hole through the parent's hole list, so it disposes once. */
-const releaseHole = (fiber, hole) => {
-	const idx = fiber.holes.findIndex((h) => h.holeFiber === hole);
-	if (idx === -1) closeFiber(hole);
-	else {
-		const [removed] = fiber.holes.splice(idx, 1);
-		removed?.dispose();
-	}
-};
 /** Close the keyed components the paint that just ran did not reach. */
 const sweepKeyedHoles = (fiber) => {
 	const { keyedHoles, keyedGen } = fiber;
@@ -1183,6 +1176,61 @@ const pass = (fiber, fn) => {
 	fn();
 	sweepKeyedHoles(fiber);
 };
+/**
+* Dispose a hole fiber's child holes before it repaints, except the component
+* and island holes the repaint can reuse: positional children, keyed
+* children, and islands. Reuse pushes new props instead of remounting, and the
+* sweeps that end the paint close whatever it did not reach.
+*/
+const keepReusableHoles = (fiber, cframe, frame) => {
+	const kept = /* @__PURE__ */ new Set();
+	for (const s of cframe.slots) if (s && !s.hole.closed) kept.add(s.hole);
+	for (const hole of fiber.keyedHoles?.values() ?? []) if (!hole.closed) kept.add(hole);
+	const keptIslands = new Set(frame.slots);
+	const keep = [];
+	for (const h of fiber.holes) {
+		if (h.holeFiber && kept.has(h.holeFiber) || h.islandSlot && keptIslands.has(h.islandSlot)) {
+			keep.push(h);
+			continue;
+		}
+		h.dispose();
+	}
+	fiber.holes = keep;
+};
+/** Shallow equality of two prop bags, children compared item by item. */
+const sameProps = (prev, next) => {
+	if (!prev) return false;
+	const keys = Object.keys(next);
+	if (keys.length !== Object.keys(prev).length) return false;
+	return keys.every((k) => {
+		const a = prev[k];
+		const b = next[k];
+		if (k === "children" && Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((x, i) => Object.is(x, b[i]));
+		return Object.is(a, b);
+	});
+};
+/**
+* Rerun a reused component hole with new props, in its own fiber. The props
+* box is updated in place, so every render closure of the hole reads the
+* latest props, including a self-render queued while an async render ran.
+*/
+const rerunHole = (hole, run, props) => {
+	const box = hole.propsBox ?? { current: props };
+	box.current = props;
+	hole.propsBox = box;
+	runSetup(hole, () => run(box.current));
+};
+/**
+* Run a new component hole's first render after the paint that opened it. A
+* repaint that reached the hole first already rendered it with newer props.
+*/
+const mountHoleLater = (fiber, hole, run) => {
+	fiber.runtime.later(() => {
+		const box = hole.propsBox;
+		if (hole.closed || hole.renderGen !== void 0 || !box) return;
+		runSetup(hole, () => run(box.current));
+	});
+};
 const warnedKeys = /* @__PURE__ */ new Set();
 const warnDuplicateKey = (key) => {
 	if (warnedKeys.has(key)) return;
@@ -1221,10 +1269,6 @@ const styleCss = (v) => {
 	if (isString(v) || isObject(v)) return serializeStyleAttr(v);
 	return "";
 };
-const isThenable = (value) => {
-	if (!isObject(value) && !isFunction(value)) return false;
-	return isFunction(value.then);
-};
 const writeAttr = (el, k, v) => {
 	if (v === false || v === null || v === void 0) {
 		el.removeAttribute(k);
@@ -1369,18 +1413,7 @@ const createPainter = (ops) => {
 						sweepIslandSlots(fiber);
 						return;
 					}
-					const kept = /* @__PURE__ */ new Set();
-					for (const s of cframe.slots) if (s && !s.hole.closed) kept.add(s.hole);
-					const keptIslands = new Set(frame.slots);
-					const keep = [];
-					for (const h of fiber.holes) {
-						if (h.holeFiber && kept.has(h.holeFiber) || h.islandSlot && keptIslands.has(h.islandSlot)) {
-							keep.push(h);
-							continue;
-						}
-						h.dispose();
-					}
-					fiber.holes = keep;
+					keepReusableHoles(fiber, cframe, frame);
 					const fresh = api.materialize(view, fiber);
 					if (canMorphRoot(fiber.root)) {
 						const tmp = document.createElement("div");
@@ -1494,18 +1527,10 @@ const createPainter = (ops) => {
 		if (existing) {
 			const { hole } = existing;
 			if (existing.type === type && !hole.closed) {
-				hole.propsBox = { current: props };
-				runSetup(hole, () => run(props));
+				rerunHole(hole, run, props);
 				return [ops.reuseNode(hole.root)];
 			}
-			if (!hole.closed) {
-				const idx = fiber.holes.findIndex((h) => h.holeFiber === hole);
-				if (idx === -1) closeFiber(hole);
-				else {
-					const [removed] = fiber.holes.splice(idx, 1);
-					removed?.dispose();
-				}
-			}
+			if (!hole.closed) releaseHole(fiber, hole);
 		}
 		const { fiber: hole, nodes } = api.openHole(fiber);
 		hole.propsBox = { current: props };
@@ -1514,51 +1539,53 @@ const createPainter = (ops) => {
 			hole,
 			type
 		};
-		fiber.runtime.later(() => {
-			if (hole.closed) return;
-			const box = hole.propsBox;
-			if (!box) return;
-			runSetup(hole, () => run(box.current));
-		});
+		mountHoleLater(fiber, hole, run);
 		trackHole(fiber, hole, void 0, { keyed: true });
 		return nodes;
 	};
-	const materializeComponent = (view, type, fiber) => {
-		const props = {
-			...view.props,
-			children: view.children
-		};
-		const branded = type;
-		if (branded[ISLAND] === true) return materializeIsland(branded, props, fiber);
-		const k = view.key === null || view.key === void 0 ? void 0 : String(view.key);
-		const reuse = k ? fiber.keyedHoles?.get(k) : void 0;
-		const run = type;
+	const materializeKeyedComponent = ({ run, type, props, key, fiber }) => {
+		let reuse = fiber.keyedHoles?.get(key);
 		const gen = fiber.keyedGen;
-		if (k && reuse && !reuse.closed && reuse.keyedSeen === gen) {
-			warnDuplicateKey(k);
+		if (reuse && !reuse.closed && reuse.keyedSeen === gen) {
+			warnDuplicateKey(key);
 			return materializeUnkeyedComponent(run, type, props, fiber);
 		}
+		if (reuse && !reuse.closed && reuse.componentType !== type) {
+			fiber.keyedHoles?.delete(key);
+			releaseHole(fiber, reuse);
+			reuse = void 0;
+		}
 		if (reuse && !reuse.closed) {
 			reuse.keyedSeen = gen;
-			if (reuse.propsBox) reuse.propsBox.current = props;
-			const next = withFiber(fiber, () => run(reuse.propsBox?.current ?? props));
-			if (next && !isThenable(next) && !isSetupFn(next)) reuse.paint(next);
+			if (!sameProps(reuse.propsBox?.current, props)) rerunHole(reuse, run, props);
 			return [ops.reuseNode(reuse.root)];
 		}
-		if (!k) return materializeUnkeyedComponent(run, type, props, fiber);
 		const { fiber: khole, nodes: knodes } = api.openHole(fiber);
 		khole.propsBox = { current: props };
+		khole.componentType = type;
 		khole.keyedSeen = gen;
-		fiber.keyedHoles?.set(k, khole);
-		fiber.runtime.later(() => {
-			if (khole.closed) return;
-			const box = khole.propsBox;
-			if (!box) return;
-			runSetup(khole, () => run(box.current));
-		});
+		fiber.keyedHoles?.set(key, khole);
+		mountHoleLater(fiber, khole, run);
 		trackHole(fiber, khole, void 0, { keyed: true });
 		return knodes;
 	};
+	const materializeComponent = (view, type, fiber) => {
+		const props = {
+			...view.props,
+			children: view.children
+		};
+		const branded = type;
+		if (branded[ISLAND] === true) return materializeIsland(branded, props, fiber);
+		const run = type;
+		if (view.key === null || view.key === void 0) return materializeUnkeyedComponent(run, type, props, fiber);
+		return materializeKeyedComponent({
+			fiber,
+			key: String(view.key),
+			props,
+			run,
+			type
+		});
+	};
 	const materializeElement = (view, fiber) => {
 		const tag = view.type;
 		const lower = tag.toLowerCase();
@@ -1602,8 +1629,14 @@ const createPainter = (ops) => {
 		const nodes = [];
 		for (const v of views) {
 			const reuse = fiber.keyedHoles?.get(String(v.key));
-			if (reuse && !reuse.closed) {
+			const reusable = reuse && !reuse.closed && reuse.keyedSeen !== fiber.keyedGen && reuse.componentType === v.type;
+			if (reuse && reusable) {
 				reuse.keyedSeen = fiber.keyedGen;
+				const props = {
+					...v.props,
+					children: v.children
+				};
+				if (!sameProps(reuse.propsBox?.current, props)) rerunHole(reuse, v.type, props);
 				nodes.push(ops.asNode(reuse.root));
 				continue;
 			}

package/dist/renderer.d.ts

@@ -1,5 +1,5 @@
 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";
+import { n as getFiber, t as FiberLocal } from "./runtime-Baq7MtkE.js";
 //#region src/shared.d.ts
 declare const KEEP: unique symbol;
 //#endregion

package/dist/renderer.js

@@ -1,5 +1,5 @@
 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";
+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-D9VO-oUM.js";
 
 //#region src/renderer.ts
 /**

package/dist/{runtime-B-sEGtAa.d.ts → runtime-Baq7MtkE.d.ts}

@@ -78,6 +78,8 @@ interface FiberLocal {
   componentFrame?: ComponentFrame;
   componentType?: unknown;
   renderSub?: () => void;
+  /** Counts the renders this fiber started; see `subscribeRenderDeps`. */
+  renderGen?: number;
   trackRestore?: () => void;
   propsBox?: {
     current: PropBag;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilha",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "Generator-first island UI on Effect",
   "keywords": [
     "effect",