@voithos-labs/aragonite 0.10.1

package/dist/components/blocks/table/table-menu-model.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Pure model for the table affordance menu: which items a target cell, row, or column
+ * offers and whether each is enabled. Enablement reuses the context's own refusal
+ * predicates, so a disabled item can never reach a no-op commit.
+ */
+import type { TableAxisAction } from '../../../action-contracts';
+import type { TableAlignment } from '../../../core/nodes';
+export type ClipboardAction = 'cut' | 'copy' | 'paste';
+/**
+ * Clamp a fixed-position menu's top-left into the viewport (minus `margin`) — menus
+ * open at a raw pointer/grip coordinate. Larger than the viewport pins to top/left.
+ */
+export declare function clampMenuToViewport(desired: {
+    x: number;
+    y: number;
+}, menu: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}, margin?: number): {
+    x: number;
+    y: number;
+};
+export type TableMenuItem = {
+    kind: 'action';
+    action: TableAxisAction;
+    label: string;
+    enabled: boolean;
+    index: number;
+} | {
+    kind: 'clipboard';
+    action: ClipboardAction;
+    label: string;
+    enabled: boolean;
+} | {
+    kind: 'alignment';
+    current: TableAlignment;
+} | {
+    kind: 'separator';
+};
+export declare function tableMenuItems(target: {
+    rowIdx?: number;
+    colIdx?: number;
+}, dims: {
+    rowCount: number;
+    colCount: number;
+}, alignments: readonly TableAlignment[], clipboard?: {
+    hasSelection: boolean;
+    hasRect?: boolean;
+}): TableMenuItem[];

package/dist/components/blocks/table/table-menu-model.js

@@ -0,0 +1,78 @@
+import { tableRowReorderTarget, tableColumnReorderTarget } from '../../../editor-actions/table-context';
+import { canDeleteRow, canDeleteColumn } from '../../../tree-operations/table-mutations';
+/**
+ * Clamp a fixed-position menu's top-left into the viewport (minus `margin`) — menus
+ * open at a raw pointer/grip coordinate. Larger than the viewport pins to top/left.
+ */
+export function clampMenuToViewport(desired, menu, viewport, margin = 8) {
+    const maxX = Math.max(margin, viewport.width - menu.width - margin);
+    const maxY = Math.max(margin, viewport.height - menu.height - margin);
+    return {
+        x: Math.min(Math.max(margin, desired.x), maxX),
+        y: Math.min(Math.max(margin, desired.y), maxY)
+    };
+}
+export function tableMenuItems(target, dims, alignments, 
+// Present only for a cell right-click; grip menus never show the clipboard group. A
+// live rectangle (`hasRect`) suppresses the cell-local selection but still serves Cut/Copy.
+clipboard) {
+    const items = [];
+    const isCell = target.rowIdx != null && target.colIdx != null;
+    if (isCell && clipboard)
+        items.push(...clipboardGroup(clipboard.hasSelection || clipboard.hasRect === true), {
+            kind: 'separator'
+        });
+    if (target.rowIdx != null)
+        items.push(...rowGroup(target.rowIdx, dims.rowCount));
+    if (isCell)
+        items.push({ kind: 'separator' });
+    if (target.colIdx != null)
+        items.push(...columnGroup(target.colIdx, dims.colCount, alignments));
+    return items;
+}
+// Paste always applies: clipboard contents aren't readable synchronously to gate it.
+function clipboardGroup(hasContent) {
+    return [
+        { kind: 'clipboard', action: 'cut', label: 'Cut', enabled: hasContent },
+        { kind: 'clipboard', action: 'copy', label: 'Copy', enabled: hasContent },
+        { kind: 'clipboard', action: 'paste', label: 'Paste', enabled: true }
+    ];
+}
+function axisItems(index, entries) {
+    return entries.map(([action, label, enabled]) => ({
+        kind: 'action',
+        action,
+        label,
+        enabled,
+        index
+    }));
+}
+function rowGroup(rowIdx, rowCount) {
+    return axisItems(rowIdx, [
+        ['insertRowAbove', 'Insert row above', true],
+        ['insertRowBelow', 'Insert row below', true],
+        ['moveRowUp', 'Move row up', tableRowReorderTarget(rowIdx, -1, rowCount) !== null],
+        ['moveRowDown', 'Move row down', tableRowReorderTarget(rowIdx, 1, rowCount) !== null],
+        ['deleteRow', 'Delete row', canDeleteRow(rowIdx, rowCount)]
+    ]);
+}
+function columnGroup(colIdx, colCount, alignments) {
+    return [
+        ...axisItems(colIdx, [
+            ['insertColumnLeft', 'Insert column left', true],
+            ['insertColumnRight', 'Insert column right', true],
+            [
+                'moveColumnLeft',
+                'Move column left',
+                tableColumnReorderTarget(colIdx, -1, colCount) !== null
+            ],
+            [
+                'moveColumnRight',
+                'Move column right',
+                tableColumnReorderTarget(colIdx, 1, colCount) !== null
+            ],
+            ['deleteColumn', 'Delete column', canDeleteColumn(colCount)]
+        ]),
+        { kind: 'alignment', current: alignments[colIdx] }
+    ];
+}

