@dimina-kit/electron-deck 0.1.0-dev.20260711141929 → 0.1.0-dev.20260716153350

package/dist/dock-react/index.js

@@ -1,4 +1,4 @@
-import { a as closePanelForUser, c as extractPanel, d as setActive, g as findGroupById, h as countPanels, m as splitPanel, p as setSizes, u as movePanel, v as findPanelGroupId } from "../layout-D-LYJIpM.js";
+import { _ as countPanels, a as closePanelForUser, b as findPanelGroupId, c as extractPanel, d as setActive, h as splitPanel, p as setSizes, u as movePanel, v as findGroupById } from "../layout-CxEGC10g.js";
 import { Fragment, createContext, useCallback, useContext, useEffect, useRef, useState } from "react";
 import { Group, Panel, Separator } from "react-resizable-panels";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -276,20 +276,40 @@ function layoutsEquivalent(a, b, ids, epsilon = LAYOUT_EPSILON) {
 * Build the panel-ID→PERCENTAGE map for an imperative `setLayout`, given the
 * model's full-length raw `sizes` (per child) and `constraints`:
 *
-*  - FIXED (px-pinned) children keep their CURRENT measured percentage (read
-*    from the live `getLayout()`); they are NOT derived from weights, so a
-*    flexible-weights change never disturbs their pixel lock.
+*  - FIXED (px-pinned) children normally keep their CURRENT measured
+*    percentage (read from the live `getLayout()`) — they are NOT derived
+*    from weights, so a flexible-weights change never disturbs their pixel
+*    lock. When `measured` is supplied, a `fixedPx` child is instead always
+*    computed from the real container size (it never legitimately differs
+*    from its exact px value), and a `minPx` child is too, but ONLY when
+*    `measured.trustLiveForMinPx` is `false` — see `MeasuredContainer`. This
+*    matters because right after `<Group>` cold-mounts a `minPx`/`fixedPx`
+*    child whose content is itself a NESTED split, rrp's own mount-time
+*    px→percentage conversion for that child can land on a degenerate ratio
+*    (observed: a pinned child grabbing ~99% while its lone flexible sibling
+*    collapses to rrp's floor) — the live layout it reports is simply wrong,
+*    and blindly trusting it would perpetuate the collapse forever (there is
+*    no subsequent event that would ever correct it).
 *  - The REMAINING percentage (100 − Σ fixed%) is distributed across the
 *    FLEXIBLE children in proportion to their weights.
 *
 * Returns `null` when the map can't be built faithfully (e.g. `live` is empty —
-* jsdom's stub — or a fixed child's live % is missing), so the caller skips the
-* `setLayout` rather than pushing a corrupt total. The result always sums to
-* ~100 over all children.
+* jsdom's stub — or a fixed child's live % is missing and no `measured`
+* fallback applies), so the caller skips the `setLayout` rather than pushing a
+* corrupt total. The result always sums to ~100 over all children.
 */
