@adecore/ui 0.18.4 → 0.20.0

package/dist/workspace/Workspace.js

@@ -0,0 +1,27 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import clsx from 'clsx';
+import { useRender } from '@base-ui-components/react/use-render';
+import { WorkspaceContext } from './context.js';
+export function Workspace({ layout = 'standard', toolbar, sidebar, sidePanel, sidebarWidth = 248, sidePanelWidth = 320, sidebarOpen, sidePanelOpen, children, className, ref, render, style, ...props }) {
+    const hasSidebar = sidebar !== undefined && sidebar !== null && sidebar !== false;
+    const hasPanel = sidePanel !== undefined && sidePanel !== null && sidePanel !== false;
+    const leftOpen = hasSidebar && (sidebarOpen ?? true);
+    const rightOpen = hasPanel && (sidePanelOpen ?? true);
+    const hasToolbar = toolbar !== undefined && toolbar !== null && toolbar !== false;
+    const element = useRender({
+        render,
+        ref,
+        defaultTagName: 'div',
+        props: {
+            ...props,
+            className: clsx('ade-workspace', className),
+            style,
+            'data-layout': layout,
+            'data-toolbar': hasToolbar || undefined,
+            'data-sidebar': leftOpen || undefined,
+            'data-side-panel': rightOpen || undefined,
+            children: (_jsxs(_Fragment, { children: [hasSidebar && (_jsx("aside", { className: "ade-workspace-sidebar", "data-auto": sidebarWidth === 'auto' || undefined, style: { width: sidebarWidth }, children: sidebar })), _jsxs("div", { className: "ade-workspace-center", children: [hasToolbar && _jsx("div", { className: "ade-workspace-toolbar", children: toolbar }), _jsx("div", { className: "ade-workspace-content", children: children })] }), hasPanel && (_jsx("aside", { className: "ade-workspace-side-panel", "data-auto": sidePanelWidth === 'auto' || undefined, style: { width: sidePanelWidth }, children: sidePanel }))] }))
+        }
+    });
+    return _jsx(WorkspaceContext, { value: { layout, edges: { top: !hasToolbar, right: !rightOpen, bottom: true, left: !leftOpen } }, children: element });
+}

package/dist/workspace/context.d.ts

@@ -0,0 +1,6 @@
+import type { SplitEdges } from './geometry.ts';
+export type WorkspaceLayout = 'standard' | 'roomy';
+export declare const WorkspaceContext: import("react").Context<{
+    layout: WorkspaceLayout;
+    edges: SplitEdges;
+}>;

package/dist/workspace/context.js

@@ -0,0 +1,5 @@
+import { createContext } from 'react';
+export const WorkspaceContext = createContext({
+    layout: 'standard',
+    edges: { top: true, right: true, bottom: true, left: true }
+});

package/dist/workspace/geometry.d.ts

@@ -0,0 +1,39 @@
+import { type SplitAxis, type SplitLayout, type SplitPane, type SplitSide } from './model.ts';
+export interface SplitRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface SplitEdges {
+    top?: boolean;
+    right?: boolean;
+    bottom?: boolean;
+    left?: boolean;
+}
+export interface SplitMinimum {
+    width: number;
+    height: number;
+}
+export interface SplitPaneRect extends SplitRect {
+    pane: SplitPane;
+}
+export interface SplitDivider extends SplitRect {
+    splitId: string;
+    index: number;
+    axis: SplitAxis;
+    lengths: number[];
+    minimums: number[];
+}
+export interface SplitGeometry {
+    panes: SplitPaneRect[];
+    dividers: SplitDivider[];
+}
+export declare function splitGeometry(layout: SplitLayout, width: number, height: number, gap: number, minimum: (pane: SplitPane) => SplitMinimum): SplitGeometry;
+export declare function resizeSplit(divider: SplitDivider, delta: number, symmetric?: boolean, snapDistance?: number, minimumShare?: number): number[];
+export declare function paneRadius(rect: SplitRect, width: number, height: number, edges: SplitEdges, radius: number): string;
+export declare function splitSideAt(rect: SplitRect, x: number, y: number): SplitSide | undefined;
+export declare function tabGapAt(rects: readonly {
+    left: number;
+    right: number;
+}[], x: number): number;