package/dist/components/blocks/table/table-navigation.d.ts

@@ -0,0 +1,8 @@
+export interface CellCoord {
+    rowIdx: number;
+    colIdx: number;
+}
+export declare function nextCell(pos: CellCoord, columnCount: number, rowCount: number): CellCoord | null;
+export declare function prevCell(pos: CellCoord, columnCount: number): CellCoord | null;
+export declare function cellAbove(pos: CellCoord): CellCoord | null;
+export declare function cellBelow(pos: CellCoord, rowCount: number): CellCoord | null;

package/dist/components/blocks/table/table-navigation.js

@@ -0,0 +1,22 @@
+// Pure: no DOM, no Svelte. Null means "no cell that way" — what the caller does with
+// the edge (exit, append a row) is the plan's decision, not this module's.
+export function nextCell(pos, columnCount, rowCount) {
+    if (pos.colIdx < columnCount - 1)
+        return { rowIdx: pos.rowIdx, colIdx: pos.colIdx + 1 };
+    if (pos.rowIdx < rowCount - 1)
+        return { rowIdx: pos.rowIdx + 1, colIdx: 0 };
+    return null;
+}
+export function prevCell(pos, columnCount) {
+    if (pos.colIdx > 0)
+        return { rowIdx: pos.rowIdx, colIdx: pos.colIdx - 1 };
+    if (pos.rowIdx > 0)
+        return { rowIdx: pos.rowIdx - 1, colIdx: columnCount - 1 };
+    return null;
+}
+export function cellAbove(pos) {
+    return pos.rowIdx === 0 ? null : { rowIdx: pos.rowIdx - 1, colIdx: pos.colIdx };
+}
+export function cellBelow(pos, rowCount) {
+    return pos.rowIdx === rowCount - 1 ? null : { rowIdx: pos.rowIdx + 1, colIdx: pos.colIdx };
+}

package/dist/components/blocks/table/table-reorder-drag.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Pointer drag-to-reorder for table rows and columns: a shared drag session paints a single
+ * insertion line (no tree mutation, no reflow) and commits ONE move on release. The axes diverge
+ * only in geometry — rows are windowed under a fixed header, so their indices are absolute and
+ * off-window targets need autoscroll to mount; columns are neither.
+ */
+import type { UserScrollport } from '../../../cursor/scroll-ancestors';
+import { type PointerPosition } from '../../../selection/pointer-session';
+/** Members every reorder-axis context shares; the row/column contexts extend it. */
+interface AxisReorderDragContext<TLine> {
+    /** The editor's scrollport, which in host mode may be an ancestor or the window. */
+    getScrollContainer(): UserScrollport | null;
+    setLine(line: TLine | null): void;
+    /** Marks the gesture a drag (not a click) so the grip's menu stays closed. */
+    onDragRecognized(): void;
+    commit(from: number, to: number): void;
+    /** Aborted on editor unmount — tears down a drag whose pointerup can't fire. */
+    lifetimeSignal?: AbortSignal;
+}
+export interface TableReorderDragContext<TLine> extends AxisReorderDragContext<TLine> {
+    from: number;
+    /**
+     * Pure per-axis map from the live pointer to the insertion line and clamped drop
+     * index (null when geometry is unavailable). Returns rather than sets, so the axis
+     * clamps stay unit-testable in isolation.
+     */
+    process(pointer: PointerPosition): {
+        line: TLine;
+        dropTo: number;
+    } | null;
+    /** The autoscroll axis only — rows scroll both ways, a wide table's columns horizontally. */
+    autoScrollAxis: 'horizontal' | 'vertical' | 'both';
+}
+export declare function startTableReorderDrag<TLine>(down: PointerEvent, ctx: TableReorderDragContext<TLine>): void;
+export interface RowReorderLine {
+    left: number;
+    top: number;
+    width: number;
+}
+export interface RowReorderGeometry {
+    /** Viewport-Y boundaries of the mounted rows: each row's top, plus the last row's bottom. */
+    rowEdges: number[];
+    /**
+     * Absolute gap index for each `rowEdges` entry, so a drop maps a local edge to a
+     * body position even once the window has scrolled past row 0.
+     */
+    gapIndices: number[];
+    /** Viewport-left and width of the table, for the insertion line's horizontal span. */
+    left: number;
+    width: number;
+}
+export interface RowReorderDragContext extends AxisReorderDragContext<RowReorderLine> {
+    fromRowIdx: number;
+    /** Live total row count — read each move so the header clamp tracks edits/re-slices. */
+    getRowCount(): number;
+    getGeometry(): RowReorderGeometry | null;
+}
+export declare function startRowReorderDrag(down: PointerEvent, ctx: RowReorderDragContext): void;
+export interface ColumnReorderLine {
+    left: number;
+    top: number;
+    height: number;
+}
+export interface ColumnReorderGeometry {
+    /** Viewport-X boundaries of the columns: each column's left, plus the last column's right. */
+    colEdges: number[];
+    /** Viewport-top and height of the table, for the insertion line's vertical span. */
+    top: number;
+    height: number;
+}
+export interface ColumnReorderDragContext extends AxisReorderDragContext<ColumnReorderLine> {
+    fromColIdx: number;
+    /** Live total column count — read each move so the clamp tracks edits. */
+    getColCount(): number;
+    getGeometry(): ColumnReorderGeometry | null;
+}
+export declare function startColumnReorderDrag(down: PointerEvent, ctx: ColumnReorderDragContext): void;
+export {};

