@dimina-kit/electron-deck 0.1.0-dev.20260610082053

package/dist/view-handle-CR-yWNfr.js

@@ -0,0 +1,701 @@
+//#region src/main/disposable.ts
+function toDisposable(fn) {
+	let done = false;
+	return { dispose() {
+		if (done) return;
+		done = true;
+		return fn();
+	} };
+}
+var DisposableRegistry = class {
+	entries = [];
+	_disposed = false;
+	/**
+	* Number of live entries. A wrapper's `dispose` splices its entry out and
+	* `disposeAll` clears the array, so `entries.length` is the live count.
+	*/
+	get size() {
+		return this.entries.length;
+	}
+	add(d) {
+		if (this._disposed) throw new Error("cannot add to disposed registry");
+		const fn = typeof d === "function" ? d : () => d.dispose();
+		const entry = {
+			fn,
+			released: false
+		};
+		this.entries.push(entry);
+		return { dispose: () => {
+			if (entry.released) return;
+			entry.released = true;
+			const i = this.entries.indexOf(entry);
+			if (i >= 0) this.entries.splice(i, 1);
+			return fn();
+		} };
+	}
+	async disposeAll() {
+		if (this._disposed) return;
+		this._disposed = true;
+		const items = this.entries.slice().reverse();
+		this.entries = [];
+		const errors = [];
+		for (const entry of items) {
+			if (entry.released) continue;
+			entry.released = true;
+			try {
+				await entry.fn();
+			} catch (e) {
+				errors.push(e);
+			}
+		}
+		if (errors.length > 0) throw new AggregateError(errors, "DisposableRegistry encountered errors during disposeAll");
+	}
+	dispose() {
+		return this.disposeAll();
+	}
+};
+//#endregion
+//#region src/main/logger.ts
+var LEVEL_PRIORITY = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+var LEVEL_PREFIX = {
+	debug: "[DEBUG]",
+	info: "[INFO]",
+	warn: "[WARN]",
+	error: "[ERROR]"
+};
+var currentLevel = "debug";
+function shouldLog(level) {
+	return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[currentLevel];
+}
+function formatMessage(level, tag, message) {
+	return `${(/* @__PURE__ */ new Date()).toISOString()} ${LEVEL_PREFIX[level]} [${tag}] ${message}`;
+}
+/**
+* Create a tagged logger for a specific module.
+* All output goes to console with structured prefix.
+*/
+function createLogger(tag) {
+	return {
+		debug(message, ...args) {
+			if (shouldLog("debug")) console.debug(formatMessage("debug", tag, message), ...args);
+		},
+		info(message, ...args) {
+			if (shouldLog("info")) console.info(formatMessage("info", tag, message), ...args);
+		},
+		warn(message, ...args) {
+			if (shouldLog("warn")) console.warn(formatMessage("warn", tag, message), ...args);
+		},
+		error(message, ...args) {
+			if (shouldLog("error")) console.error(formatMessage("error", tag, message), ...args);
+		}
+	};
+}
+function setLogLevel(level) {
+	currentLevel = level;
+}
+//#endregion
+//#region src/main/scope.ts
+/**
+* `Scope` — engine-agnostic nested-lifetime primitive, generalizing the
+* Connection/Disposable semantics in this package (foundation.md §4).
+*
+* A `Scope` owns a single "lifetime segment". Resources bound via `own()` and
+* sub-scopes created via `child()` are released together — both on `reset()`
+* (soft reuse: dispose the segment, open a fresh one, stay alive) and `close()`
+* (terminal: dispose everything, die). Teardown is LIFO and, crucially,
+* `reset()`/`close()` are COMPLETION FENCES: their Promise resolves (and the
+* `'reset'`/`'closed'` listeners fire) only AFTER the underlying async
+* disposeAll has fully finished — unlike `connection.ts`, which fires the
+* teardown and forgets (`void ...disposeAll()`).
+*
+* Cross-layer LIFO: a scope's teardown disposes its child sub-scopes (deepest
+* first, recursively) BEFORE its own directly-owned resources, so a grandchild
+* tears down before a child, which tears down before the root.
+*/
+var log = createLogger("scope");
+function asInternal(s) {
+	return s;
+}
+/** True if `maybeAncestor` is `node` or an ancestor of it (walking parents). */
+function isSelfOrAncestor(maybeAncestor, node) {
+	let cur = node;
+	while (cur) {
+		if (cur === maybeAncestor) return true;
+		cur = cur.__parent().parent;
+	}
+	return false;
+}
+var NOOP_DISPOSABLE = { dispose() {} };
+function toDispose(d) {
+	return typeof d === "function" ? d : () => d.dispose();
+}
+/**
+* Dispose a resource handed to a dead scope's `own()` — immediately, exactly
+* once, never delegating to a disposed segment (that would throw). Both sync
+* throws and async rejections are caught/logged so a late teardown can never
+* escape as an unhandledRejection in the main process.
+*/
+function disposeLate(d) {
+	try {
+		const r = toDispose(d)();
+		if (r && typeof r.then === "function") r.catch((e) => log.error("late own() async disposer rejected", e));
+	} catch (e) {
+		log.error("late own() resource disposer threw", e);
+	}
+}
+function newSegment() {
+	return {
+		children: [],
+		resources: new DisposableRegistry()
+	};
+}
+async function disposeSegment(segment) {
+	const children = segment.children.slice().reverse();
+	segment.children = [];
+	for (const child of children) try {
+		await child.close();
+	} catch (e) {
+		log.error("child scope close threw during segment teardown", e);
+	}
+	await segment.resources.disposeAll();
+}
+function createScope() {
+	let segment = newSegment();
+	let alive = true;
+	let inFlight = null;
+	let inFlightKind = null;
+	const resetListeners = /* @__PURE__ */ new Set();
+	const closedListeners = /* @__PURE__ */ new Set();
+	let parent = null;
+	let owningSegment = null;
+	const childRemovers = /* @__PURE__ */ new Map();
+	function emit(ev) {
+		const set = ev === "reset" ? resetListeners : closedListeners;
+		for (const cb of [...set]) try {
+			cb();
+		} catch (e) {
+			log.error(`listener for "${ev}" threw`, e);
+		}
+	}
+	function runReset() {
+		const old = segment;
+		segment = newSegment();
+		inFlightKind = "reset";
+		const p = (async () => {
+			try {
+				await disposeSegment(old);
+			} finally {
+				if (inFlightKind === "reset") {
+					inFlight = null;
+					inFlightKind = null;
+					emit("reset");
+				}
+			}
+		})();
+		inFlight = p;
+		return p;
+	}
+	function runClose() {
+		alive = false;
+		const old = segment;
+		segment = newSegment();
+		inFlightKind = "close";
+		const p = (async () => {
+			try {
+				await disposeSegment(old);
+			} finally {
+				inFlight = null;
+				inFlightKind = null;
+				emit("closed");
+			}
+		})();
+		inFlight = p;
+		return p;
+	}
+	function attachChild(child, seg) {
+		seg.children.push(child);
+		const remover = child.on("closed", () => {
+			const i = seg.children.indexOf(child);
+			if (i >= 0) seg.children.splice(i, 1);
+			childRemovers.delete(child);
+		});
+		childRemovers.set(child, remover);
+		child.__setParent(scope, seg);
+	}
+	function detachChild(child, seg) {
+		const i = seg.children.indexOf(child);
+		if (i >= 0) seg.children.splice(i, 1);
+		const remover = childRemovers.get(child);
+		if (remover) {
+			remover.dispose();
+			childRemovers.delete(child);
+		}
+		child.__setParent(null, null);
+	}
+	const scope = {
+		get alive() {
+			return alive;
+		},
+		__currentSegment() {
+			return segment;
+		},
+		__inFlight() {
+			return inFlight;
+		},
+		__parent() {
+			return {
+				parent,
+				owningSegment
+			};
+		},
+		__attachChild(child, seg) {
+			attachChild(child, seg);
+		},
+		__detachChild(child, seg) {
+			detachChild(child, seg);
+		},
+		__setParent(p, seg) {
+			parent = p;
+			owningSegment = seg;
+		},
+		own(d) {
+			if (!alive) {
+				disposeLate(d);
+				return NOOP_DISPOSABLE;
+			}
+			return segment.resources.add(d);
+		},
+		child() {
+			if (!alive) {
+				const dead = createScope();
+				dead.close();
+				return dead;
+			}
+			const sub = asInternal(createScope());
+			attachChild(sub, segment);
+			return sub;
+		},
+		reset() {
+			if (!alive) return inFlight ?? Promise.resolve();
+			if (inFlight) return inFlight;
+			return runReset();
+		},
+		close() {
+			if (!alive) return inFlight ?? Promise.resolve();
+			if (inFlight && inFlightKind === "close") return inFlight;
+			if (inFlight && inFlightKind === "reset") {
+				alive = false;
+				const afterReset = inFlight;
+				inFlightKind = "close";
+				const upgraded = (async () => {
+					await afterReset.catch(() => {});
+					const leftover = segment;
+					segment = newSegment();
+					try {
+						await disposeSegment(leftover);
+					} finally {
+						inFlight = null;
+						inFlightKind = null;
+						emit("closed");
+					}
+				})();
+				inFlight = upgraded;
+				return upgraded;
+			}
+			return runClose();
+		},
+		on(ev, cb) {
+			const set = ev === "reset" ? resetListeners : closedListeners;
+			set.add(cb);
+			let removed = false;
+			return { dispose() {
+				if (removed) return;
+				removed = true;
+				set.delete(cb);
+			} };
+		},
+		async adopt(childPublic, newParentPublic) {
+			const child = asInternal(childPublic);
+			const newParent = asInternal(newParentPublic);
+			const self = scope;
+			while (true) {
+				const f = self.__inFlight() ?? newParent.__inFlight();
+				if (!f) break;
+				await f.catch(() => {});
+			}
+			if (!self.alive) throw new Error("adopt: donor scope is not alive");
+			if (!newParent.alive) throw new Error("adopt: newParent scope is not alive");
+			const fromSegment = self.__currentSegment();
+			const toSegment = newParent.__currentSegment();
+			if (child.__parent().parent !== self || fromSegment.children.indexOf(child) < 0) throw new Error("adopt: child is not a direct child of this scope current segment");
+			if (isSelfOrAncestor(child, newParent)) throw new Error("adopt: would create a cycle (newParent is child or a descendant of it)");
+			self.__detachChild(child, fromSegment);
+			newParent.__attachChild(child, toSegment);
+		}
+	};
+	return scope;
+}
+//#endregion
+//#region src/main/compositor.ts
+/**
+* Typed failure thrown by {@link Compositor.commit}. `kind` distinguishes a
+* preflight refusal (`host-destroyed`, native byte-for-byte pre-commit,
+* `applied:false`) from a mid-apply native throw (`apply-failed`,
+* `applied:'partial'`); for `apply-failed`, `recovered` reports whether the
+* best-effort rollback restored the pre-apply snapshot order (`false` ⇒ native
+* is untrusted and the host must be treated as dead).
+*/
+var CommitError = class extends Error {
+	kind;
+	applied;
+	recovered;
+	constructor(args) {
+		super(args.message ?? `commit failed: ${args.kind}`);
+		this.name = "CommitError";
+		this.kind = args.kind;
+		this.applied = args.applied;
+		if (args.recovered !== void 0) this.recovered = args.recovered;
+	}
+};
+var DEFAULT_ZONE = 0;
+/**
+* Smallest representable gap between fractional keys before we renumber. Once a
+* midpoint would round to (or below) this distance from a neighbor, the zone is
+* rebalanced rather than risk key collision / loss of ordering.
+*/
+var MIN_KEY_GAP = 1e-9;
+function createCompositor(host) {
+	const views = /* @__PURE__ */ new Map();
+	let mountSeqCounter = 0;
+	/** Views in a zone, sorted by the in-zone order `(orderKey, viewId)`. */
+	function zoneSorted(zone) {
+		const out = [];
+		for (const v of views.values()) if (v.zone === zone) out.push(v);
+		out.sort(compareInZone);
+		return out;
+	}
+	function compareInZone(a, b) {
+		if (a.orderKey !== b.orderKey) return a.orderKey - b.orderKey;
+		return a.ref.id < b.ref.id ? -1 : a.ref.id > b.ref.id ? 1 : 0;
+	}
+	/** Full target order: zones ascending (low renders first/bottom), then
+	* in-zone order. */
+	function targetOrder() {
+		const all = [...views.values()];
+		all.sort((a, b) => {
+			if (a.zone !== b.zone) return a.zone - b.zone;
+			return compareInZone(a, b);
+		});
+		return all;
+	}
+	/** Next order key that lands a view at the TOP (end) of its zone. */
+	function topKey(zone) {
+		const z = zoneSorted(zone);
+		const last = z[z.length - 1];
+		return last === void 0 ? 0 : last.orderKey + 1;
+	}
+	/**
+	* Renumber a zone to evenly-spaced integer keys, preserving the current
+	* relative order exactly. Invisible: the visible order is unchanged, so a
+	* commit after a rebalance produces no extra host churn.
+	*/
+	function rebalanceZone(zone) {
+		zoneSorted(zone).forEach((v, i) => {
+			v.orderKey = i;
+		});
+	}
+	/**
+	* Compute the fractional key that places a view immediately before `anchor`
+	* within its zone (the midpoint between `anchor` and its predecessor), or at
+	* the zone top when `anchor` is null. If the midpoint would exhaust precision,
+	* rebalance the zone and recompute on the fresh integer keys.
+	*/
+	function keyBefore(zone, anchor, movingId) {
+		if (anchor === null) return topKey(zone);
+		const midpointBefore = (anchorId) => {
+			const z = zoneSorted(zone).filter((v) => v.ref.id !== movingId);
+			const idx = z.findIndex((v) => v.ref.id === anchorId);
+			const at = z[idx];
+			if (idx < 0 || at === void 0) return null;
+			const hiKey = at.orderKey;
+			const prev = z[idx - 1];
+			const loKey = prev !== void 0 ? prev.orderKey : hiKey - 1;
+			const mid = (loKey + hiKey) / 2;
+			if (mid <= loKey + MIN_KEY_GAP || mid >= hiKey - MIN_KEY_GAP) return null;
+			return mid;
+		};
+		const first = midpointBefore(anchor.ref.id);
+		if (first === null && zoneSorted(zone).some((v) => v.ref.id === anchor.ref.id)) {
+			rebalanceZone(zone);
+			const retry = midpointBefore(anchor.ref.id);
+			if (retry !== null) return retry;
+		}
+		return first ?? topKey(zone);
+	}
+	const compositor = {
+		mount(view, opts) {
+			const zone = opts?.zone ?? DEFAULT_ZONE;
+			if (views.get(view.id)) return;
+			views.set(view.id, {
+				ref: view,
+				zone,
+				orderKey: topKey(zone),
+				mountSeq: ++mountSeqCounter
+			});
+		},
+		unmount(viewId) {
+			views.delete(viewId);
+		},
+		reorder(viewId, opts) {
+			const mv = views.get(viewId);
+			if (!mv) throw new Error(`reorder: view "${viewId}" is not mounted`);
+			const before = opts.before;
+			const targetZone = opts.zone ?? mv.zone;
+			if (before === void 0 || before === null) {
+				mv.zone = targetZone;
+				mv.orderKey = topKey(targetZone);
+				return;
+			}
+			const anchor = views.get(before);
+			if (!anchor) throw new Error(`reorder: before anchor "${before}" is not mounted`);
+			if (opts.zone !== void 0 && anchor.zone !== opts.zone) throw new Error(`reorder: before anchor "${before}" is in zone ${anchor.zone}, which conflicts with the requested zone ${opts.zone}`);
+			mv.zone = anchor.zone;
+			mv.orderKey = keyBefore(anchor.zone, anchor, viewId);
+		},
+		commit() {
+			const target = targetOrder();
+			const targetIds = target.map((v) => v.ref.id);
+			const current = host.children().map((v) => v.id);
+			const targetSet = new Set(targetIds);
+			const currentSet = new Set(current);
+			const removals = [];
+			const additions = [];
+			const shared = targetIds.filter((id) => currentSet.has(id));
+			const currentIndexOf = /* @__PURE__ */ new Map();
+			current.forEach((id, i) => currentIndexOf.set(id, i));
+			const keepIds = /* @__PURE__ */ new Set();
+			let prevPos = -1;
+			for (const id of shared) {
+				const pos = currentIndexOf.get(id);
+				if (pos > prevPos) {
+					keepIds.add(id);
+					prevPos = pos;
+				} else break;
+			}
+			for (const v of host.children()) if (!targetSet.has(v.id)) removals.push(v);
+			target.forEach((v, i) => {
+				const isNew = !currentSet.has(v.ref.id);
+				const mustMove = currentSet.has(v.ref.id) && !keepIds.has(v.ref.id);
+				if (isNew || mustMove) additions.push({
+					ref: v.ref,
+					atIndex: i
+				});
+			});
+			if (removals.length === 0 && additions.length === 0) return;
+			if (host.isDestroyed) {
+				if (additions.length === 0) return;
+				throw new CommitError({
+					kind: "host-destroyed",
+					applied: false,
+					message: "commit: contentView is destroyed"
+				});
+			}
+			const snapshot = host.children().slice();
+			additions.sort((a, b) => a.atIndex - b.atIndex);
+			try {
+				for (const r of removals) host.removeChildView(r);
+				for (const a of additions) host.addChildView(a.ref);
+			} catch (applyErr) {
+				let recovered;
+				try {
+					for (const v of host.children().slice()) host.removeChildView(v);
+					for (const v of snapshot) host.addChildView(v);
+					recovered = true;
+				} catch {
+					recovered = false;
+				}
+				throw new CommitError({
+					kind: "apply-failed",
+					applied: "partial",
+					recovered,
+					message: `commit apply failed: ${applyErr?.message ?? applyErr}`
+				});
+			}
+		},
+		detachAll() {
+			for (const id of [...views.keys()]) views.delete(id);
+			compositor.commit();
+		}
+	};
+	return compositor;
+}
+//#endregion
+//#region src/main/view-handle.ts
+function createViewHandle(deps) {
+	const { nativeView } = deps;
+	const ref = nativeView.ref;
+	let current = null;
+	let currentZone;
+	let viewScope = null;
+	let owningWindowScope = null;
+	let active = false;
+	let visibleBounds = null;
+	let migrating = false;
+	let lockChain = Promise.resolve();
+	function withLock(fn) {
+		const run = lockChain.then(fn, fn);
+		lockChain = run.then(() => {}, () => {});
+		return run;
+	}
+	function ensureMounted() {
+		if (!current) return;
+		current.compositor.mount(ref, { zone: currentZone });
+		current.compositor.commit();
+	}
+	async function doDispose() {
+		if (!viewScope) return;
+		await viewScope.close();
+	}
+	async function doMove(dest, opts) {
+		if (!active || !current || !viewScope) throw new Error("moveTo: the view is not currently placed (disposed or never placed)");
+		const src = current;
+		const srcZone = currentZone;
+		const destZone = opts.zone;
+		const vs = viewScope;
+		src.compositor.unmount(ref.id);
+		try {
+			src.compositor.commit();
+		} catch (e) {
+			src.compositor.mount(ref, { zone: srcZone });
+			try {
+				src.compositor.commit();
+			} catch {
+				await doDispose();
+				throw e;
+			}
+			throw e;
+		}
+		dest.compositor.mount(ref, { zone: destZone });
+		try {
+			dest.compositor.commit();
+		} catch (destErr) {
+			dest.compositor.unmount(ref.id);
+			src.compositor.mount(ref, { zone: srcZone });
+			try {
+				src.compositor.commit();
+			} catch {
+				await doDispose();
+				throw destErr;
+			}
+			throw destErr;
+		}
+		current = {
+			compositor: dest.compositor,
+			windowScope: dest.windowScope
+		};
+		currentZone = destZone;
+		if (opts.rehome) {
+			const donor = owningWindowScope ?? src.windowScope;
+			try {
+				await donor.adopt(vs, dest.windowScope);
+			} catch (adoptErr) {
+				dest.compositor.unmount(ref.id);
+				try {
+					dest.compositor.commit();
+				} catch {}
+				src.compositor.mount(ref, { zone: srcZone });
+				current = src;
+				currentZone = srcZone;
+				try {
+					src.compositor.commit();
+				} catch {
+					await doDispose();
+					throw adoptErr;
+				}
+				throw adoptErr;
+			}
+			owningWindowScope = dest.windowScope;
+		}
+	}
+	const handle = {
+		placeIn(target, opts) {
+			if (viewScope) throw new Error("ViewHandle.placeIn: view already placed — use moveTo() to migrate");
+			current = {
+				compositor: target.compositor,
+				windowScope: target.windowScope
+			};
+			currentZone = opts.zone;
+			ensureMounted();
+			active = true;
+			const vs = target.windowScope.child();
+			viewScope = vs;
+			owningWindowScope = target.windowScope;
+			vs.own(() => {
+				if (current) {
+					current.compositor.unmount(ref.id);
+					current.compositor.commit();
+				}
+				deps.nativeView.destroy?.();
+			});
+			vs.own(() => {
+				active = false;
+			});
+			vs.own(() => {
+				deps.onDispose?.();
+			});
+			return handle;
+		},
+		applyPlacement(p) {
+			if (!active || !current) return;
+			if (migrating) return;
+			if (p.visible) {
+				ensureMounted();
+				nativeView.setBounds(p.bounds);
+				visibleBounds = {
+					x: p.bounds.x,
+					y: p.bounds.y,
+					width: p.bounds.width,
+					height: p.bounds.height
+				};
+			} else {
+				current.compositor.unmount(ref.id);
+				current.compositor.commit();
+				visibleBounds = null;
+			}
+		},
+		moveTo(dest, opts) {
+			return withLock(async () => {
+				migrating = true;
+				try {
+					return await doMove(dest, opts);
+				} finally {
+					migrating = false;
+				}
+			});
+		},
+		dispose() {
+			return withLock(() => doDispose());
+		},
+		get webContents() {
+			return nativeView.webContents;
+		},
+		bounds() {
+			if (!active || !visibleBounds) return null;
+			return { ...visibleBounds };
+		},
+		capturePage() {
+			if (!nativeView.capturePage) return Promise.reject(/* @__PURE__ */ new Error("ViewHandle.capturePage: native view has no capturePage"));
+			return nativeView.capturePage();
+		}
+	};
+	return handle;
+}
+//#endregion
+export { createLogger as a, toDisposable as c, createScope as i, CommitError as n, setLogLevel as o, createCompositor as r, DisposableRegistry as s, createViewHandle as t };
+
+//# sourceMappingURL=view-handle-CR-yWNfr.js.map