@konitif/workbench 0.284.1

package/dist/application/workspace/dockPanel.js

@@ -0,0 +1,399 @@
+import { getActiveWindow } from "../../domain/workspace/selectors.js";
+import { findStack } from "../../domain/layout/selectors.js";
+import { createSplit, createStack } from "../../domain/workspace/factories.js";
+import { canonicalizeLayout } from "./canonicalizeLayout.js";
+import { updateActiveWindowRoot } from "./layoutTree.js";
+import { LAYOUT_MIN_SPLIT_SIZE } from "../../domain/layout/validation.js";
+import { updateWorkspaceTargetWindow } from "./targetWindow.js";
+const WORKSPACE_EDGE_DOCK_RATIO = 0.25;
+export function dockPanel(workspace, input) {
+    return updateWorkspaceTargetWindow(workspace, input.panelId, (selected) => dockPanelInActiveWindow(selected, input));
+}
+function dockPanelInActiveWindow(workspace, input) {
+    const activeWindow = getActiveWindow(workspace);
+    if (!activeWindow) {
+        return workspace;
+    }
+    const sourceStack = findStackContainingPanel(activeWindow.root, input.panelId);
+    if (!sourceStack) {
+        return workspace;
+    }
+    if (input.target.kind === 'workspace-edge') {
+        const extracted = extractPanelFromNode(activeWindow.root, input.panelId);
+        if (!extracted.panel || !extracted.nextNode) {
+            return workspace;
+        }
+        const nextRoot = wrapRootWithDockedPanel(extracted.nextNode, extracted.panel, input.target.side);
+        return updateActiveWindowRoot(workspace, () => canonicalizeLayout(nextRoot));
+    }
+    const targetStack = findStack(activeWindow.root, input.target.stackId);
+    if (!targetStack) {
+        return workspace;
+    }
+    if (input.target.placement === 'center' && sourceStack.id === targetStack.id) {
+        return reorderPanelWithinStack(workspace, sourceStack, input.panelId, input.target.tabIndex ?? null);
+    }
+    if (input.target.placement !== 'center' && sourceStack.id === targetStack.id && sourceStack.children.length <= 1) {
+        return workspace;
+    }
+    if (input.target.placement !== 'center' && sourceStack.children.length === 1) {
+        const reorderedWorkspace = reorderWholeStackWithinAlignedBand(workspace, activeWindow.root, sourceStack.id, targetStack.id, input.target.placement);
+        if (reorderedWorkspace) {
+            return reorderedWorkspace;
+        }
+    }
+    const preferredSplitSizes = resolveDockPreferredSplitSizes(activeWindow.root, sourceStack.id, targetStack.id, input.target.placement);
+    const extracted = extractPanelFromNode(activeWindow.root, input.panelId);
+    if (!extracted.panel || !extracted.nextNode) {
+        return workspace;
+    }
+    const nextRoot = insertPanelIntoDockTarget(extracted.nextNode, extracted.panel, input.target, preferredSplitSizes);
+    if (!nextRoot) {
+        return workspace;
+    }
+    return updateActiveWindowRoot(workspace, () => canonicalizeLayout(nextRoot));
+}
+function insertPanelIntoDockTarget(node, panel, target, preferredSplitSizes) {
+    if (node.kind === 'stack') {
+        if (node.id !== target.stackId) {
+            return node;
+        }
+        if (target.placement === 'center') {
+            const insertionIndex = clampTabInsertionIndex(target.tabIndex ?? node.children.length, node.children.length);
+            const nextChildren = [...node.children];
+            nextChildren.splice(insertionIndex, 0, panel);
+            return {
+                ...node,
+                activeChildId: panel.id,
+                children: nextChildren
+            };
+        }
+        const movedStack = createStack([panel]);
+        const orientation = target.placement === 'left' || target.placement === 'right' ? 'horizontal' : 'vertical';
+        const nextChildren = target.placement === 'left' || target.placement === 'top'
+            ? [movedStack, node]
+            : [node, movedStack];
+        return createSplit(orientation, nextChildren, preferredSplitSizes ?? [1, 1]);
+    }
+    const nextChildren = node.children.map((child) => insertPanelIntoDockTarget(child, panel, target, preferredSplitSizes));
+    if (nextChildren[0] === null && nextChildren[1] === null) {
+        return null;
+    }
+    if (nextChildren[0] === null) {
+        return nextChildren[1];
+    }
+    if (nextChildren[1] === null) {
+        return nextChildren[0];
+    }
+    return {
+        ...node,
+        children: nextChildren
+    };
+}
+function extractPanelFromNode(node, panelId) {
+    if (node.kind === 'stack') {
+        const panel = node.children.find((entry) => entry.id === panelId) ?? null;
+        if (!panel) {
+            return { nextNode: node, panel: null };
+        }
+        if (node.children.length === 1) {
+            return {
+                nextNode: null,
+                panel
+            };
+        }
+        const nextChildren = node.children.filter((entry) => entry.id !== panelId);
+        const activeChildId = node.activeChildId === panelId
+            ? nextChildren[Math.max(0, node.children.findIndex((entry) => entry.id === panelId) - 1)]?.id ?? nextChildren[0].id
+            : node.activeChildId;
+        return {
+            nextNode: {
+                ...node,
+                activeChildId,
+                children: nextChildren
+            },
+            panel
+        };
+    }
+    const leftResult = extractPanelFromNode(node.children[0], panelId);
+    if (leftResult.panel) {
+        if (!leftResult.nextNode) {
+            return {
+                nextNode: node.children[1],
+                panel: leftResult.panel
+            };
+        }
+        return {
+            nextNode: {
+                ...node,
+                children: [leftResult.nextNode, node.children[1]]
+            },
+            panel: leftResult.panel
+        };
+    }
+    const rightResult = extractPanelFromNode(node.children[1], panelId);
+    if (rightResult.panel) {
+        if (!rightResult.nextNode) {
+            return {
+                nextNode: node.children[0],
+                panel: rightResult.panel
+            };
+        }
+        return {
+            nextNode: {
+                ...node,
+                children: [node.children[0], rightResult.nextNode]
+            },
+            panel: rightResult.panel
+        };
+    }
+    return { nextNode: node, panel: null };
+}
+function findStackContainingPanel(node, panelId) {
+    if (node.kind === 'stack') {
+        return node.children.some((panel) => panel.id === panelId) ? node : undefined;
+    }
+    return findStackContainingPanel(node.children[0], panelId) ?? findStackContainingPanel(node.children[1], panelId);
+}
+export function createStackDockTarget(stackId, placement, tabIndex = null) {
+    return {
+        kind: 'stack',
+        stackId,
+        placement,
+        tabIndex
+    };
+}
+export function createWorkspaceEdgeDockTarget(side) {
+    return {
+        kind: 'workspace-edge',
+        side
+    };
+}
+export function isEdgeDockPlacement(placement) {
+    return placement !== 'center';
+}
+function wrapRootWithDockedPanel(root, panel, side) {
+    const dockedStack = createStack([panel]);
+    const orientation = side === 'left' || side === 'right' ? 'horizontal' : 'vertical';
+    const leadingSizes = [WORKSPACE_EDGE_DOCK_RATIO, 1 - WORKSPACE_EDGE_DOCK_RATIO];
+    const trailingSizes = [1 - WORKSPACE_EDGE_DOCK_RATIO, WORKSPACE_EDGE_DOCK_RATIO];
+    if (side === 'left' || side === 'top') {
+        return createSplit(orientation, [dockedStack, root], leadingSizes);
+    }
+    return createSplit(orientation, [root, dockedStack], trailingSizes);
+}
+function reorderPanelWithinStack(workspace, stack, panelId, targetTabIndex) {
+    const currentIndex = stack.children.findIndex((panel) => panel.id === panelId);
+    if (currentIndex === -1) {
+        return workspace;
+    }
+    const rawTargetIndex = clampTabInsertionIndex(targetTabIndex ?? currentIndex, stack.children.length);
+    const nextIndex = rawTargetIndex > currentIndex ? rawTargetIndex - 1 : rawTargetIndex;
+    if (nextIndex === currentIndex) {
+        return workspace;
+    }
+    const nextChildren = [...stack.children];
+    const [movedPanel] = nextChildren.splice(currentIndex, 1);
+    nextChildren.splice(nextIndex, 0, movedPanel);
+    return updateActiveWindowRoot(workspace, (root) => replaceStackById(root, stack.id, {
+        ...stack,
+        activeChildId: panelId,
+        children: nextChildren
+    }));
+}
+function replaceStackById(node, stackId, replacement) {
+    if (node.kind === 'stack') {
+        return node.id === stackId ? replacement : node;
+    }
+    return {
+        ...node,
+        children: [
+            replaceStackById(node.children[0], stackId, replacement),
+            replaceStackById(node.children[1], stackId, replacement)
+        ]
+    };
+}
+function reorderWholeStackWithinAlignedBand(workspace, root, sourceStackId, targetStackId, placement) {
+    const orientation = placement === 'left' || placement === 'right' ? 'horizontal' : 'vertical';
+    const sourceBounds = findNodeBounds(root, sourceStackId);
+    const targetBounds = findNodeBounds(root, targetStackId);
+    if (!sourceBounds || !targetBounds) {
+        return null;
+    }
+    const crossAxisOverlap = orientation === 'horizontal'
+        ? resolveRangeOverlapRatio(sourceBounds.vertical, targetBounds.vertical)
+        : resolveRangeOverlapRatio(sourceBounds.horizontal, targetBounds.horizontal);
+    if (crossAxisOverlap < 0.95) {
+        return null;
+    }
+    const container = findMinimalSameOrientationContainer(root, sourceStackId, targetStackId, orientation);
+    if (!container) {
+        return null;
+    }
+    const segments = flattenSameOrientationChain(container, orientation);
+    const sourceIndex = segments.findIndex((segment) => segment.node.kind === 'stack' && segment.node.id === sourceStackId);
+    const targetIndex = segments.findIndex((segment) => segment.node.kind === 'stack' && segment.node.id === targetStackId);
+    if (sourceIndex === -1 || targetIndex === -1) {
+        return null;
+    }
+    const nextSegments = [...segments];
+    const [sourceSegment] = nextSegments.splice(sourceIndex, 1);
+    const targetIndexAfterRemoval = nextSegments.findIndex((segment) => segment.node.kind === 'stack' && segment.node.id === targetStackId);
+    if (targetIndexAfterRemoval === -1) {
+        return null;
+    }
+    const insertionIndex = placement === 'left' || placement === 'top' ? targetIndexAfterRemoval : targetIndexAfterRemoval + 1;
+    nextSegments.splice(insertionIndex, 0, sourceSegment);
+    if (segmentsHaveSameOrder(segments, nextSegments)) {
+        return workspace;
+    }
+    const nextChain = buildSameOrientationChain(orientation, nextSegments);
+    return updateActiveWindowRoot(workspace, (currentRoot) => canonicalizeLayout(replaceNodeById(currentRoot, container.id, nextChain)));
+}
+function findMinimalSameOrientationContainer(node, sourceStackId, targetStackId, orientation) {
+    if (node.kind === 'stack') {
+        return null;
+    }
+    if (node.orientation !== orientation) {
+        return (findMinimalSameOrientationContainer(node.children[0], sourceStackId, targetStackId, orientation) ??
+            findMinimalSameOrientationContainer(node.children[1], sourceStackId, targetStackId, orientation));
+    }
+    const containsSource = containsNodeId(node, sourceStackId);
+    const containsTarget = containsNodeId(node, targetStackId);
+    if (!containsSource || !containsTarget) {
+        return (findMinimalSameOrientationContainer(node.children[0], sourceStackId, targetStackId, orientation) ??
+            findMinimalSameOrientationContainer(node.children[1], sourceStackId, targetStackId, orientation));
+    }
+    const nestedMatch = findMinimalSameOrientationContainer(node.children[0], sourceStackId, targetStackId, orientation) ??
+        findMinimalSameOrientationContainer(node.children[1], sourceStackId, targetStackId, orientation);
+    return nestedMatch ?? node;
+}
+function containsNodeId(node, targetNodeId) {
+    if (node.id === targetNodeId) {
+        return true;
+    }
+    if (node.kind === 'stack') {
+        return false;
+    }
+    return containsNodeId(node.children[0], targetNodeId) || containsNodeId(node.children[1], targetNodeId);
+}
+function flattenSameOrientationChain(node, orientation, inheritedSize = 1) {
+    if (node.kind === 'split' && node.orientation === orientation) {
+        return [
+            ...flattenSameOrientationChain(node.children[0], orientation, inheritedSize * node.sizes[0]),
+            ...flattenSameOrientationChain(node.children[1], orientation, inheritedSize * node.sizes[1])
+        ];
+    }
+    return [{ node, size: inheritedSize }];
+}
+function buildSameOrientationChain(orientation, segments) {
+    if (segments.length === 1) {
+        return segments[0].node;
+    }
+    const [firstSegment, ...restSegments] = segments;
+    const totalSize = segments.reduce((sum, segment) => sum + segment.size, 0);
+    const firstRatio = totalSize > 0 ? firstSegment.size / totalSize : 0.5;
+    return createSplit(orientation, [firstSegment.node, buildSameOrientationChain(orientation, restSegments)], [firstRatio, 1 - firstRatio]);
+}
+function replaceNodeById(node, targetNodeId, replacement) {
+    if (node.id === targetNodeId) {
+        return replacement;
+    }
+    if (node.kind === 'stack') {
+        return node;
+    }
+    return {
+        ...node,
+        children: [
+            replaceNodeById(node.children[0], targetNodeId, replacement),
+            replaceNodeById(node.children[1], targetNodeId, replacement)
+        ]
+    };
+}
+function segmentsHaveSameOrder(first, second) {
+    if (first.length !== second.length) {
+        return false;
+    }
+    return first.every((segment, index) => segment.node.id === second[index]?.node.id);
+}
+function clampTabInsertionIndex(index, length) {
+    return Math.max(0, Math.min(length, Math.round(index)));
+}
+function resolveDockPreferredSplitSizes(root, sourceStackId, targetStackId, placement) {
+    if (placement === 'center') {
+        return null;
+    }
+    const orientation = placement === 'left' || placement === 'right' ? 'horizontal' : 'vertical';
+    const sourceBounds = findNodeBounds(root, sourceStackId);
+    const targetBounds = findNodeBounds(root, targetStackId);
+    if (!sourceBounds || !targetBounds) {
+        return null;
+    }
+    const crossAxisOverlap = orientation === 'horizontal'
+        ? resolveRangeOverlapRatio(sourceBounds.vertical, targetBounds.vertical)
+        : resolveRangeOverlapRatio(sourceBounds.horizontal, targetBounds.horizontal);
+    if (crossAxisOverlap < 0.95) {
+        return null;
+    }
+    const sourceSpan = orientation === 'horizontal'
+        ? sourceBounds.horizontal.end - sourceBounds.horizontal.start
+        : sourceBounds.vertical.end - sourceBounds.vertical.start;
+    const targetSpan = orientation === 'horizontal'
+        ? targetBounds.horizontal.end - targetBounds.horizontal.start
+        : targetBounds.vertical.end - targetBounds.vertical.start;
+    if (!Number.isFinite(sourceSpan) || !Number.isFinite(targetSpan) || sourceSpan <= 0 || targetSpan <= 0) {
+        return null;
+    }
+    const movedRatio = Math.max(LAYOUT_MIN_SPLIT_SIZE, Math.min(1 - LAYOUT_MIN_SPLIT_SIZE, sourceSpan / targetSpan));
+    return placement === 'left' || placement === 'top'
+        ? [movedRatio, 1 - movedRatio]
+        : [1 - movedRatio, movedRatio];
+}
+function findNodeBounds(node, targetNodeId, bounds = {
+    horizontal: { start: 0, end: 1 },
+    vertical: { start: 0, end: 1 }
+}) {
+    if (node.id === targetNodeId) {
+        return bounds;
+    }
+    if (node.kind === 'stack') {
+        return null;
+    }
+    const [firstSize] = node.sizes;
+    if (node.orientation === 'horizontal') {
+        const width = bounds.horizontal.end - bounds.horizontal.start;
+        const splitPoint = bounds.horizontal.start + width * firstSize;
+        const firstBounds = {
+            horizontal: { start: bounds.horizontal.start, end: splitPoint },
+            vertical: bounds.vertical
+        };
+        const secondBounds = {
+            horizontal: { start: splitPoint, end: bounds.horizontal.end },
+            vertical: bounds.vertical
+        };
+        return findNodeBounds(node.children[0], targetNodeId, firstBounds) ??
+            findNodeBounds(node.children[1], targetNodeId, secondBounds);
+    }
+    const height = bounds.vertical.end - bounds.vertical.start;
+    const splitPoint = bounds.vertical.start + height * firstSize;
+    const firstBounds = {
+        horizontal: bounds.horizontal,
+        vertical: { start: bounds.vertical.start, end: splitPoint }
+    };
+    const secondBounds = {
+        horizontal: bounds.horizontal,
+        vertical: { start: splitPoint, end: bounds.vertical.end }
+    };
+    return findNodeBounds(node.children[0], targetNodeId, firstBounds) ??
+        findNodeBounds(node.children[1], targetNodeId, secondBounds);
+}
+function resolveRangeOverlapRatio(first, second) {
+    const overlapStart = Math.max(first.start, second.start);
+    const overlapEnd = Math.min(first.end, second.end);
+    const overlap = Math.max(0, overlapEnd - overlapStart);
+    const base = Math.min(first.end - first.start, second.end - second.start);
+    if (base <= 0) {
+        return 0;
+    }
+    return overlap / base;
+}