package/dist/workspace/geometry.js

@@ -0,0 +1,153 @@
+import { findSplitNode } from './model.js';
+function distribute(total, weights, minimums) {
+    const floor = minimums.reduce((sum, size) => sum + size, 0);
+    if (floor >= total) {
+        return minimums.map((size) => (floor ? (size * total) / floor : total / minimums.length));
+    }
+    const result = weights.map(() => 0);
+    const pending = new Set(weights.map((_, i) => i));
+    let remaining = total;
+    while (pending.size) {
+        const sum = [...pending].reduce((value, i) => value + weights[i], 0);
+        const small = [...pending].filter((i) => (remaining * weights[i]) / sum < minimums[i]);
+        if (!small.length) {
+            pending.forEach((i) => {
+                result[i] = (remaining * weights[i]) / sum;
+            });
+            break;
+        }
+        small.forEach((i) => {
+            result[i] = minimums[i];
+            remaining -= minimums[i];
+            pending.delete(i);
+        });
+    }
+    return result;
+}
+export function splitGeometry(layout, width, height, gap, minimum) {
+    const result = { panes: [], dividers: [] };
+    const minimums = new Map();
+    const measure = (node) => {
+        if (node.type === 'pane') {
+            const value = minimum(node);
+            const safe = {
+                width: Math.max(0, Number.isFinite(value.width) ? value.width : 0),
+                height: Math.max(0, Number.isFinite(value.height) ? value.height : 0)
+            };
+            minimums.set(node.id, safe);
+            return safe;
+        }
+        const children = node.children.map(measure);
+        const horizontal = node.axis === 'horizontal';
+        const value = {
+            width: horizontal
+                ? children.reduce((sum, item) => sum + item.width, 0) + gap * (children.length - 1)
+                : Math.max(...children.map((item) => item.width)),
+            height: horizontal
+                ? Math.max(...children.map((item) => item.height))
+                : children.reduce((sum, item) => sum + item.height, 0) + gap * (children.length - 1)
+        };
+        minimums.set(node.id, value);
+        return value;
+    };
+    const walk = (node, rect) => {
+        if (node.type === 'pane') {
+            result.panes.push({ ...rect, pane: node });
+            return;
+        }
+        const horizontal = node.axis === 'horizontal';
+        const axisLength = horizontal ? rect.width : rect.height;
+        const spacing = Math.min(gap, axisLength / (node.children.length - 1));
+        const available = Math.max(0, axisLength - spacing * (node.children.length - 1));
+        const limits = node.children.map((child) => minimums.get(child.id)[horizontal ? 'width' : 'height']);
+        const lengths = distribute(available, node.sizes, limits);
+        let offset = 0;
+        node.children.forEach((child, i) => {
+            const end = Math.round(offset + lengths[i]);
+            const start = Math.round(offset);
+            walk(child, horizontal ? { ...rect, x: rect.x + start, width: end - start } : { ...rect, y: rect.y + start, height: end - start });
+            if (i < node.children.length - 1) {
+                result.dividers.push({
+                    ...rect,
+                    ...(horizontal ? { x: rect.x + end, width: spacing } : { y: rect.y + end, height: spacing }),
+                    splitId: node.id,
+                    index: i,
+                    axis: node.axis,
+                    lengths,
+                    minimums: limits
+                });
+            }
+            offset += lengths[i] + spacing;
+        });
+    };
+    const root = layout.maximized ? (findSplitNode(layout.root, layout.maximized) ?? layout.root) : layout.root;
+    measure(root);
+    walk(root, { x: 0, y: 0, width: Math.max(0, width), height: Math.max(0, height) });
+    return result;
+}
+export function resizeSplit(divider, delta, symmetric = false, snapDistance = 0, minimumShare = 0) {
+    const lengths = [...divider.lengths];
+    const { index } = divider;
+    const total = lengths.reduce((sum, size) => sum + size, 0);
+    if (total <= 0 || lengths.some((size) => size <= 0)) {
+        return lengths.map(() => 1 / lengths.length);
+    }
+    const mirror = lengths.length - divider.index - 2;
+    const affected = new Set([index, index + 1, ...(symmetric ? [mirror, mirror + 1] : [])]);
+    const span = [...affected].reduce((sum, i) => sum + lengths[i], 0);
+    const share = Number.isFinite(minimumShare) ? Math.max(0, Math.min(1 / affected.size, minimumShare)) : 0;
+    const min = divider.minimums.map((size, i) => Math.min(lengths[i], Math.max(size, affected.has(i) ? span * share : 0)));
+    if (symmetric && mirror !== index) {
+        const changes = lengths.map(() => 0);
+        changes[index]++;
+        changes[index + 1]--;
+        changes[mirror]--;
+        changes[mirror + 1]++;
+        let lower = -Infinity;
+        let upper = Infinity;
+        changes.forEach((coefficient, i) => {
+            if (coefficient > 0) {
+                lower = Math.max(lower, (min[i] - lengths[i]) / coefficient);
+            }
+            if (coefficient < 0) {
+                upper = Math.min(upper, (lengths[i] - min[i]) / -coefficient);
+            }
+        });
+        const change = Math.max(lower, Math.min(delta, upper));
+        return lengths.map((size, i) => Math.max(Number.EPSILON, (size + changes[i] * change) / total));
+    }
+    const change = Math.max(min[index] - lengths[index], Math.min(delta, lengths[index + 1] - min[index + 1]));
+    const pair = lengths[index] + lengths[index + 1];
+    const middle = pair / 2;
+    const next = lengths[index] + change;
+    // A snap must not cross either pane's minimum, including minimums inherited from nested splits.
+    lengths[index] = Math.abs(next - middle) <= snapDistance && middle >= min[index] && middle >= min[index + 1] ? middle : next;
+    lengths[index + 1] = pair - lengths[index];
+    return lengths.map((size) => Math.max(Number.EPSILON, size / total));
+}
+export function paneRadius(rect, width, height, edges, radius) {
+    const left = rect.x === 0 && edges.left;
+    const top = rect.y === 0 && edges.top;
+    const right = rect.x + rect.width >= width && edges.right;
+    const bottom = rect.y + rect.height >= height && edges.bottom;
+    return [top || left, top || right, bottom || right, bottom || left].map((flush) => `${flush ? 0 : radius}px`).join(' ');
+}
+export function splitSideAt(rect, x, y) {
+    const horizontal = (x - rect.x) / rect.width;
+    const vertical = (y - rect.y) / rect.height;
+    const nearest = Math.min(horizontal, 1 - horizontal, vertical, 1 - vertical);
+    if (nearest > 0.25) {
+        return undefined;
+    }
+    if (nearest === horizontal) {
+        return 'left';
+    }
+    if (nearest === 1 - horizontal) {
+        return 'right';
+    }
+    return nearest === vertical ? 'top' : 'bottom';
+}
+export function tabGapAt(rects, x) {
+    const index = rects.findIndex((rect) => x < (rect.left + rect.right) / 2);
+    return index < 0 ? rects.length : index;
+}

