@konitif/workbench 0.284.1

package/dist/application/workspace/joinPanelArea.js

@@ -0,0 +1,281 @@
+import { getActiveWindow } from "../../domain/workspace/selectors.js";
+import { containsPanel, listPanels } from "../../domain/layout/selectors.js";
+import { normalizeSplitSizes } from "../../domain/layout/validation.js";
+import { pruneUnusedToolInstances, updateCanonicalizedActiveWindowRoot } from "./finalizeWorkspace.js";
+import { selectWorkspaceTargetWindow, updateWorkspaceTargetWindow } from "./targetWindow.js";
+export function canJoinPanelArea(workspace, input) {
+    const activeWindow = getActiveWindow(selectWorkspaceTargetWindow(workspace, input.panelId));
+    if (!activeWindow || !containsPanel(activeWindow.root, input.panelId)) {
+        return false;
+    }
+    return findExplicitJoinCandidate(activeWindow.root, input) !== null || findJoinCandidate(activeWindow.root, input.panelId, input.edge) !== null;
+}
+export function joinPanelArea(workspace, input) {
+    return updateWorkspaceTargetWindow(workspace, input.panelId, (selected) => joinPanelAreaInActiveWindow(selected, input));
+}
+function joinPanelAreaInActiveWindow(workspace, input) {
+    const activeWindow = getActiveWindow(workspace);
+    if (!activeWindow || !containsPanel(activeWindow.root, input.panelId)) {
+        return workspace;
+    }
+    const explicitCandidate = findExplicitJoinCandidate(activeWindow.root, input);
+    if (explicitCandidate) {
+        return pruneUnusedToolInstances(updateCanonicalizedActiveWindowRoot(workspace, (root) => joinNodesById(root, explicitCandidate.sourceNodeId, explicitCandidate.siblingNodeId, input.edge)));
+    }
+    const candidate = findJoinCandidate(activeWindow.root, input.panelId, input.edge);
+    if (!candidate) {
+        return workspace;
+    }
+    return pruneUnusedToolInstances(updateCanonicalizedActiveWindowRoot(workspace, (root) => {
+        const split = findSplitById(root, candidate.splitId);
+        return split ? replaceNodeById(root, candidate.splitId, keepJoinedSide(split, input.side)) : root;
+    }));
+}
+function keepJoinedSide(split, side) {
+    if (split.orientation === 'horizontal') {
+        return side === 'left' ? split.children[0] : split.children[1];
+    }
+    return side === 'top' ? split.children[0] : split.children[1];
+}
+function findSplitById(node, splitId) {
+    if (node.kind === 'split') {
+        if (node.id === splitId) {
+            return node;
+        }
+        return findSplitById(node.children[0], splitId) ?? findSplitById(node.children[1], splitId);
+    }
+    return null;
+}
+function findJoinCandidate(root, panelId, edge) {
+    const ancestors = findLayoutBranchAncestors(root, panelId);
+    const targetOrientation = edge === 'left' || edge === 'right' ? 'horizontal' : 'vertical';
+    const expectedChildIndex = edge === 'left' || edge === 'top' ? 1 : 0;
+    if (!ancestors) {
+        return null;
+    }
+    for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+        const ancestor = ancestors[index];
+        if (ancestor.orientation === targetOrientation && ancestor.childIndex === expectedChildIndex) {
+            return {
+                splitId: ancestor.splitId
+            };
+        }
+    }
+    return null;
+}
+function findExplicitJoinCandidate(root, input) {
+    if (!input.sourceAreaPanelIds || !input.siblingAreaPanelIds) {
+        return null;
+    }
+    const sourceNode = findNodeByExactPanelSet(root, normalizePanelIdSet(input.sourceAreaPanelIds));
+    const siblingNode = findNodeByExactPanelSet(root, normalizePanelIdSet(input.siblingAreaPanelIds));
+    if (!sourceNode ||
+        !siblingNode ||
+        sourceNode.id === siblingNode.id ||
+        containsNodeId(sourceNode, siblingNode.id) ||
+        containsNodeId(siblingNode, sourceNode.id)) {
+        return null;
+    }
+    return {
+        sourceNodeId: sourceNode.id,
+        siblingNodeId: siblingNode.id
+    };
+}
+function findLayoutBranchAncestors(node, panelId, trail = []) {
+    if (node.kind === 'stack') {
+        return node.children.some((panel) => panel.id === panelId) ? trail : null;
+    }
+    for (let childIndex = 0; childIndex < node.children.length; childIndex = (childIndex + 1)) {
+        const child = node.children[childIndex];
+        if (!containsPanel(child, panelId)) {
+            continue;
+        }
+        return findLayoutBranchAncestors(child, panelId, [
+            ...trail,
+            {
+                splitId: node.id,
+                orientation: node.orientation,
+                childIndex
+            }
+        ]);
+    }
+    return null;
+}
+function findNodeByExactPanelSet(node, expectedPanelIds) {
+    if (matchesPanelIdSet(normalizePanelIdSet(listPanels(node).map((panel) => panel.id)), expectedPanelIds)) {
+        return node;
+    }
+    if (node.kind === 'stack') {
+        return null;
+    }
+    return findNodeByExactPanelSet(node.children[0], expectedPanelIds) ?? findNodeByExactPanelSet(node.children[1], expectedPanelIds);
+}
+function normalizePanelIdSet(panelIds) {
+    return Array.from(new Set(panelIds)).sort();
+}
+function matchesPanelIdSet(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((panelId, index) => panelId === right[index]);
+}
+function joinNodesById(root, sourceNodeId, siblingNodeId, edge) {
+    const axis = edge === 'left' || edge === 'right' ? 'horizontal' : 'vertical';
+    const sourcePath = findNodePathById(root, sourceNodeId);
+    const siblingPath = findNodePathById(root, siblingNodeId);
+    if (!sourcePath || !siblingPath) {
+        return root;
+    }
+    const commonSplitIndex = findCommonSplitIndex(sourcePath, siblingPath);
+    if (commonSplitIndex === -1) {
+        return root;
+    }
+    const sourceLcaEntry = sourcePath[commonSplitIndex];
+    const siblingLcaEntry = siblingPath[commonSplitIndex];
+    if (sourceLcaEntry.childIndex === siblingLcaEntry.childIndex) {
+        return root;
+    }
+    const sourceSpanWithinLca = resolveAxisSpanFromPath(sourcePath.slice(commonSplitIndex), axis);
+    const lcaSourceSize = sourceLcaEntry.split.sizes[sourceLcaEntry.childIndex];
+    const lcaSiblingSize = sourceLcaEntry.split.sizes[siblingLcaEntry.childIndex];
+    const sourceBranch = sourceLcaEntry.split.children[sourceLcaEntry.childIndex];
+    const siblingBranch = sourceLcaEntry.split.children[siblingLcaEntry.childIndex];
+    const remainingSourceBranch = removeNodeById(sourceBranch, sourceNodeId);
+    const siblingDeltaRelative = lcaSiblingSize > 0 ? sourceSpanWithinLca / lcaSiblingSize : 0;
+    const expandedSiblingBranch = expandNodeAlongAxis(siblingBranch, siblingNodeId, axis, siblingDeltaRelative);
+    if (!remainingSourceBranch) {
+        return replaceNodeById(root, sourceLcaEntry.split.id, expandedSiblingBranch);
+    }
+    const nextSizes = [...sourceLcaEntry.split.sizes];
+    nextSizes[sourceLcaEntry.childIndex] = Math.max(lcaSourceSize - sourceSpanWithinLca, 0);
+    nextSizes[siblingLcaEntry.childIndex] = lcaSiblingSize + sourceSpanWithinLca;
+    const nextChildren = [...sourceLcaEntry.split.children];
+    nextChildren[sourceLcaEntry.childIndex] = remainingSourceBranch;
+    nextChildren[siblingLcaEntry.childIndex] = expandedSiblingBranch;
+    return replaceNodeById(root, sourceLcaEntry.split.id, {
+        ...sourceLcaEntry.split,
+        children: nextChildren,
+        sizes: normalizeSplitSizes(nextSizes)
+    });
+}
+function removeNodeById(node, nodeId) {
+    if (node.id === nodeId) {
+        return null;
+    }
+    if (node.kind === 'stack') {
+        return node;
+    }
+    const firstChild = removeNodeById(node.children[0], nodeId);
+    const secondChild = removeNodeById(node.children[1], nodeId);
+    if (!firstChild && !secondChild) {
+        return null;
+    }
+    if (!firstChild) {
+        return secondChild;
+    }
+    if (!secondChild) {
+        return firstChild;
+    }
+    return {
+        ...node,
+        children: [firstChild, secondChild]
+    };
+}
+function replaceNodeById(node, nodeId, replacement) {
+    if (node.id === nodeId) {
+        return replacement;
+    }
+    if (node.kind === 'stack') {
+        return node;
+    }
+    return {
+        ...node,
+        children: [
+            replaceNodeById(node.children[0], nodeId, replacement),
+            replaceNodeById(node.children[1], nodeId, replacement)
+        ]
+    };
+}
+function findNodePathById(node, targetNodeId, trail = []) {
+    if (node.id === targetNodeId) {
+        return trail;
+    }
+    if (node.kind === 'stack') {
+        return null;
+    }
+    for (let childIndex = 0; childIndex < node.children.length; childIndex = (childIndex + 1)) {
+        const child = node.children[childIndex];
+        const path = findNodePathById(child, targetNodeId, [...trail, { split: node, childIndex }]);
+        if (path) {
+            return path;
+        }
+    }
+    return null;
+}
+function findCommonSplitIndex(sourcePath, siblingPath) {
+    const maxLength = Math.min(sourcePath.length, siblingPath.length);
+    let commonIndex = -1;
+    for (let index = 0; index < maxLength; index += 1) {
+        if (sourcePath[index].split.id !== siblingPath[index].split.id) {
+            break;
+        }
+        commonIndex = index;
+    }
+    return commonIndex;
+}
+function resolveAxisSpanFromPath(path, axis) {
+    return path.reduce((span, entry) => {
+        if (entry.split.orientation !== axis) {
+            return span;
+        }
+        return span * entry.split.sizes[entry.childIndex];
+    }, 1);
+}
+function expandNodeAlongAxis(node, targetNodeId, axis, deltaRelativeToNode) {
+    if (deltaRelativeToNode <= 0 || node.id === targetNodeId || node.kind === 'stack') {
+        return node;
+    }
+    const targetChildIndex = findChildIndexContainingNode(node, targetNodeId);
+    if (targetChildIndex === null) {
+        return node;
+    }
+    const nextChildren = [...node.children];
+    if (node.orientation !== axis) {
+        nextChildren[targetChildIndex] = expandNodeAlongAxis(node.children[targetChildIndex], targetNodeId, axis, deltaRelativeToNode);
+        return {
+            ...node,
+            children: nextChildren
+        };
+    }
+    const siblingChildIndex = targetChildIndex === 0 ? 1 : 0;
+    const targetSize = node.sizes[targetChildIndex];
+    const siblingSize = node.sizes[siblingChildIndex];
+    const totalFactor = 1 + deltaRelativeToNode;
+    const nextSizes = [...node.sizes];
+    nextSizes[targetChildIndex] = (targetSize + deltaRelativeToNode) / totalFactor;
+    nextSizes[siblingChildIndex] = siblingSize / totalFactor;
+    nextChildren[targetChildIndex] = expandNodeAlongAxis(node.children[targetChildIndex], targetNodeId, axis, targetSize > 0 ? deltaRelativeToNode / targetSize : 0);
+    return {
+        ...node,
+        children: nextChildren,
+        sizes: normalizeSplitSizes(nextSizes)
+    };
+}
+function findChildIndexContainingNode(node, targetNodeId) {
+    if (containsNodeId(node.children[0], targetNodeId)) {
+        return 0;
+    }
+    if (containsNodeId(node.children[1], targetNodeId)) {
+        return 1;
+    }
+    return null;
+}
+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);
+}

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