package/dist/application/workspace/finalizeWorkspace.d.ts

@@ -0,0 +1,4 @@
+import type { LayoutNode } from "../../domain/layout/model.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+export declare function updateCanonicalizedActiveWindowRoot(workspace: Workspace, updater: (root: LayoutNode) => LayoutNode): Workspace;
+export declare function pruneUnusedToolInstances(workspace: Workspace, candidateToolInstanceIds?: Iterable<string>): Workspace;

package/dist/application/workspace/finalizeWorkspace.js

@@ -0,0 +1,23 @@
+import { collectReferencedToolInstanceIds } from "../../domain/workspace/selectors.js";
+import { canonicalizeLayout } from "./canonicalizeLayout.js";
+import { updateActiveWindowRoot } from "./layoutTree.js";
+export function updateCanonicalizedActiveWindowRoot(workspace, updater) {
+    return updateActiveWindowRoot(workspace, (root) => canonicalizeLayout(updater(root)));
+}
+export function pruneUnusedToolInstances(workspace, candidateToolInstanceIds) {
+    const liveToolInstanceIds = collectReferencedToolInstanceIds(workspace);
+    if (!candidateToolInstanceIds) {
+        return {
+            ...workspace,
+            toolInstances: Object.fromEntries(Object.entries(workspace.toolInstances).filter(([toolInstanceId]) => liveToolInstanceIds.has(toolInstanceId)))
+        };
+    }
+    const candidateSet = new Set(candidateToolInstanceIds);
+    if (candidateSet.size === 0) {
+        return workspace;
+    }
+    return {
+        ...workspace,
+        toolInstances: Object.fromEntries(Object.entries(workspace.toolInstances).filter(([toolInstanceId]) => !candidateSet.has(toolInstanceId) || liveToolInstanceIds.has(toolInstanceId)))
+    };
+}

