@dashfoo/core 0.5.2 → 1.0.0

package/dist/index.js

@@ -1,7 +1,31 @@
 import { z } from "zod";
 import { assign, emit, setup } from "xstate";
 
+//#region src/lib/clamp-selected.ts
+/**
+* Lives in `lib/` rather than beside `normalize`, because both the parse
+* boundary (`tabsetNodeSchema`) and the tree walker that `normalize` uses need
+* it, and importing it from either one would close a module cycle.
+*/
+const clampSelected = (length, selected) => {
+	if (length === 0) return 0;
+	const base = Number.isFinite(selected) ? Math.trunc(selected) : 0;
+	if (base < 0) return 0;
+	if (base > length - 1) return length - 1;
+	return base;
+};
+
+//#endregion
 //#region src/model/schema.ts
+/**
+* Weights are relative shares, and every reader that rendered one already
+* treated a missing weight as a single share (`row-view` summed `weight ?? 1`),
+* so filling it in at the boundary changes nothing on screen. The one place that
+* read a missing weight as a percentage was `placeBesideTarget`, which is why
+* docking beside an unweighted target halved it to `50` and left its unweighted
+* siblings rendering as a sliver of the row.
+*/
+const DEFAULT_WEIGHT = 1;
 const jsonValueSchema = z.lazy(() => z.union([
 	z.string(),
 	z.number(),
@@ -44,7 +68,14 @@ const tabNodeSchema = z.object({
 	name: z.string(),
 	type: z.literal("tab")
 });
-const tabsetNodeSchema = z.object({
+/**
+* The pre-transform object, kept separate so `node-attrs` can `.pick()` mutable
+* keys off it. Picking from the transformed schema is impossible (a pipe has no
+* `.pick`), and picking `weight` with its default attached would inject that
+* default: `.partial()` over a defaulted field still fills it in, which would
+* rewrite a tabset's weight on every unrelated attribute update.
+*/
+const tabsetNodeObjectSchema = z.object({
 	children: z.array(tabNodeSchema),
 	enableClose: z.boolean().optional(),
 	enableMaximize: z.boolean().optional(),
@@ -54,8 +85,12 @@ const tabsetNodeSchema = z.object({
 	name: z.string().optional(),
 	selected: z.number().int(),
 	type: z.literal("tabset"),
-	weight: z.number().optional()
+	weight: z.number().default(1)
 });
+const tabsetNodeSchema = tabsetNodeObjectSchema.transform((tabset) => ({
+	...tabset,
+	selected: clampSelected(tabset.children.length, tabset.selected)
+}));
 const rowNodeSchema = z.lazy(() => z.object({
 	children: z.array(z.union([rowNodeSchema, tabsetNodeSchema])),
 	id: z.string(),
@@ -64,7 +99,7 @@ const rowNodeSchema = z.lazy(() => z.object({
 	orientation: orientationSchema,
 	snap: snapSchema.optional(),
 	type: z.literal("row"),
-	weight: z.number().optional()
+	weight: z.number().default(1)
 }));
 const geometrySchema = z.object({
 	height: z.number(),
@@ -95,7 +130,7 @@ const globalAttributesSchema = z.object({
 });
 const dashfooSchema = z.object({
 	activeTabsetId: z.string().optional(),
-	floats: z.array(floatNodeSchema).optional(),
+	floats: z.array(floatNodeSchema).default(() => []),
 	global: globalAttributesSchema,
 	layout: rowNodeSchema,
 	maximizedTabsetId: z.string().optional(),
@@ -103,7 +138,7 @@ const dashfooSchema = z.object({
 });
 
 //#endregion
-//#region src/state/actions.ts
+//#region src/state/node-attrs.ts
 const mutableTabAttrsSchema = tabNodeSchema.pick({
 	config: true,
 	enableClose: true,
@@ -111,14 +146,18 @@ const mutableTabAttrsSchema = tabNodeSchema.pick({
 	enableRename: true,
 	name: true
 }).partial();
-const mutableTabsetAttrsSchema = tabsetNodeSchema.pick({
+/**
+* `weight` is re-declared instead of picked: `.partial()` over the schema's
+* defaulted `weight` still injects the default, so `{ name: "x" }` would arrive
+* at the reducer carrying a weight and silently resize the tabset.
+*/
+const mutableTabsetAttrsSchema = tabsetNodeObjectSchema.pick({
 	enableClose: true,
 	enableMaximize: true,
 	max: true,
 	min: true,
-	selected: true,
-	weight: true
-}).partial();
+	selected: true
+}).extend({ weight: z.number() }).partial();
 const mutableRowAttrsSchema = z.object({
 	max: dimensionSchema.optional(),
 	min: dimensionSchema.optional(),
@@ -126,11 +165,19 @@ const mutableRowAttrsSchema = z.object({
 	snap: snapSchema.optional(),
 	weight: z.number()
 }).partial();
-const mutableNodeAttrsSchema = z.union([
-	mutableTabAttrsSchema,
-	mutableTabsetAttrsSchema,
-	mutableRowAttrsSchema
-]);
+/**
+* One all-optional object carrying every mutable key of every node kind, not a
+* union of the three: a union whose members are all fully optional matches on
+* its first member and strips the keys the others own, which erased every
+* tabset and row attribute at the parse boundary. The four keys that two kinds
+* share (`enableClose`, `max`, `min`, `weight`) declare the same type on both
+* sides, so merging widens nothing. Which keys are legal for a given node is
+* enforced by the reducer against that node's own schema.
+*/
+const mutableNodeAttrsSchema = mutableTabAttrsSchema.extend(mutableTabsetAttrsSchema.shape).extend(mutableRowAttrsSchema.shape);
+
+//#endregion
+//#region src/state/actions.ts
 const dockLocationSchema = z.enum([
 	"center",
 	"split-bottom",
@@ -243,8 +290,8 @@ const createTabId = () => createNodeId("tab");
 
 //#endregion
 //#region src/model/tree.ts
-const collectRoots = (model) => [model.layout, ...(model.floats ?? []).map((float) => float.layout)];
-const findFloat = (model, floatId) => (model.floats ?? []).find((float) => float.id === floatId);
+const collectRoots = (model) => [model.layout, ...model.floats.map((float) => float.layout)];
+const findFloat = (model, floatId) => model.floats.find((float) => float.id === floatId);
 /**
 * Depth-first pre-order over one root: the row itself, then each child in
 * order, descending into nested rows and into a tabset's tabs. Returning a
@@ -344,7 +391,7 @@ const collectIdsInRow = (row, acc) => {
 };
 const findDuplicateIds = (model) => {
 	const ids = [];
-	for (const float of model.floats ?? []) ids.push(float.id);
+	for (const float of model.floats) ids.push(float.id);
 	for (const root of collectRoots(model)) collectIdsInRow(root, ids);
 	const seen = /* @__PURE__ */ new Set();
 	const duplicates = /* @__PURE__ */ new Set();
@@ -377,7 +424,8 @@ const tabset = (children, options = {}) => {
 		...max === void 0 ? {} : { max: toDimension(max) },
 		...min === void 0 ? {} : { min: toDimension(min) },
 		id: options.id ?? createNodeId("tabset"),
-		selected: options.selected ?? 0
+		selected: clampSelected(children.length, options.selected ?? 0),
+		weight: options.weight ?? 1
 	};
 };
 const row = (children, options = {}) => {
@@ -389,7 +437,8 @@ const row = (children, options = {}) => {
 		...max === void 0 ? {} : { max: toDimension(max) },
 		...min === void 0 ? {} : { min: toDimension(min) },
 		id: options.id ?? createNodeId("row"),
-		orientation: options.orientation ?? "row"
+		orientation: options.orientation ?? "row",
+		weight: options.weight ?? 1
 	};
 };
 const floatNode = (layout, geometry, options = {}) => ({
@@ -404,6 +453,7 @@ const model = (layout, options = {}) => {
 		layout,
 		version: 1,
 		...options,
+		floats: options.floats ?? [],
 		global: options.global ?? {}
 	};
 	const duplicates = findDuplicateIds(built);
@@ -411,6 +461,12 @@ const model = (layout, options = {}) => {
 	return built;
 };
 
+//#endregion
+//#region src/lib/assert-never.ts
+const assertNever = (value) => {
+	throw new Error(`Unhandled variant: ${JSON.stringify(value)}`);
+};
+
 //#endregion
 //#region src/geometry/geometry.ts
 const DEFAULT_BAND_FRACTION = .22;
@@ -431,6 +487,23 @@ const closestEdge = (d) => {
 	if (min === d.top) return "top";
 	return "bottom";
 };
+const dockLocationFor = (target) => {
+	switch (target.kind) {
+		case "split": return `split-${target.edge}`;
+		case "tab": return "center";
+		default: return assertNever(target);
+	}
+};
+const splitEdge = (location) => {
+	switch (location) {
+		case "center": return;
+		case "split-bottom": return "bottom";
+		case "split-left": return "left";
+		case "split-right": return "right";
+		case "split-top": return "top";
+		default: return assertNever(location);
+	}
+};
 const resolveDockTarget = (pointer, rect, opts) => {
 	const band = opts?.bandFraction ?? DEFAULT_BAND_FRACTION;
 	if (rect.width <= 0 || rect.height <= 0) return { kind: "tab" };
@@ -564,7 +637,7 @@ const zoneRect = (rect, location) => {
 			y: rect.y
 		};
 		case "center": return rect;
-		default: return rect;
+		default: return assertNever(location);
 	}
 };
 
@@ -626,20 +699,21 @@ const snapSizes = (sizes, boundaryIndex, config) => {
 		snapped: true
 	};
 };
+const decideSnap = (sizes, boundaryIndex, config) => {
+	if (boundaryIndex === null || config === null || !snapEnabled(config)) return { kind: "inactive" };
+	const { sizes: snappedSizes, snapped } = snapSizes(sizes, boundaryIndex, config);
+	return snapped ? {
+		kind: "engage",
+		sizes: snappedSizes
+	} : { kind: "clear" };
+};
+const settleSnap = (sizes, boundaryIndex, config) => {
+	const decision = decideSnap(sizes, boundaryIndex, config);
+	return decision.kind === "engage" ? decision.sizes : sizes;
+};
 
 //#endregion
 //#region src/model/invariants.ts
-const clampSelected = (length, selected) => {
-	if (length === 0) return 0;
-	const base = Number.isFinite(selected) ? Math.trunc(selected) : 0;
-	if (base < 0) return 0;
-	if (base > length - 1) return length - 1;
-	return base;
-};
-const normalizeTabset = (tabset) => ({
-	...tabset,
-	selected: clampSelected(tabset.children.length, tabset.selected)
-});
 /**
 * A row that collapses to a single child hands its slot in the parent to
 * that child, so the slot's sizing constraints have to travel with it.
@@ -651,7 +725,7 @@ const normalizeTabset = (tabset) => ({
 const inheritSlot = (row, survivor) => {
 	const sized = {
 		...survivor,
-		...row.weight === void 0 ? {} : { weight: row.weight },
+		weight: row.weight,
 		...row.min === void 0 ? {} : { min: row.min },
 		...row.max === void 0 ? {} : { max: row.max }
 	};
@@ -665,7 +739,7 @@ const normalizeRowChildren = (children) => {
 	const out = [];
 	for (const child of children) {
 		if (child.type === "tabset") {
-			if (child.children.length > 0) out.push(normalizeTabset(child));
+			if (child.children.length > 0) out.push(child);
 			continue;
 		}
 		const grandchildren = normalizeRowChildren(child.children);
@@ -700,22 +774,22 @@ const normalizeLayout = (root) => {
 };
 const normalize = (model) => {
 	const layout = normalizeLayout(model.layout);
-	const healedFloats = [];
-	for (const float of model.floats ?? []) {
+	const floats = [];
+	for (const float of model.floats) {
 		const floatLayout = normalizeLayout(float.layout);
-		if (rowContainsTabset(floatLayout)) healedFloats.push({
+		if (rowContainsTabset(floatLayout)) floats.push({
 			...float,
 			layout: floatLayout
 		});
 	}
-	const floats = healedFloats.length > 0 ? healedFloats : void 0;
 	const withRoots = {
 		...model,
 		floats,
 		layout
 	};
-	const tabsetIds = new Set(collectTabsets(withRoots).map((tabset) => tabset.id));
-	const firstTabsetId = collectTabsets(withRoots)[0]?.id;
+	const tabsets = collectTabsets(withRoots);
+	const tabsetIds = new Set(tabsets.map((tabset) => tabset.id));
+	const firstTabsetId = tabsets[0]?.id;
 	const activeTabsetId = model.activeTabsetId !== void 0 && tabsetIds.has(model.activeTabsetId) ? model.activeTabsetId : firstTabsetId;
 	const maximizedTabsetId = model.maximizedTabsetId !== void 0 && tabsetIds.has(model.maximizedTabsetId) ? model.maximizedTabsetId : void 0;
 	return {
@@ -734,30 +808,33 @@ const removeTabsetReturning = (row, tabsetId) => {
 	return removed?.type === "tabset" ? removed : void 0;
 };
 const removeTabset = (row, tabsetId) => removeTabsetReturning(row, tabsetId) !== void 0;
-const splitOrientation = (location) => location === "split-left" || location === "split-right" ? "row" : "column";
-const splitsBefore = (location) => location === "split-left" || location === "split-top";
+const splitPlacement = (location) => {
+	const edge = splitEdge(location);
+	return {
+		before: edge === "left" || edge === "top",
+		orientation: edge === "left" || edge === "right" ? "row" : "column"
+	};
+};
 const placeBesideTarget = (draft, placed, targetId, location) => {
 	const targetTabset = findTabset(draft, targetId);
 	const found = findTabsetParent(findRootContaining(draft, targetId) ?? draft.layout, targetId);
 	if (!targetTabset || !found) return;
-	const orientation = splitOrientation(location);
-	const before = splitsBefore(location);
+	const { before, orientation } = splitPlacement(location);
 	if (found.parent.orientation === orientation) {
-		const targetWeight = targetTabset.weight ?? 100;
-		targetTabset.weight = targetWeight / 2;
-		placed.weight = targetWeight / 2;
+		const half = targetTabset.weight / 2;
+		targetTabset.weight = half;
+		placed.weight = half;
 		found.parent.children.splice(before ? found.index : found.index + 1, 0, placed);
 	} else {
-		const targetWeight = targetTabset.weight;
-		targetTabset.weight = 50;
-		placed.weight = 50;
 		const newRow = {
 			children: before ? [placed, targetTabset] : [targetTabset, placed],
 			id: createNodeId("row"),
 			orientation,
-			type: "row"
+			type: "row",
+			weight: targetTabset.weight
 		};
-		if (targetWeight !== void 0) newRow.weight = targetWeight;
+		targetTabset.weight = 50;
+		placed.weight = 50;
 		found.parent.children.splice(found.index, 1, newRow);
 	}
 	draft.activeTabsetId = placed.id;
@@ -767,7 +844,7 @@ const insertTab = (draft, tab, target) => {
 	const targetTabset = findTabset(draft, targetId);
 	if (!targetTabset) return;
 	if (location === "center") {
-		const at = index ?? targetTabset.children.length;
+		const at = Math.min(Math.max(index ?? targetTabset.children.length, 0), targetTabset.children.length);
 		targetTabset.children.splice(at, 0, tab);
 		targetTabset.selected = at;
 		return;
@@ -777,10 +854,20 @@ const insertTab = (draft, tab, target) => {
 		id: createNodeId("tabset"),
 		selected: 0,
 		type: "tabset",
-		weight: 50
+		weight: 1
 	};
 	placeBesideTarget(draft, newTabset, targetId, location);
 };
+/**
+* Removing a tab can leave `selected` past the end of the strip, so every
+* detach re-clamps its container rather than leaving the whole tree to be
+* re-walked afterwards.
+*/
+const detachTab = (container, index) => {
+	const removed = container.children.splice(index, 1).at(0);
+	container.selected = clampSelected(container.children.length, container.selected);
+	return removed;
+};
 const mergeTabsInto = (target, tabs, selectedOffset) => {
 	const mergeStart = target.children.length;
 	target.children.push(...tabs);
@@ -791,17 +878,20 @@ const wrapTabInLayout = (tab) => ({
 		children: [tab],
 		id: createNodeId("tabset"),
 		selected: 0,
-		type: "tabset"
+		type: "tabset",
+		weight: 1
 	}],
 	id: createNodeId("row"),
 	orientation: "row",
-	type: "row"
+	type: "row",
+	weight: 1
 });
 const wrapTabsetInLayout = (tabset) => ({
 	children: [tabset],
 	id: createNodeId("row"),
 	orientation: "row",
-	type: "row"
+	type: "row",
+	weight: 1
 });
 
 //#endregion
@@ -824,10 +914,10 @@ const pushFloat = (draft, layout, geometry, floatId) => {
 		geometry: geometry ?? DEFAULT_FLOAT_GEOMETRY,
 		id: floatId ?? createNodeId("float"),
 		layout,
-		name: uniqueFloatName("Panel", draft.floats ?? []),
+		name: uniqueFloatName("Panel", draft.floats),
 		type: "float"
 	};
-	draft.floats = [...draft.floats ?? [], float];
+	draft.floats = [...draft.floats, float];
 	const tabsets = [];
 	collectTabsetsInRow(layout, tabsets);
 	const first = tabsets.at(0);
@@ -853,11 +943,10 @@ const resolveMainTarget = (draft, targetId) => {
 	return mainTabsets[0];
 };
 const dockFloat = (draft, floatId, targetId, location) => {
-	const floats = draft.floats ?? [];
+	const floats = draft.floats;
 	const index = floats.findIndex((float) => float.id === floatId);
 	if (index === -1) return;
 	const float = floats.splice(index, 1).at(0);
-	draft.floats = floats;
 	if (!float) return;
 	const tabsets = [];
 	collectTabsetsInRow(float.layout, tabsets);
@@ -877,20 +966,30 @@ const dockFloat = (draft, floatId, targetId, location) => {
 		return;
 	}
 	const where = location ?? "split-right";
-	const placed = tabsets.length === 1 && leadTabset ? leadTabset : {
+	placeBesideTarget(draft, tabsets.length === 1 && leadTabset ? leadTabset : {
 		children: tabs,
 		id: createNodeId("tabset"),
 		selected: selectedOffset,
-		type: "tabset"
-	};
-	placed.weight = 50;
-	placeBesideTarget(draft, placed, target.id, where);
+		type: "tabset",
+		weight: 1
+	}, target.id, where);
 };
 
 //#endregion
 //#region src/state/reducer.ts
-const assertNever = (value) => {
-	throw new Error(`Unhandled action: ${JSON.stringify(value)}`);
+const parseNodeAttrs = (node, attrs) => {
+	switch (node.type) {
+		case "row": return mutableRowAttrsSchema.parse(attrs);
+		case "tab": return mutableTabAttrsSchema.parse(attrs);
+		case "tabset": {
+			const parsed = mutableTabsetAttrsSchema.parse(attrs);
+			return parsed.selected === void 0 ? parsed : {
+				...parsed,
+				selected: clampSelected(node.children.length, parsed.selected)
+			};
+		}
+		default: return assertNever(node);
+	}
 };
 const applyAction = (draft, action) => {
 	switch (action.type) {
@@ -914,7 +1013,7 @@ const applyAction = (draft, action) => {
 		}
 		case "deleteTab": {
 			const location = findTab(draft, action.tabId);
-			if (location) location.container.children.splice(location.index, 1);
+			if (location) detachTab(location.container, location.index);
 			return;
 		}
 		case "deleteTabset": {
@@ -928,7 +1027,7 @@ const applyAction = (draft, action) => {
 		case "floatTab": {
 			const location = findTab(draft, action.tabId);
 			if (!location) return;
-			const removed = location.container.children.splice(location.index, 1).at(0);
+			const removed = detachTab(location.container, location.index);
 			if (removed) pushFloat(draft, wrapTabInLayout(removed), action.geometry, action.floatId);
 			return;
 		}
@@ -943,7 +1042,7 @@ const applyAction = (draft, action) => {
 		case "moveNode": {
 			const source = findTab(draft, action.sourceId);
 			if (!source) return;
-			const removed = source.container.children.splice(source.index, 1).at(0);
+			const removed = detachTab(source.container, source.index);
 			if (!removed) return;
 			insertTab(draft, removed, {
 				id: action.targetId,
@@ -965,17 +1064,15 @@ const applyAction = (draft, action) => {
 				}
 				return;
 			}
-			if (action.location.startsWith("split-")) {
-				const sourceRoot = findRootContaining(draft, action.sourceId);
-				const detached = sourceRoot ? removeTabsetReturning(sourceRoot, action.sourceId) : void 0;
-				if (detached) placeBesideTarget(draft, detached, action.targetId, action.location);
-			}
+			const sourceRoot = findRootContaining(draft, action.sourceId);
+			const detached = sourceRoot ? removeTabsetReturning(sourceRoot, action.sourceId) : void 0;
+			if (detached) placeBesideTarget(draft, detached, action.targetId, action.location);
 			return;
 		}
 		case "renameFloat": {
 			const float = findFloat(draft, action.floatId);
 			if (float) {
-				const others = (draft.floats ?? []).filter((other) => other.id !== action.floatId);
+				const others = draft.floats.filter((other) => other.id !== action.floatId);
 				float.name = uniqueFloatName(action.name, others);
 			}
 			return;
@@ -987,7 +1084,7 @@ const applyAction = (draft, action) => {
 		}
 		case "selectTab": {
 			const tabset = findTabset(draft, action.tabsetId);
-			if (tabset) tabset.selected = action.index;
+			if (tabset) tabset.selected = clampSelected(tabset.children.length, action.index);
 			return;
 		}
 		case "setActiveTabset":
@@ -1006,7 +1103,7 @@ const applyAction = (draft, action) => {
 			return;
 		case "updateNodeAttributes": {
 			const node = findAttributedNode(draft, action.nodeId);
-			if (node) Object.assign(node, action.attrs);
+			if (node) Object.assign(node, parseNodeAttrs(node, action.attrs));
 			return;
 		}
 		default: assertNever(action);
@@ -1164,12 +1261,13 @@ const stackModel = (model, orientation = "column") => {
 			children,
 			id: model.layout.id,
 			orientation,
-			type: "row"
+			type: "row",
+			weight: model.layout.weight
 		},
 		maximizedTabsetId: void 0
 	});
 };
 
 //#endregion
-export { DEFAULT_SNAP_THRESHOLD, HISTORY_LIMIT, actionSchema, canRedo, canUndo, collectRoots, collectTabsets, collectTabsetsInRow, createHistory, createNodeId, createTabId, dashfooMachine, dashfooSchema, dimensionSchema, dispatch, dockLocationSchema, dockZonePolygons, dragDockMachine, edgeSchema, findAttributedNode, findDuplicateIds, findFloat, findRootContaining, findRow, findTab, findTabset, findTabsetParent, floatNode, floatNodeSchema, fromJSON, geometrySchema, getFirstTabset, globalAttributesSchema, jsonValueSchema, model, mutableNodeAttrsSchema, normalize, orientationSchema, parseModel, redo, reducer, resolveDockTarget, resolveSnapTargets, row, rowNodeSchema, snapEnabled, snapSchema, snapSizes, stackModel, tab, tabNodeSchema, tabset, tabsetNodeSchema, toJSON, undo, unitSchema, zoneRect };
+export { DEFAULT_SNAP_THRESHOLD, DEFAULT_WEIGHT, HISTORY_LIMIT, actionSchema, canRedo, canUndo, collectRoots, collectTabsets, collectTabsetsInRow, createHistory, createNodeId, createTabId, dashfooMachine, dashfooSchema, decideSnap, dimensionSchema, dispatch, dockLocationFor, dockLocationSchema, dockZonePolygons, dragDockMachine, edgeSchema, findAttributedNode, findDuplicateIds, findFloat, findRootContaining, findRow, findTab, findTabset, findTabsetParent, floatNode, floatNodeSchema, fromJSON, geometrySchema, getFirstTabset, globalAttributesSchema, jsonValueSchema, model, mutableNodeAttrsSchema, normalize, orientationSchema, parseModel, redo, reducer, resolveDockTarget, resolveSnapTargets, row, rowNodeSchema, settleSnap, snapEnabled, snapSchema, snapSizes, splitEdge, stackModel, tab, tabNodeSchema, tabset, tabsetNodeObjectSchema, tabsetNodeSchema, toJSON, undo, unitSchema, zoneRect };
 //# sourceMappingURL=index.js.map