-function buildSetLayoutMap(childIds, sizes, constraints, live) {
+function buildSetLayoutMap(childIds, sizes, constraints, live, measured) {
 	const isFixedAt = (i) => (constraints?.[i] ?? null) !== null;
-	const fixedTotal = sumFixedLivePercent(childIds, isFixedAt, live);
+	const fixedPercentAt = (i) => {
+		const constraint = constraints?.[i] ?? null;
+		if (measured && measured.containerPx > 0 && constraint) {
+			if (constraint.fixedPx != null) return constraint.fixedPx / measured.containerPx * 100;
+			if (constraint.minPx != null && !measured.trustLiveForMinPx) return constraint.minPx / measured.containerPx * 100;
+		}
+		const livePct = live[childIds[i]];
+		return typeof livePct === "number" ? livePct : null;
+	};
+	const fixedTotal = sumFixedPercent(childIds, isFixedAt, fixedPercentAt);
 	if (fixedTotal === null) return null;
 	const remaining = Math.max(0, 100 - fixedTotal);
 	let flexWeightTotal = 0;
@@ -303,22 +323,22 @@ function buildSetLayoutMap(childIds, sizes, constraints, live) {
 	const out = {};
 	for (let i = 0; i < childIds.length; i++) {
 		const id = childIds[i];
-		out[id] = isFixedAt(i) ? live[id] : flexibleShare(sizes[i] ?? 0, remaining, flexWeightTotal, flexibleCount);
+		out[id] = isFixedAt(i) ? fixedPercentAt(i) : flexibleShare(sizes[i] ?? 0, remaining, flexWeightTotal, flexibleCount);
 	}
 	return out;
 }
 /**
-* Sum the fixed children's CURRENT live percentages (preserving their px
-* lock). Null when a fixed child has no measured live % — the caller cannot
-* build a faithful map then.
+* Sum the fixed children's target percentages (via `fixedPercentAt`). Null
+* when any fixed child has no usable percentage — the caller cannot build a
+* faithful map then.
 */
-function sumFixedLivePercent(childIds, isFixedAt, live) {
+function sumFixedPercent(childIds, isFixedAt, fixedPercentAt) {
 	let fixedTotal = 0;
 	for (let i = 0; i < childIds.length; i++) {
 		if (!isFixedAt(i)) continue;
-		const livePct = live[childIds[i]];
-		if (typeof livePct !== "number") return null;
-		fixedTotal += livePct;
+		const pct = fixedPercentAt(i);
+		if (pct === null) return null;
+		fixedTotal += pct;
 	}
 	return fixedTotal;
 }
@@ -370,6 +390,7 @@ function SplitView(props) {
 	const flexCount = node.children.filter((_, i) => (node.constraints?.[i] ?? null) === null).length;
 	const flexMinSize = String(flexibleFloor(flexCount));
 	const groupRef = useRef(null);
+	const containerElRef = useRef(null);
 	const nodeRef = useRef(node);
 	nodeRef.current = node;
 	const items = [];
@@ -418,6 +439,7 @@ function SplitView(props) {
 		ctx.onApplyLayout(cur.id, clampFlexibleWeights(weights, cur.constraints));
 	};
 	const setSplitRef = (el) => {
+		containerElRef.current = el;
 		if (el) {
 			el.__deckApplyLayout = (weights) => {
 				const cur = nodeRef.current;
@@ -431,22 +453,61 @@ function SplitView(props) {
 			});
 		}
 	};
-	const runSync = useCallback(() => {
+	const runSync = useCallback((isFreshRemount) => {
 		const api = groupRef.current;
-		if (!api) return false;
+		if (!api) return {
+			pushed: false,
+			stuck: false
+		};
 		const cur = nodeRef.current;
 		const curChildIds = cur.children.map((c) => c.id);
 		const live = api.getLayout();
-		const targetMap = buildSetLayoutMap(curChildIds, cur.sizes, cur.constraints, live);
-		if (!targetMap) return false;
-		if (layoutsEquivalent(live, targetMap, curChildIds)) return false;
+		const containerRect = containerElRef.current?.getBoundingClientRect();
+		const containerPx = containerRect ? cur.orientation === "row" ? containerRect.width : containerRect.height : 0;
+		const measured = containerPx > 0 ? {
+			containerPx,
+			trustLiveForMinPx: !isFreshRemount
+		} : void 0;
+		const targetMap = buildSetLayoutMap(curChildIds, cur.sizes, cur.constraints, live, measured);
+		if (!targetMap) return {
+			pushed: false,
+			stuck: false
+		};
+		if (layoutsEquivalent(live, targetMap, curChildIds)) return {
+			pushed: false,
+			stuck: true
+		};
 		api.setLayout(targetMap);
-		return true;
+		return {
+			pushed: true,
+			stuck: layoutsEquivalent(api.getLayout(), targetMap, curChildIds)
+		};
 	}, []);
 	const sizesKey = node.sizes.join(",");
 	const childCountKey = node.children.length;
+	const prevChildCountKeyRef = useRef(null);
+	const MAX_FRESH_REMOUNT_SYNC_ATTEMPTS = 8;
 	useEffect(() => {
-		runSync();
+		const isFreshRemount = prevChildCountKeyRef.current !== childCountKey;
+		prevChildCountKeyRef.current = childCountKey;
+		if (!isFreshRemount) {
+			runSync(false);
+			return;
+		}
+		let cancelled = false;
+		let rafId = 0;
+		let attempts = 0;
+		const tick = () => {
+			if (cancelled) return;
+			attempts += 1;
+			const { stuck } = runSync(true);
+			if (!stuck && attempts < MAX_FRESH_REMOUNT_SYNC_ATTEMPTS) rafId = requestAnimationFrame(tick);
+		};
+		rafId = requestAnimationFrame(tick);
+		return () => {
+			cancelled = true;
+			cancelAnimationFrame(rafId);
+		};
 	}, [
 		sizesKey,
 		childCountKey,