package/dist/application/workspace/focusPanel.d.ts

@@ -0,0 +1,2 @@
+import { type WorkspaceSessionState } from "./session.js";
+export declare function focusPanel(state: WorkspaceSessionState, panelId: string): WorkspaceSessionState;

package/dist/application/workspace/focusPanel.js

@@ -0,0 +1,19 @@
+import { findStackContainingPanelInWorkspace, findWindowContainingPanel } from "../../domain/workspace/selectors.js";
+import { setActiveStackChild } from "./setActiveStackChild.js";
+import { createWorkspaceSessionState } from "./session.js";
+// Shared by direct commands and editable layout projections. The owning
+// window must be selected before updating its active stack child.
+export function focusPanel(state, panelId) {
+    const containingStack = findStackContainingPanelInWorkspace(state.workspace, panelId);
+    const containingWindow = findWindowContainingPanel(state.workspace, panelId);
+    if (!containingStack || !containingWindow) {
+        return state;
+    }
+    const workspaceWithActiveWindow = state.workspace.activeWindowId === containingWindow.id
+        ? state.workspace
+        : { ...state.workspace, activeWindowId: containingWindow.id };
+    const nextWorkspace = containingStack.activeChildId === panelId
+        ? workspaceWithActiveWindow
+        : setActiveStackChild(workspaceWithActiveWindow, { stackId: containingStack.id, panelId });
+    return createWorkspaceSessionState(nextWorkspace, { activePanelId: panelId });
+}

package/dist/application/workspace/joinPanelArea.d.ts

@@ -0,0 +1,13 @@
+import type { LayoutEdge } from "../../domain/layout/interaction.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+export type JoinPanelAreaSide = 'left' | 'right' | 'top' | 'bottom';
+interface JoinPanelAreaInput {
+    panelId: string;
+    edge: LayoutEdge;
+    side: JoinPanelAreaSide;
+    sourceAreaPanelIds?: readonly string[];
+    siblingAreaPanelIds?: readonly string[];
+}
+export declare function canJoinPanelArea(workspace: Workspace, input: Omit<JoinPanelAreaInput, 'side'>): boolean;
+export declare function joinPanelArea(workspace: Workspace, input: JoinPanelAreaInput): Workspace;
+export {};