@voithos-labs/aragonite 0.10.2 → 0.10.3

package/dist/components/blocks/code/CodeLanguageChip.svelte

@@ -1,127 +0,0 @@
-<script lang="ts">
-	import { tick } from 'svelte';
-	import { CODE_LANGUAGE_FIELD, codeLanguageLabel } from '../../../a11y-strings';
-
-	// The fence-info door for the modes that paint no fence. The draft lives here and only a
-	// commit reaches the tree.
-	let {
-		info,
-		editable,
-		onCommit,
-		onCancel
-	}: {
-		/** The opener's full info string; the button shows its first token. */
-		info: string;
-		/** False in reading mode, which writes no bytes — the chip is then a label. */
-		editable: boolean;
-		/** Only Enter calls this, and it owns the caret's landing afterwards. */
-		onCommit: (info: string) => void;
-		/** Nothing written. Escape asks for the caret back; a blur must not yank it from
-		 *  wherever the user just clicked, so it does not. */
-		onCancel: (returnCaret: boolean) => void;
-	} = $props();
-
-	const language = $derived(info.split(/\s+/)[0] || 'text');
-
-	let editing = $state(false);
-	let draft = $state('');
-	let inputEl: HTMLInputElement | undefined = $state();
-
-	function open(): void {
-		if (!editable) return;
-		draft = info;
-		editing = true;
-		void tick().then(() => {
-			inputEl?.focus();
-			inputEl?.select();
-		});
-	}
-
-	function onFieldKeyDown(e: KeyboardEvent): void {
-		// The field owns its keys while open: no Escape of this state may reach whatever else
-		// listens for one. A composing Enter/Escape is the IME's, never the field's.
-		e.stopPropagation();
-		if (e.isComposing) return;
-		if (e.key === 'Enter') {
-			e.preventDefault();
-			const committed = draft;
-			editing = false;
-			onCommit(committed);
-		} else if (e.key === 'Escape') {
-			e.preventDefault();
-			editing = false;
-			onCancel(true);
-		}
-	}
-
-	function onFieldBlur(): void {
-		if (!editing) return;
-		editing = false;
-		onCancel(false);
-	}
-</script>
-
-<span class="code-lang-chip">
-	{#if editing}
-		<input
-			bind:this={inputEl}
-			bind:value={draft}
-			type="text"
-			spellcheck="false"
-			aria-label={CODE_LANGUAGE_FIELD}
-			onkeydown={onFieldKeyDown}
-			onfocusout={onFieldBlur}
-		/>
-	{:else}
-		<button type="button" aria-label={codeLanguageLabel(language)} onclick={open}>{language}</button
-		>
-	{/if}
-</span>
-
-<style>
-	/* Positioned against the block host, whose box the code box fills, and out of the code
-	   box's own scroller so a horizontal scroll leaves it where it is. */
-	.code-lang-chip {
-		position: absolute;
-		top: 5px;
-		right: 5px;
-		z-index: 1;
-		display: flex;
-		font-family: var(--font-editor, ui-monospace, monospace);
-		font-size: 0.75em;
-		line-height: 1;
-		opacity: 0;
-		pointer-events: none;
-	}
-
-	/* Transient, like the drag handle: the pointer over the block or the caret inside it, plus
-	   the open field, which outlives both. Child and sibling combinators, so an outer container's
-	   hover never reveals a nested block's chip. */
-	:global(.block-host:hover) > .code-lang-chip,
-	:global(.code-block:focus) ~ .code-lang-chip,
-	.code-lang-chip:focus-within {
-		opacity: 1;
-		pointer-events: auto;
-	}
-
-	button,
-	input {
-		padding: 2px 6px;
-		border: 1px solid var(--color-ui-muted, #a4a4a4);
-		border-radius: var(--radius-ui, 3px);
-		background: var(--color-bg-elevated, #2a2a2a);
-		color: var(--color-accent, #567b67);
-		font: inherit;
-		cursor: pointer;
-	}
-
-	button:hover {
-		background: var(--color-ui-faint, rgba(255, 255, 255, 0.07));
-	}
-
-	input {
-		width: 9ch;
-		color: var(--color-text-secondary, #eee);
-		cursor: text;
-	}
-</style>

package/dist/components/blocks/code/CodeLanguageChip.svelte.d.ts

@@ -1,14 +0,0 @@
-type $$ComponentProps = {
-    /** The opener's full info string; the button shows its first token. */
-    info: string;
-    /** False in reading mode, which writes no bytes — the chip is then a label. */
-    editable: boolean;
-    /** Only Enter calls this, and it owns the caret's landing afterwards. */
-    onCommit: (info: string) => void;
-    /** Nothing written. Escape asks for the caret back; a blur must not yank it from
-     *  wherever the user just clicked, so it does not. */
-    onCancel: (returnCaret: boolean) => void;
-};
-declare const CodeLanguageChip: import("svelte").Component<$$ComponentProps, {}, "">;
-type CodeLanguageChip = ReturnType<typeof CodeLanguageChip>;
-export default CodeLanguageChip;

package/dist/components/blocks/table/TableGrip.svelte

@@ -1,91 +0,0 @@
-<script lang="ts">
-	let {
-		axis,
-		onActivate,
-		onpointerdown
-	}: {
-		axis: 'row' | 'column';
-		onActivate: (e: MouseEvent) => void;
-		onpointerdown?: (e: PointerEvent) => void;
-	} = $props();
-
-	function handlePointerDown(e: PointerEvent): void {
-		// The affordance opens a menu, it doesn't place a caret, so the grip's pointer
-		// stream stays off the editor's selection/focus handlers.
-		e.stopPropagation();
-		onpointerdown?.(e);
-	}
-</script>
-
-<!-- Pointer-only affordance: the cell chords are the operable, screen-reader path, so the
-	grip stays out of the tab/SR flow. Reveal is pure CSS: hover in editor.css, touch below. -->
-<span class="table-grip-anchor table-grip-anchor-{axis}">
-	<span
-		class="table-grip table-grip-{axis}"
-		data-table-col-grip={axis === 'column' ? '' : undefined}
-		data-table-row-grip={axis === 'row' ? '' : undefined}
-		aria-hidden="true"
-		onclick={onActivate}
-		onpointerdown={handlePointerDown}
-	></span>
-</span>
-
-<style>
-	/* Zero-height so it never adds a visible band or shifts caret-measured layout;
-	   z-index lifts the dots above the DOM-later header cell, which would eat the click. */
-	.table-grip-anchor-column {
-		position: relative;
-		z-index: 2;
-		height: 0;
-	}
-
-	/* The dotted bar shared by both axes; the axis rules add only the geometry. */
-	.table-grip {
-		position: absolute;
-		color: var(--color-ui-muted, #a4a4a4);
-		background-image: radial-gradient(currentColor 40%, transparent 45%);
-		background-position: center;
-		cursor: pointer;
-		opacity: 0;
-		pointer-events: none;
-	}
-
-	/* Sits within the header cell's top padding so it never overlaps the caret-click target. */
-	.table-grip-column {
-		top: 0;
-		left: 50%;
-		transform: translateX(-50%);
-		width: 1.75rem;
-		height: 0.35rem;
-		background-size: 0.25rem 0.35rem;
-		background-repeat: repeat-x;
-	}
-
-	/* Zero-width gutter item, stretched to the row height. z-index lifts the dots above
-	   cell A, which renders DOM-later and would otherwise paint over them. */
-	.table-grip-anchor-row {
-		position: relative;
-		z-index: 2;
-	}
-
-	/* Overflows out of the zero-width gutter into cell A's left padding, clear of the text. */
-	.table-grip-row {
-		top: 50%;
-		left: 0.15rem;
-		transform: translateY(-50%);
-		width: 0.35rem;
-		height: 1rem;
-		background-size: 0.35rem 0.25rem;
-		background-repeat: repeat-y;
-	}
-
-	/* Touch fires no hover, so the editor.css reveal never runs and an opted-in host's grips
-	   would be unreachable. `touch-action` keeps a reorder drag off the table's own scroll. */
-	@media (hover: none) {
-		.table-grip {
-			opacity: 1;
-			pointer-events: auto;
-			touch-action: none;
-		}
-	}
-</style>

package/dist/components/blocks/table/TableGrip.svelte.d.ts

@@ -1,8 +0,0 @@
-type $$ComponentProps = {
-    axis: 'row' | 'column';
-    onActivate: (e: MouseEvent) => void;
-    onpointerdown?: (e: PointerEvent) => void;
-};
-declare const TableGrip: import("svelte").Component<$$ComponentProps, {}, "">;
-type TableGrip = ReturnType<typeof TableGrip>;
-export default TableGrip;

package/dist/components/blocks/table/table-drop-target.d.ts

@@ -1 +0,0 @@
-export declare function dropGapIndex(pointer: number, edges: number[]): number;

package/dist/components/blocks/table/table-drop-target.js

@@ -1,16 +0,0 @@
-// Map a reorder drag's pointer to the insertion gap it sits nearest. `edges` are the
-// row/column boundaries in pointer space, so N tracks yield N+1 edges. The result is a
-// gap index, not the occupied cell `table-drag-hit-test` returns.
-export function dropGapIndex(pointer, edges) {
-    let nearest = 0;
-    let nearestDistance = Infinity;
-    for (let i = 0; i < edges.length; i++) {
-        const distance = Math.abs(pointer - edges[i]);
-        // Strict `<` keeps the lower gap when the pointer is exactly equidistant.
-        if (distance < nearestDistance) {
-            nearest = i;
-            nearestDistance = distance;
-        }
-    }
-    return nearest;
-}

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

@@ -1,78 +0,0 @@
-/**
- * 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

@@ -1,97 +0,0 @@
-/**
- * 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 };
-        }
-    });
-}