package/dist/components/blocks/table/table-reorder-drag.js

@@ -0,0 +1,97 @@
+/**
+ * Pointer drag-to-reorder for table rows and columns: a shared drag session paints a single
+ * insertion line (no tree mutation, no reflow) and commits ONE move on release. The axes diverge
+ * only in geometry — rows are windowed under a fixed header, so their indices are absolute and
+ * off-window targets need autoscroll to mount; columns are neither.
+ */
+import { dropGapIndex } from './table-drop-target';
+import { createPointerDragSession } from '../../../selection/pointer-session';
+// Past this much pointer travel the gesture is a drag, not a menu-opening click.
+const DRAG_THRESHOLD_PX = 4;
+export function startTableReorderDrag(down, ctx) {
+    let dragging = false;
+    let dropTo = null;
+    createPointerDragSession(down, {
+        threshold: DRAG_THRESHOLD_PX,
+        onDragRecognized: () => {
+            dragging = true;
+            ctx.onDragRecognized();
+        },
+        onMove: (pointer) => {
+            const result = ctx.process(pointer);
+            if (!result)
+                return;
+            dropTo = result.dropTo;
+            ctx.setLine(result.line);
+        },
+        // A sub-threshold press is a menu-opening click, not a reorder.
+        onEnd: (reason) => {
+            if (reason === 'up' && dragging && dropTo !== null && dropTo !== ctx.from) {
+                ctx.commit(ctx.from, dropTo);
+            }
+        },
+        onTeardown: () => ctx.setLine(null),
+        autoScroll: {
+            axis: ctx.autoScrollAxis,
+            getTargets: () => {
+                const sc = ctx.getScrollContainer();
+                return sc ? [sc] : [];
+            }
+        },
+        escape: true,
+        // Up front, not at threshold: a native text selection can begin from the empty
+        // grip before the first qualifying move and survive the drag.
+        disableUserSelect: true,
+        lifetimeSignal: ctx.lifetimeSignal
+    });
+}
+export function startRowReorderDrag(down, ctx) {
+    startTableReorderDrag(down, {
+        from: ctx.fromRowIdx,
+        autoScrollAxis: 'both',
+        getScrollContainer: ctx.getScrollContainer,
+        setLine: ctx.setLine,
+        onDragRecognized: ctx.onDragRecognized,
+        commit: ctx.commit,
+        lifetimeSignal: ctx.lifetimeSignal,
+        process(pointer) {
+            const geom = ctx.getGeometry();
+            if (!geom)
+                return null;
+            // The LOCAL edge among mounted rows; gapIndices maps it to the absolute gap.
+            let edge = dropGapIndex(pointer.clientY, geom.rowEdges);
+            // Never land above the fixed header (gap 0); reachable only while row 0 is mounted.
+            if (geom.gapIndices[edge] < 1)
+                edge = Math.min(edge + 1, geom.gapIndices.length - 1);
+            const gap = geom.gapIndices[edge];
+            // Insert semantics: removing the dragged row shifts later slots down by one.
+            const target = gap <= ctx.fromRowIdx ? gap : gap - 1;
+            const dropTo = Math.max(1, Math.min(target, ctx.getRowCount() - 1));
+            return { line: { left: geom.left, top: geom.rowEdges[edge], width: geom.width }, dropTo };
+        }
+    });
+}
+export function startColumnReorderDrag(down, ctx) {
+    startTableReorderDrag(down, {
+        from: ctx.fromColIdx,
+        // Pinned in the table's top band; vertical evaluation would spin the loop on a
+        // `.table-block` that only scrolls horizontally (autoscroll.ts § axis).
+        autoScrollAxis: 'horizontal',
+        getScrollContainer: ctx.getScrollContainer,
+        setLine: ctx.setLine,
+        onDragRecognized: ctx.onDragRecognized,
+        commit: ctx.commit,
+        lifetimeSignal: ctx.lifetimeSignal,
+        process(pointer) {
+            const geom = ctx.getGeometry();
+            if (!geom)
+                return null;
+            // Columns aren't windowed and have no header, so the edge index IS the drop gap.
+            const gap = dropGapIndex(pointer.clientX, geom.colEdges);
+            // Insert semantics: removing the dragged column shifts later slots left by one.
+            const target = gap <= ctx.fromColIdx ? gap : gap - 1;
+            const dropTo = Math.max(0, Math.min(target, ctx.getColCount() - 1));
+            return { line: { left: geom.colEdges[gap], top: geom.top, height: geom.height }, dropTo };
+        }
+    });
+}