@@ -0,0 +1,176 @@
+import type { LayoutDockSide, LayoutEdge, LayoutInteractionAnchor, LayoutInteractionState, LayoutDockTarget, LayoutMenuTarget, LayoutInteractionSourceKind, LayoutMenuActionId } from "../../domain/layout/interaction.js";
+import type { LayoutNode, SplitNode, SplitOrientation } from "../../domain/layout/model.js";
+export type LayoutMenuActionSelection = {
+    kind: 'split';
+    orientation: SplitOrientation;
+    panelId: string;
+    edge: LayoutEdge;
+} | {
+    kind: 'join';
+    panelId: string;
+    edge: LayoutEdge;
+    side: LayoutDockSide;
+    sourceAreaPanelIds: readonly string[];
+    siblingAreaPanelIds: readonly string[];
+} | {
+    kind: 'swap';
+    panelId: string;
+    edge: LayoutEdge;
+    sourceAreaPanelIds: readonly string[];
+    siblingAreaPanelIds: readonly string[];
+};
+export interface LayoutMenuActionItem {
+    id: string;
+    label: string;
+    group: 'split' | 'transform';
+    enabled: boolean;
+    selection: LayoutMenuActionSelection | null;
+}
+export interface SplitHandleMenuTarget {
+    panelId: string;
+    edge: LayoutEdge;
+}
+export interface LayoutSplitCommit {
+    panelId: string | null;
+    orientation: SplitOrientation;
+    side: LayoutDockSide;
+}
+export type LayoutInteractionResolution = {
+    kind: 'state';
+    state: LayoutInteractionState;
+} | {
+    kind: 'commit-subdivide';
+    state: LayoutInteractionState;
+    subdivide: {
+        panelId: string;
+        orientation: SplitOrientation;
+        edge: LayoutEdge;
+        cuts: number;
+        pointerRatio: number;
+    };
+} | {
+    kind: 'commit-split';
+    state: LayoutInteractionState;
+    split: LayoutSplitCommit;
+} | {
+    kind: 'commit-swap';
+    state: LayoutInteractionState;
+    swap: {
+        panelId: string;
+        edge: LayoutEdge;
+        sourceAreaPanelIds: readonly string[];
+        siblingAreaPanelIds: readonly string[];
+    };
+} | {
+    kind: 'commit-join';
+    state: LayoutInteractionState;
+    join: {
+        panelId: string;
+        edge: LayoutEdge;
+        side: 'left' | 'right' | 'top' | 'bottom';
+        sourceAreaPanelIds: readonly string[];
+        siblingAreaPanelIds: readonly string[];
+    };
+} | {
+    kind: 'commit-dock';
+    state: LayoutInteractionState;
+    dock: {
+        panelId: string;
+        target: LayoutDockTarget;
+    };
+} | {
+    kind: 'commit-boundary-pull';
+    state: LayoutInteractionState;
+    boundaryPull: {
+        windowId?: string;
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+} | {
+    kind: 'commit-intersection-resize';
+    state: LayoutInteractionState;
+    intersectionResize: {
+        columnSplitId: string;
+        rowSplitId: string;
+        columnSizes: [number, number];
+        rowSizes: [number, number];
+    };
+};
+export declare function createLayoutInteractionState(): LayoutInteractionState;
+export declare function openLayoutSplitMenu(panelId: string | null, edge: LayoutEdge, anchor: LayoutInteractionAnchor, targets?: LayoutMenuTarget[], options?: {
+    source?: LayoutInteractionSourceKind;
+    initialActionId?: LayoutMenuActionId | null;
+}): LayoutInteractionState;
+export declare function dismissLayoutInteraction(): LayoutInteractionState;
+export declare function startPanelDrag(panelId: string, sourceStackId: string, anchor: LayoutInteractionAnchor): LayoutInteractionState;
+export declare function updatePanelDrag(state: LayoutInteractionState, pointer: LayoutInteractionAnchor, hoveredTarget: LayoutDockTarget | null): LayoutInteractionState;
+export declare function commitPanelDock(state: LayoutInteractionState): LayoutInteractionResolution;
+export declare function resolveSplitHandleMenuTarget(split: SplitNode, activePanelId: string | null): SplitHandleMenuTarget | null;
+export declare function resolveSplitHandleMenuTargets(split: SplitNode): LayoutMenuTarget[];
+export declare function resolveWorkspaceEdgeMenuTargets(root: LayoutNode, edge: LayoutEdge): LayoutMenuTarget[];
+export declare function resolvePanelMenuTargets(root: LayoutNode, panelId: string): LayoutMenuTarget[];
+export declare function resolvePanelMenuJoinTargets(root: LayoutNode, panelId: string): LayoutMenuTarget[];
+export declare function resolvePanelMenuSwapTargets(root: LayoutNode, panelId: string): LayoutMenuTarget[];
+export declare function getLayoutMenuActions(options?: {
+    edge?: LayoutEdge;
+    panelId?: string | null;
+    target?: LayoutMenuTarget | null;
+    targets?: LayoutMenuTarget[];
+    joinEnabled?: boolean;
+    swapAreasEnabled?: boolean;
+}): LayoutMenuActionItem[];
+export declare function selectLayoutMenuAction(state: LayoutInteractionState, selection: LayoutMenuActionSelection | null): LayoutInteractionResolution;
+export declare function getEdgeSemanticOrientation(edge: LayoutEdge): SplitOrientation;
+export declare function isAlignedEdgePreview(edge: LayoutEdge, orientation: SplitOrientation): boolean;
+export declare function getDockSidesForOrientation(orientation: SplitOrientation): [LayoutDockSide, LayoutDockSide];
+export declare function selectLayoutSplitOrientation(state: LayoutInteractionState, orientation: SplitOrientation): LayoutInteractionResolution;
+export declare function updateLayoutSplitPreview(state: LayoutInteractionState, panelId: string | null, pointerRatio: number): LayoutInteractionState;
+export declare function startLayoutSplitPreview(input: {
+    panelId: string;
+    edge: LayoutEdge;
+    orientation: SplitOrientation;
+    cuts?: number;
+    pointerRatio?: number;
+}): LayoutInteractionState;
+export declare function startBoundaryPull(input: {
+    windowId?: string;
+    anchor: LayoutInteractionAnchor;
+    horizontalEdge?: 'left' | 'right' | null;
+    verticalEdge?: 'top' | 'bottom' | null;
+    source?: 'edge' | 'corner';
+    neutralThreshold?: number;
+    creationThreshold?: number;
+}): LayoutInteractionState;
+export declare function updateBoundaryPull(state: LayoutInteractionState, pointer: LayoutInteractionAnchor, viewport: {
+    width: number;
+    height: number;
+}): LayoutInteractionState;
+export declare function commitBoundaryPull(state: LayoutInteractionState): LayoutInteractionResolution;
+export declare function startIntersectionResize(input: {
+    anchor: LayoutInteractionAnchor;
+    columnSplitId: string;
+    rowSplitId: string;
+    columnBaseSizes: [number, number];
+    rowBaseSizes: [number, number];
+}): LayoutInteractionState;
+export declare function updateIntersectionResize(state: LayoutInteractionState, pointer: LayoutInteractionAnchor, dimensions: {
+    width: number;
+    height: number;
+}): LayoutInteractionState;
+export declare function commitIntersectionResize(state: LayoutInteractionState): LayoutInteractionResolution;
+export declare function resolveImmediateJoinSiblingPanelIds(root: LayoutNode, panelId: string, edge: LayoutEdge): string[];
+export declare function resolveImmediateSwapAreaPanelIds(root: LayoutNode, panelId: string, edge: LayoutEdge): string[];
+export declare function resolveImmediateSwapSiblingPanelIds(root: LayoutNode, panelId: string, edge: LayoutEdge): string[];
+export declare function adjustLayoutSplitPreviewCuts(state: LayoutInteractionState, delta: number): LayoutInteractionState;
+export declare function commitLayoutSplitPreview(state: LayoutInteractionState): LayoutInteractionResolution;
+export declare function commitLayoutSubdivideSelection(input: {
+    panelId: string;
+    edge: LayoutEdge;
+    orientation: SplitOrientation;
+    cuts: number;
+    pointerRatio: number;
+}): LayoutInteractionResolution;
+export declare function previewLayoutSplitSide(state: LayoutInteractionState, side: LayoutDockSide | null): LayoutInteractionState;
+export declare function confirmLayoutSplitSide(state: LayoutInteractionState, side: LayoutDockSide): LayoutInteractionResolution;