package/dist/workspace/model.d.ts

@@ -0,0 +1,83 @@
+export type SplitAxis = 'horizontal' | 'vertical';
+export type SplitSide = 'left' | 'right' | 'top' | 'bottom';
+export interface SplitPane {
+    type: 'pane';
+    id: string;
+    views: string[];
+    active: string | null;
+}
+export interface SplitBranch {
+    type: 'split';
+    id: string;
+    axis: SplitAxis;
+    children: SplitNode[];
+    sizes: number[];
+}
+export type SplitNode = SplitPane | SplitBranch;
+export interface SplitLayout {
+    root: SplitNode;
+    focused: string;
+    maximized: string | null;
+}
+export type SplitCommand = {
+    type: 'activate';
+    paneId: string;
+    viewId: string;
+} | {
+    type: 'focus';
+    paneId: string;
+} | {
+    type: 'maximize';
+    paneId: string | null;
+} | {
+    type: 'close';
+    viewId: string;
+} | {
+    type: 'closePane';
+    paneId: string;
+} | {
+    type: 'insert';
+    paneId: string;
+    viewId: string;
+    index?: number;
+} | {
+    type: 'split';
+    paneId: string;
+    side: SplitSide;
+    newPane: SplitPane;
+    splitId: string;
+} | {
+    type: 'move';
+    sourceId: string;
+    targetId: string;
+    viewId?: string;
+    side?: SplitSide;
+    index?: number;
+    newPaneId?: string;
+    splitId?: string;
+} | {
+    type: 'swap';
+    sourceId: string;
+    targetId: string;
+    viewId?: string;
+} | {
+    type: 'resize';
+    splitId: string;
+    sizes: number[];
+} | {
+    type: 'equalize';
+    splitId: string;
+    index?: number;
+} | {
+    type: 'equalizeAxis';
+    axis: SplitAxis;
+    length?: number;
+    gap?: number;
+};
+export declare function createSplitLayout(views?: string[], paneId?: string): SplitLayout;
+export declare function splitPanes(node: SplitNode): SplitPane[];
+export declare function findSplitNode(node: SplitNode, id: string): SplitNode | undefined;
+/** Repairs persisted data at the application boundary; view payloads never enter the layout. */
+export declare function normalizeSplitLayout(value: unknown): SplitLayout;
+/** Invalid or stale commands are no-ops. IDs for new nodes come from the caller. */
+export declare function updateSplitLayout(layout: SplitLayout, command: SplitCommand): SplitLayout;

package/dist/workspace/model.js

@@ -0,0 +1,360 @@
+export function createSplitLayout(views = [], paneId = 'main') {
+    const unique = [...new Set(views)];
+    return { root: { type: 'pane', id: paneId, views: unique, active: unique[0] ?? null }, focused: paneId, maximized: null };
+}
+export function splitPanes(node) {
+    return node.type === 'pane' ? [node] : node.children.flatMap(splitPanes);
+}
+export function findSplitNode(node, id) {
+    if (node.id === id) {
+        return node;
+    }
+    return node.type === 'split' ? node.children.map((child) => findSplitNode(child, id)).find(Boolean) : undefined;
+}
+function shares(values, length) {
+    const safe = Array.from({ length }, (_, i) => (Number.isFinite(values[i]) && values[i] > 0 ? values[i] : 1));
+    const largest = Math.max(...safe, 1);
+    const total = safe.reduce((sum, value) => sum + value / largest, 0);
+    return safe.map((value) => value / largest / total);
+}
+function flattenSplits(node) {
+    if (node.type === 'pane') {
+        return node;
+    }
+    const children = [];
+    const sizes = [];
+    node.children.forEach((child, i) => {
+        const next = flattenSplits(child);
+        // A divider balances neighboring tracks, not a pane against a hidden group on the same axis.
+        if (next.type === 'split' && next.axis === node.axis) {
+            children.push(...next.children);
+            sizes.push(...next.sizes.map((size) => size * node.sizes[i]));
+        }
+        else {
+            children.push(next);
+            sizes.push(node.sizes[i]);
+        }
+    });
+    if (children.length === node.children.length && children.every((child, i) => child === node.children[i])) {
+        return node;
+    }
+    return { ...node, children, sizes: shares(sizes, children.length) };
+}
+/** Repairs persisted data at the application boundary; view payloads never enter the layout. */
+export function normalizeSplitLayout(value) {
+    const ids = new Set();
+    const views = new Set();
+    const seen = new Set();
+    let serial = 0;
+    const nextId = (candidate) => {
+        let id = typeof candidate === 'string' && candidate.length > 0 ? candidate : `pane-${serial++}`;
+        while (ids.has(id)) {
+            id = `pane-${serial++}`;
+        }
+        ids.add(id);
+        return id;
+    };
+    const read = (input, depth) => {
+        if (input === null || typeof input !== 'object' || seen.has(input) || depth > 64) {
+            return null;
+        }
+        seen.add(input);
+        const row = input;
+        if (row.type === 'pane') {
+            const items = Array.isArray(row.views)
+                ? row.views.filter((view) => {
+                    if (typeof view !== 'string' || view.length === 0 || views.has(view)) {
+                        return false;
+                    }
+                    views.add(view);
+                    return true;
+                })
+                : [];
+            return {
+                type: 'pane',
+                id: nextId(row.id),
+                views: items,
+                active: typeof row.active === 'string' && items.includes(row.active) ? row.active : (items[0] ?? null)
+            };
+        }
+        if (row.type !== 'split' || !Array.isArray(row.children)) {
+            return null;
+        }
+        const children = [];
+        const sizes = [];
+        row.children.forEach((child, i) => {
+            const result = read(child, depth + 1);
+            if (result) {
+                children.push(result);
+                sizes.push(Array.isArray(row.sizes) ? Number(row.sizes[i]) : 1);
+            }
+        });
+        if (children.length < 2) {
+            return children[0] ?? null;
+        }
+        return {
+            type: 'split',
+            id: nextId(row.id),
+            axis: row.axis === 'vertical' ? 'vertical' : 'horizontal',
+            children,
+            sizes: shares(sizes, children.length)
+        };
+    };
+    const input = value !== null && typeof value === 'object' ? value : {};
+    const root = flattenSplits(read(input.root, 0) ?? createSplitLayout().root);
+    const panes = splitPanes(root);
+    return {
+        root,
+        focused: panes.find((pane) => pane.id === input.focused)?.id ?? panes[0].id,
+        maximized: panes.find((pane) => pane.id === input.maximized)?.id ?? null
+    };
+}
+function replace(node, id, transform) {
+    if (node.id === id) {
+        return transform(node);
+    }
+    if (node.type === 'pane') {
+        return node;
+    }
+    const children = [];
+    const sizes = [];
+    node.children.forEach((child, i) => {
+        const next = replace(child, id, transform);
+        if (next) {
+            children.push(next);
+            sizes.push(node.sizes[i]);
+        }
+    });
+    if (children.every((child, i) => child === node.children[i]) && children.length === node.children.length) {
+        return node;
+    }
+    if (children.length < 2) {
+        return children[0] ?? null;
+    }
+    return { ...node, children, sizes: shares(sizes, children.length) };
+}
+function finish(layout, root, focus = layout.focused) {
+    const next = flattenSplits(root ?? createSplitLayout([], layout.focused).root);
+    const panes = splitPanes(next);
+    return {
+        root: next,
+        focused: panes.some((pane) => pane.id === focus) ? focus : panes[0].id,
+        maximized: panes.some((pane) => pane.id === layout.maximized) ? layout.maximized : null
+    };
+}
+function without(pane, views) {
+    const remaining = pane.views.filter((view) => !views.includes(view));
+    const position = Math.max(0, pane.views.indexOf(pane.active ?? ''));
+    return {
+        ...pane,
+        views: remaining,
+        active: remaining.includes(pane.active ?? '') ? pane.active : (remaining[Math.min(position, remaining.length - 1)] ?? null)
+    };
+}
+function beside(target, pane, side, id) {
+    return {
+        type: 'split',
+        id,
+        axis: side === 'left' || side === 'right' ? 'horizontal' : 'vertical',
+        children: side === 'left' || side === 'top' ? [pane, target] : [target, pane],
+        sizes: [0.5, 0.5]
+    };
+}
+function equalizeAxis(root, axis, length, gap) {
+    const tracks = new Map();
+    const measure = (node) => {
+        const children = node.type === 'split' ? node.children.map(measure) : [];
+        const count = node.type === 'pane' ? 1 : node.axis === axis ? children.reduce((sum, value) => sum + value, 0) : Math.max(...children);
+        tracks.set(node.id, count);
+        return count;
+    };
+    measure(root);
+    const distribute = (node, extent) => {
+        if (node.type === 'pane') {
+            return node;
+        }
+        if (node.axis !== axis) {
+            return { ...node, children: node.children.map((child) => distribute(child, extent)) };
+        }
+        const count = tracks.get(node.id);
+        const spacing = Math.min(gap, extent / (count - 1));
+        const unit = Math.max(0, extent - spacing * (count - 1)) / count;
+        // Spanning panels also occupy the gaps between their tracks.
+        const lengths = node.children.map((child) => {
+            const span = tracks.get(child.id);
+            return Math.max(Number.EPSILON, unit * span + spacing * (span - 1));
+        });
+        return { ...node, sizes: shares(lengths, lengths.length), children: node.children.map((child, i) => distribute(child, lengths[i])) };
+    };
+    return distribute(root, length);
+}
+/** Invalid or stale commands are no-ops. IDs for new nodes come from the caller. */
+export function updateSplitLayout(layout, command) {
+    const panes = splitPanes(layout.root);
+    const pane = 'paneId' in command ? panes.find((item) => item.id === command.paneId) : undefined;
+    switch (command.type) {
+        case 'focus':
+            return pane && layout.focused !== pane.id ? { ...layout, focused: pane.id } : layout;
+        case 'maximize':
+            return command.paneId === null || pane ? { ...layout, maximized: command.paneId, focused: pane?.id ?? layout.focused } : layout;
+        case 'activate':
+            return pane?.views.includes(command.viewId)
+                ? finish(layout, replace(layout.root, pane.id, () => ({ ...pane, active: command.viewId })), pane.id)
+                : layout;
+        case 'close': {
+            const source = panes.find((item) => item.views.includes(command.viewId));
+            if (!source) {
+                return layout;
+            }
+            const next = without(source, [command.viewId]);
+            return finish(layout, replace(layout.root, source.id, () => (next.views.length || panes.length === 1 ? next : null)));
+        }
+        case 'closePane':
+            return pane
+                ? finish(layout, replace(layout.root, pane.id, () => null))
+                : layout;
+        case 'insert': {
+            if (!pane) {
+                return layout;
+            }
+            const source = panes.find((item) => item.views.includes(command.viewId));
+            if (source) {
+                return updateSplitLayout(layout, { type: 'move', sourceId: source.id, targetId: pane.id, viewId: command.viewId, index: command.index });
+            }
+            const views = [...pane.views];
+            views.splice(Math.max(0, Math.min(views.length, command.index ?? views.length)), 0, command.viewId);
+            return finish(layout, replace(layout.root, pane.id, () => ({ ...pane, views, active: command.viewId })), pane.id);
+        }
+        case 'split': {
+            if (!pane ||
+                findSplitNode(layout.root, command.newPane.id) ||
+                findSplitNode(layout.root, command.splitId) ||
+                command.newPane.id === command.splitId) {
+                return layout;
+            }
+            const allViews = new Set(panes.flatMap((item) => item.views));
+            if (command.newPane.views.some((view) => allViews.has(view)) || new Set(command.newPane.views).size !== command.newPane.views.length) {
+                return layout;
+            }
+            const added = {
+                ...command.newPane,
+                active: command.newPane.views.includes(command.newPane.active ?? '') ? command.newPane.active : (command.newPane.views[0] ?? null)
+            };
+            return finish({ ...layout, maximized: null }, replace(layout.root, pane.id, () => beside(pane, added, command.side, command.splitId)), added.id);
+        }
+        case 'swap': {
+            const source = panes.find((item) => item.id === command.sourceId);
+            const target = panes.find((item) => item.id === command.targetId);
+            if (!source ||
+                !target ||
+                source === target ||
+                source.views.length === 0 ||
+                (command.viewId !== undefined && !source.views.includes(command.viewId))) {
+                return layout;
+            }
+            if (command.viewId === undefined || source.views.length === 1) {
+                const exchange = (node) => {
+                    if (node.id === source.id) {
+                        return target;
+                    }
+                    if (node.id === target.id) {
+                        return source;
+                    }
+                    return node.type === 'pane' ? node : { ...node, children: node.children.map(exchange) };
+                };
+                return finish({ ...layout, maximized: null }, exchange(layout.root), source.id);
+            }
+            const moving = command.viewId;
+            const displaced = target.active;
+            const sourceNext = displaced === null
+                ? without(source, [moving])
+                : {
+                    ...source,
+                    views: source.views.map((view) => (view === moving ? displaced : view)),
+                    active: source.active === moving ? displaced : source.active
+                };
+            const targetNext = {
+                ...target,
+                views: displaced === null ? [moving] : target.views.map((view) => (view === displaced ? moving : view)),
+                active: moving
+            };
+            const root = replace(layout.root, source.id, () => sourceNext);
+            return finish({ ...layout, maximized: null }, replace(root, target.id, () => targetNext), target.id);
+        }
+        case 'move': {
+            const source = panes.find((item) => item.id === command.sourceId);
+            const target = panes.find((item) => item.id === command.targetId);
+            if (!source || !target || (command.viewId !== undefined && !source.views.includes(command.viewId))) {
+                return layout;
+            }
+            const moving = command.viewId === undefined ? source.views : [command.viewId];
+            if (!moving.length || (source === target && (command.viewId === undefined || (command.side !== undefined && source.views.length === 1)))) {
+                return layout;
+            }
+            let added;
+            if (command.side) {
+                const id = command.viewId === undefined ? source.id : command.newPaneId;
+                if (!id ||
+                    !command.splitId ||
+                    id === command.splitId ||
+                    findSplitNode(layout.root, command.splitId) ||
+                    (findSplitNode(layout.root, id) && !(id === source.id && command.viewId === undefined))) {
+                    return layout;
+                }
+                added = { type: 'pane', id, views: moving, active: command.viewId ?? source.active };
+            }
+            const remaining = without(source, moving);
+            const root = replace(layout.root, source.id, () => (remaining.views.length || source === target ? remaining : null));
+            if (!root) {
+                return layout;
+            }
+            const next = replace(root, target.id, (node) => {
+                if (node.type !== 'pane') {
+                    return node;
+                }
+                if (added && command.side && command.splitId) {
+                    return beside(node, added, command.side, command.splitId);
+                }
+                const gap = Math.max(0, Math.min(target.views.length, command.index ?? target.views.length));
+                const lifted = source === target ? target.views.slice(0, gap).filter((view) => moving.includes(view)).length : 0;
+                const views = [...node.views];
+                views.splice(gap - lifted, 0, ...moving);
+                return { ...node, views, active: command.viewId ?? source.active ?? views[0] ?? null };
+            });
+            return finish({ ...layout, maximized: null }, next, added?.id ?? target.id);
+        }
+        case 'equalizeAxis': {
+            const length = command.length ?? 1;
+            const gap = command.gap ?? 0;
+            if (layout.root.type === 'pane' || !Number.isFinite(length) || length <= 0 || !Number.isFinite(gap) || gap < 0) {
+                return layout;
+            }
+            return finish(layout, equalizeAxis(layout.root, command.axis, length, gap));
+        }
+        case 'resize':
+        case 'equalize': {
+            const node = findSplitNode(layout.root, command.splitId);
+            if (!node || node.type !== 'split') {
+                return layout;
+            }
+            let sizes = [...node.sizes];
+            if (command.type === 'resize') {
+                if (command.sizes.length !== node.children.length || command.sizes.some((size) => !Number.isFinite(size) || size <= 0)) {
+                    return layout;
+                }
+                sizes = shares(command.sizes, node.children.length);
+            }
+            else if (command.index === undefined) {
+                sizes = node.children.map(() => 1 / node.children.length);
+            }
+            else {
+                const index = command.index;
+                if (index < 0 || index >= sizes.length - 1) {
+                    return layout;
+                }
+                sizes[index] = sizes[index + 1] = (sizes[index] + sizes[index + 1]) / 2;
+            }
+            return finish(layout, replace(layout.root, node.id, () => ({ ...node, sizes })));
+        }
+    }
+}