@threadlabs/looma 0.3.1 → 0.5.0

package/editor/chunks/table-backgrounds.js

@@ -0,0 +1,51 @@
+//#region src/editor/table-backgrounds.ts
+/** Canonical persisted colors shared by editor commands and table UI swatches. */
+var TABLE_CELL_BACKGROUND_PRESETS = {
+	none: null,
+	gray: "#f3f4f6",
+	yellow: "#fef3c7",
+	blue: "#dbeafe",
+	green: "#dcfce7",
+	red: "#fee2e2"
+};
+/** Ordered menu choices coupling each UI intent to its persisted color value. */
+var TABLE_CELL_BACKGROUND_OPTIONS = [
+	{
+		action: "background-none",
+		label: "Default",
+		value: TABLE_CELL_BACKGROUND_PRESETS.none,
+		swatch: null
+	},
+	{
+		action: "background-gray",
+		label: "Gray",
+		value: TABLE_CELL_BACKGROUND_PRESETS.gray,
+		swatch: TABLE_CELL_BACKGROUND_PRESETS.gray
+	},
+	{
+		action: "background-yellow",
+		label: "Yellow",
+		value: TABLE_CELL_BACKGROUND_PRESETS.yellow,
+		swatch: TABLE_CELL_BACKGROUND_PRESETS.yellow
+	},
+	{
+		action: "background-blue",
+		label: "Blue",
+		value: TABLE_CELL_BACKGROUND_PRESETS.blue,
+		swatch: TABLE_CELL_BACKGROUND_PRESETS.blue
+	},
+	{
+		action: "background-green",
+		label: "Green",
+		value: TABLE_CELL_BACKGROUND_PRESETS.green,
+		swatch: TABLE_CELL_BACKGROUND_PRESETS.green
+	},
+	{
+		action: "background-red",
+		label: "Red",
+		value: TABLE_CELL_BACKGROUND_PRESETS.red,
+		swatch: TABLE_CELL_BACKGROUND_PRESETS.red
+	}
+];
+//#endregion
+export { TABLE_CELL_BACKGROUND_PRESETS as n, TABLE_CELL_BACKGROUND_OPTIONS as t };

package/editor/chunks/ui.js

@@ -0,0 +1,92 @@
+//#region src/editor/table-overlay.ts
+function mapTableCells(table) {
+	const rows = Array.from(table.rows);
+	const grid = [];
+	const coordinates = /* @__PURE__ */ new Map();
+	rows.forEach((row, rowIndex) => {
+		grid[rowIndex] ??= [];
+		let columnIndex = 0;
+		for (const cell of Array.from(row.cells)) {
+			while (grid[rowIndex]?.[columnIndex]) columnIndex += 1;
+			coordinates.set(cell, {
+				rowIndex,
+				columnIndex
+			});
+			const rowSpan = cell.rowSpan === 0 ? rows.length - rowIndex : Math.max(1, cell.rowSpan);
+			const columnSpan = Math.max(1, cell.colSpan);
+			for (let rowOffset = 0; rowOffset < rowSpan; rowOffset += 1) {
+				const gridRow = grid[rowIndex + rowOffset] ??= [];
+				for (let columnOffset = 0; columnOffset < columnSpan; columnOffset += 1) gridRow[columnIndex + columnOffset] = cell;
+			}
+			columnIndex += columnSpan;
+		}
+	});
+	return {
+		grid,
+		coordinates
+	};
+}
+/**
+* Resolves a logical grid coordinate to its owning DOM cell.
+* A spanning cell can therefore be returned for more than one coordinate; this
+* is intentional and prevents overlay actions from inventing nonexistent cells.
+*
+* @contract Coordinates outside the expanded table grid return null; coordinates
+* covered by a span resolve to the single DOM cell that owns them.
+*/
+function resolveTableCellAt(table, rowIndex, columnIndex) {
+	return mapTableCells(table).grid[rowIndex]?.[columnIndex] ?? null;
+}
+function uniqueSorted(values) {
+	return values.sort((left, right) => left - right).filter((value, index, all) => index === 0 || Math.abs(value - (all[index - 1] ?? value)) >= .5).map((value) => Math.round(value * 100) / 100);
+}
+/**
+* Measures rendered boundaries rather than assuming a uniform table grid.
+* Returned offsets are table-relative and rounded to hundredths of a CSS pixel
+* to suppress observer churn without losing subpixel layout fidelity.
+*
+* @contract Active and hovered rectangles are returned only for cells contained
+* by the supplied table; detached or foreign cells are represented as null.
+*/
+function measureTableOverlayGeometry(table, activeCell, hoveredCell = null) {
+	const tableRect = table.getBoundingClientRect();
+	const rows = Array.from(table.rows);
+	const cells = rows.flatMap((row) => Array.from(row.cells));
+	const { coordinates } = mapTableCells(table);
+	const rowBoundaries = uniqueSorted(rows.flatMap((row) => {
+		const rect = row.getBoundingClientRect();
+		return [rect.top - tableRect.top, rect.bottom - tableRect.top];
+	}));
+	const columnBoundaries = uniqueSorted(cells.flatMap((cell) => {
+		const rect = cell.getBoundingClientRect();
+		return [rect.left - tableRect.left, rect.right - tableRect.left];
+	}));
+	if (!activeCell || !table.contains(activeCell)) return {
+		rowBoundaries,
+		columnBoundaries,
+		activeCell: null,
+		hoveredCell: measureCellRect(table, hoveredCell, coordinates)
+	};
+	return {
+		rowBoundaries,
+		columnBoundaries,
+		activeCell: measureCellRect(table, activeCell, coordinates),
+		hoveredCell: measureCellRect(table, hoveredCell, coordinates)
+	};
+}
+function measureCellRect(table, cell, coordinates) {
+	if (!cell || !table.contains(cell)) return null;
+	const tableRect = table.getBoundingClientRect();
+	const cellRect = cell.getBoundingClientRect();
+	const coordinate = coordinates.get(cell);
+	return {
+		left: Math.round((cellRect.left - tableRect.left) * 100) / 100,
+		top: Math.round((cellRect.top - tableRect.top) * 100) / 100,
+		width: Math.round(cellRect.width * 100) / 100,
+		height: Math.round(cellRect.height * 100) / 100,
+		rowIndex: coordinate?.rowIndex ?? 0,
+		columnIndex: coordinate?.columnIndex ?? 0
+	};
+}
+//#endregion
+export { resolveTableCellAt as n, measureTableOverlayGeometry as t };

package/editor/extensions/callout.d.ts

@@ -0,0 +1,20 @@
+import { Node } from "@tiptap/core";
+/** Canonical tone values that may be persisted in a Looma callout node. */
+export declare const LOOMA_CALLOUT_TONES: readonly ["info", "note", "warning"];
+/** A serialized callout tone; unsupported input is normalized to `note`. */
+export type LoomaCalloutTone = (typeof LOOMA_CALLOUT_TONES)[number];
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        loomaCallout: {
+            /** Wrap the current block in a semantic Looma callout, or retone its existing callout. */
+            setLoomaCallout: (tone?: LoomaCalloutTone) => ReturnType;
+        };
+    }
+}
+/**
+ * A durable, themeable block container for informational editor content.
+ *
+ * @invariant Parsed and rendered `data-tone` values always belong to
+ * `LOOMA_CALLOUT_TONES`; missing or unknown values round-trip as `note`.
+ */
+export declare const LoomaCallout: Node<any, any>;

package/editor/extensions/index.d.ts

@@ -1,444 +1,15 @@
-import { Node, AnyExtension, Extension, Editor, Range } from '@tiptap/core';
-import { d as TableContextMenuActionEventDetail, g as TableOverlayActionEventDetail } from '../table-overlay-DZFGHQDt.js';
-export { a as TABLE_CELL_BACKGROUND_PRESETS } from '../table-overlay-DZFGHQDt.js';
-import { PluginKey } from '@tiptap/pm/state';
-import { LoomaIconName } from '@threadlabs/looma/core';
-
-/** Canonical tone values that may be persisted in a Looma callout node. */
-declare const LOOMA_CALLOUT_TONES: readonly ["info", "note", "warning"];
-/** A serialized callout tone; unsupported input is normalized to `note`. */
-type LoomaCalloutTone = (typeof LOOMA_CALLOUT_TONES)[number];
-declare module "@tiptap/core" {
-    interface Commands<ReturnType> {
-        loomaCallout: {
-            /** Wrap the current block in a semantic Looma callout, or retone its existing callout. */
-            setLoomaCallout: (tone?: LoomaCalloutTone) => ReturnType;
-        };
-    }
-}
 /**
- * A durable, themeable block container for informational editor content.
+ * Tiptap-facing schema, behavior, and command policy.
  *
- * @invariant Parsed and rendered `data-tone` values always belong to
- * `LOOMA_CALLOUT_TONES`; missing or unknown values round-trip as `note`.
+ * Importing this subpath does not register Looma UI elements. Commands accept
+ * framework-neutral intent details from `@threadlabs/looma-editor/ui`, but the
+ * application owns wiring and editor-instance lifetime. Tiptap remains a peer
+ * dependency so Looma and the host execute against the same editor runtime.
  */
-declare const LoomaCallout: Node<any, any>;
-
-/**
- * Default Tiptap extension preset for Looma editor.
- * Uses the Vanilla JS Tiptap API; apps provide @tiptap/core and Looma ships the preset extensions.
- */
-
-/**
- * Deliberate policy knobs in Looma's default extension set.
- * Consumers needing different schemas should compose an explicit Tiptap list
- * rather than relying on undocumented mutation of the returned extensions.
- */
-interface DefaultEditorExtensionsOptions {
-    /** Placeholder shown only for empty paragraphs, not every empty node type. */
-    placeholder?: string;
-    /** Passed to Tiptap Link; defaults false to keep editing clicks in the editor. */
-    linkOpenOnClick?: boolean;
-    /** Passed to Tiptap Image; block images are the default document policy. */
-    imageInline?: boolean;
-    /** Custom mention extension, the Looma default, or false to omit mentions. */
-    mention?: AnyExtension | false;
-}
-/**
- * Complete Looma table schema as one Tiptap extension.
- * Use this in presets that want table, row, header, and cell nodes to remain an
- * atomic policy choice; use `getLoomaTableExtensions` only when ordering or
- * per-extension composition must be explicit.
- *
- * @invariant Installs exactly one compatible table, row, header, and cell node
- * set so a preset cannot accidentally split Looma's persisted table schema.
- */
-declare const LoomaTableKit: AnyExtension;
-/** Returns a fresh ordered list of the same schema extensions as `LoomaTableKit`. */
-declare function getLoomaTableExtensions(): AnyExtension[];
-/**
- * Builds Looma's complete, ordered Tiptap extension policy.
- *
- * A fresh array is returned for each editor. Document nodes precede marks and
- * behavior extensions; Looma's table/list policies are installed once; mention
- * can be replaced without coupling UI chrome to an application directory.
- * Use with `new Editor({ extensions: getDefaultEditorExtensions(), ... })` or a
- * framework's Tiptap editor hook.
- */
-declare function getDefaultEditorExtensions(options?: DefaultEditorExtensionsOptions): AnyExtension[];
-
-/**
- * Interprets document markup copied from source-oriented tools before Tiptap's
- * generic VS Code handler can turn it into a literal code block.
- *
- * Source-editor metadata remains authoritative for non-document languages.
- * Explicit code-block context is never reinterpreted.
- *
- * @contract Recognized document markup is sanitized and dispatched as one paste
- * transaction; every unrecognized or code-oriented payload returns control to
- * Tiptap's remaining paste handlers without changing the document.
- */
-declare const LoomaSmartPaste: Extension<any, any>;
-
-/** Persistable horizontal alignments accepted by Looma table cells. */
-type TableCellAlignment = "left" | "center" | "right";
-/** CSS color stored in document attrs; null removes authored cell background. */
-type TableCellBackground = string | null;
-/**
- * Looma's table behavior policy: resizable columns, stable minimum cell width,
- * and no independently resizable trailing column. The narrow handle is also a
- * Tiptap coordinate probe, so changing it affects selection as well as visuals.
- *
- * @invariant The 3px handle, 112px cell minimum, and fixed trailing edge are a
- * coordinated selection-and-resize policy and must be changed together.
- */
-declare const LoomaTable: AnyExtension;
-/**
- * Header node that round-trips Looma alignment and background attributes.
- *
- * @contract Inherits the base header schema while normalizing authored styles
- * into the same persisted attributes used by body cells.
- */
-declare const LoomaTableHeader: AnyExtension;
-/**
- * Body-cell node with the same persisted formatting contract as headers.
- *
- * @contract Inherits the base cell schema and shares header parsing/rendering so
- * moving content between header and body cells does not change formatting data.
- */
-declare const LoomaTableCell: AnyExtension;
-/**
- * Reads formatting from the nearest cell/header ancestor of the selection.
- * Left is the canonical default and is not serialized as an inline style.
- *
- * @contract Returns `left` outside a table cell and for missing, invalid, or
- * explicitly default alignment attributes.
- */
-declare function getActiveTableCellAlignment(editor: Editor): TableCellAlignment;
-/**
- * Returns the nearest cell/header background, normalized so blank means absent.
- *
- * @contract Returns null outside a table cell and for non-string or whitespace-
- * only attributes, matching the value used to clear persisted background CSS.
- */
-declare function getActiveTableCellBackground(editor: Editor): TableCellBackground;
-/**
- * Updates the active header or body cell and returns false outside a table cell.
- * Setting left stores null, keeping the document free of redundant default CSS.
- *
- * @contract Focuses and updates only the active header or body cell; unsupported
- * selections return false without creating a transaction.
- */
-declare function setActiveTableCellAlignment(editor: Editor, alignment: TableCellAlignment): boolean;
-/**
- * Updates the active header or body cell; blank strings normalize to null so
- * clearing formatting removes persisted inline style instead of storing noise.
- *
- * @contract Focuses and updates only the active header or body cell; unsupported
- * selections return false and blank values remove the persisted attribute.
- */
-declare function setActiveTableCellBackground(editor: Editor, backgroundColor: TableCellBackground): boolean;
-
-/**
- * Table overlay action handler — maps boundaryIndex to Tiptap table commands.
- * Use with the table overlay's `action` event: call this from the adapter's handler.
- */
-
-/**
- * Bounded initial shape for table insertion.
- * Rows and columns are clamped to 1–10 by `insertTableAtRange` so slash-command
- * or custom UI input cannot create an accidentally unbounded transaction.
- */
-interface InsertTableAtRangeOptions {
-    rows?: number;
-    cols?: number;
-    withHeaderRow?: boolean;
-}
-/**
- * Command availability calculated from the current ProseMirror selection.
- * Keeping capabilities beside UI state prevents toolbars from duplicating
- * Tiptap's schema/selection rules or optimistically enabling invalid actions.
- */
-interface TableActionCapabilities {
-    canAddRowBefore: boolean;
-    canAddRowAfter: boolean;
-    canAddColumnBefore: boolean;
-    canAddColumnAfter: boolean;
-    canDeleteRow: boolean;
-    canDeleteColumn: boolean;
-    canDeleteTable: boolean;
-    canMergeCells: boolean;
-    canSplitCell: boolean;
-}
-/**
- * One replaceable snapshot for editor-owned table chrome.
- * Consumers should discard prior capabilities whenever `active` becomes false;
- * they describe the current ProseMirror transaction state, not table schema in
- * general.
- */
-interface ActiveTableUiState {
-    active: boolean;
-    showToolbar: boolean;
-    cellAlignment: TableCellAlignment;
-    cellBackground: TableCellBackground;
-    capabilities: TableActionCapabilities;
-}
-/**
- * Text formatting belongs to actual text selections, not table CellSelections.
- *
- * @contract Returns true only for an editable editor with a non-collapsed
- * `TextSelection`; node and cell selections never activate formatting chrome.
- */
-declare function shouldShowTextFormattingToolbar(editor: Editor, from?: number, to?: number): boolean;
-/**
- * Returns the complete interaction state for the table containing the selection.
- * Inactive defaults are concrete so UI can replace its previous snapshot and
- * cannot accidentally retain enabled controls from a table that lost selection.
- *
- * @contract Capabilities are recalculated from `editor.can()` at call time; an
- * inactive snapshot disables every action and resets authored cell formatting.
- */
-declare function getActiveTableUiState(editor: Editor): ActiveTableUiState;
-/**
- * Executes a toolbar/context-menu action using Looma's table behavior policy.
- * The boolean is Tiptap's command result, so callers can distinguish a handled
- * action from one rejected by the current schema or selection.
- *
- * @contract The event action becomes one focused Tiptap transaction; UI callers
- * never need to reproduce selection repair or cell-format policy.
- * @failure Returns false when the current selection cannot support the action.
- */
-declare function handleTableAction(editor: Editor, detail: TableContextMenuActionEventDetail): boolean;
-/**
- * Deletes a slash-command range (or other inline trigger text) and inserts a table.
- * Use this when apps want a stable default `/table` behavior without owning
- * table policy. Deletion and insertion share one focused command chain, so the
- * trigger text cannot remain behind if insertion succeeds.
- *
- * @contract Rows and columns are clamped to 1–10, then range deletion and table
- * insertion succeed or fail together through a single Tiptap command chain.
- */
-declare function insertTableAtRange(editor: Editor, range: Range, options?: InsertTableAtRangeOptions): boolean;
-/**
- * Reconciles rendered column widths back into table-cell `colwidth` attributes.
- *
- * Browser layout is the source of truth at the end of a pointer resize, but
- * ProseMirror must persist integer widths in the document. The algorithm keeps
- * proportions, enforces a minimum, and distributes rounding error so the final
- * sum still equals the rendered table width. Spanning cells are updated once at
- * their top-left map coordinate rather than once per covered grid position.
- *
- * @invariant Every persisted width is an integer at least `minWidth`, and each
- * spanning cell receives one width per logical column from its top-left origin.
- * @failure Returns false without an active table or measurable columns and does
- * not dispatch when persisted widths already match the rendered geometry.
- */
-declare function normalizeActiveTableColumnWidths(editor: Editor, tableElement: HTMLTableElement, minWidth?: number): boolean;
-/**
- * Handles a geometry-derived table-overlay intent without exposing ProseMirror
- * positions to UI components.
- *
- * Boundary indices address the visual grid edges measured by the overlay. The
- * helper maps them into the current table transaction, rejects indices that do
- * not represent a legal insertion edge, dispatches once, and restores editor
- * focus. `open-cell-menu` returns handled without editing because menu ownership
- * remains with the application/adapter.
- *
- * @contract A valid structural intent dispatches at most one transaction;
- * `open-cell-menu` acknowledges UI ownership without mutating the document.
- * @failure Missing tables, malformed payloads, and out-of-range boundaries
- * return false before dispatching a transaction.
- */
-declare function handleTableOverlayAction(editor: Editor, detail: TableOverlayActionEventDetail): boolean;
-
-/** Default visible candidate budget when an application does not set a limit. */
-declare const DEFAULT_MENTION_RESULT_LIMIT = 8;
-/** Hard candidate ceiling shared by providers, keyboard state, and menu rendering. */
-declare const MAX_MENTION_RESULT_LIMIT = 20;
-/**
- * Application-owned identity and display data for one mention candidate.
- * Looma persists `id` and `label` in the editor document; `detail` and
- * `initials` are presentation hints and are not part of mention identity.
- */
-interface LoomaMentionItem {
-    id: string;
-    label: string;
-    detail?: string;
-    initials?: string;
-}
-/** Bounded result budget passed to a directory provider for the current query. */
-interface LoomaMentionProviderContext {
-    limit: number;
-}
-/**
- * Resolves candidates for the current query.
- *
- * Providers may perform asynchronous directory lookup, but should return no
- * more than `context.limit`. The extension also clamps and filters results so a
- * provider cannot accidentally create an unbounded suggestion surface.
- *
- * @ownership The application owns directory access and returned item data;
- * Looma owns filtering, clamping, and the suggestion state that consumes it.
- */
-type LoomaMentionProvider = (query: string, context: LoomaMentionProviderContext) => readonly LoomaMentionItem[] | Promise<readonly LoomaMentionItem[]>;
-/**
- * Complete render state handed from the headless Tiptap extension to UI chrome.
- *
- * The snapshot owns selection commands only while `active` is true. Consumers
- * should replace, not merge, snapshots: callbacks and rectangles are tied to a
- * particular suggestion range and become stale as soon as the query changes.
- *
- * @lifecycle `highlight` and `select` are valid only while this snapshot remains
- * active; the next query update or exit invalidates both callbacks.
- */
-interface LoomaMentionMenuSnapshot {
-    active: boolean;
-    items: LoomaMentionItem[];
-    selectedIndex: number;
-    query: string;
-    rect: DOMRect | null;
-    loading: boolean;
-    highlight: ((index: number) => void) | null;
-    select: ((index: number) => void) | null;
-}
-/**
- * Mention policy supplied by the application.
- *
- * Looma owns suggestion mechanics and accessibility state; the application
- * owns the directory and may render the snapshot with Looma's menu or custom
- * UI. `menuId` must match that UI's listbox id so `aria-controls` and
- * `aria-activedescendant` reference real elements.
- *
- * @ownership The application owns provider work and rendering callbacks; Looma
- * owns transient selection state and restores every borrowed editor ARIA value.
- */
-interface LoomaMentionOptions {
-    items?: readonly LoomaMentionItem[] | LoomaMentionProvider;
-    limit?: number;
-    menuId?: string;
-    onStateChange?: (state: LoomaMentionMenuSnapshot) => void;
-}
-/** Clamps public/provider limits so keyboard navigation remains predictably bounded. */
-declare function normalizeMentionResultLimit(limit?: number): number;
-/**
- * Applies Looma's local fallback matching to static or provider results.
- * Matching is intentionally limited to display text; stable ids and arbitrary
- * metadata must not become discoverable search fields by accident.
- *
- * @contract Preserves source order, does not mutate the input, and returns no
- * more than the normalized public result limit.
- */
-declare function filterLoomaMentionItems(items: readonly LoomaMentionItem[], query: string, limit?: number): LoomaMentionItem[];
-
-interface MentionPluginState {
-    active?: boolean;
-    query?: string | null;
-    range?: {
-        from: number;
-        to: number;
-    };
-}
-/**
- * Stable key for reading Looma's active mention query and source range.
- * Consumers should treat the keyed value as transient suggestion state rather
- * than document data.
- */
-declare const LoomaMentionSuggestionPluginKey: PluginKey<MentionPluginState>;
-/**
- * Creates a domain-neutral Tiptap mention node and suggestion lifecycle.
- *
- * Applications provide either a small static list or a bounded async directory
- * provider. Looma owns keyboard selection plus the temporary combobox ARIA
- * attributes on the editor. Every attribute is snapshotted and restored so
- * installing this extension cannot erase accessibility state owned by another
- * extension or by the host application.
- *
- * @ownership The application owns the item provider and rendered menu. The
- * extension owns suggestion state and only borrows editor ARIA attributes.
- * @lifecycle Each suggestion update replaces the published snapshot; exit
- * restores borrowed attributes and invalidates callbacks from the prior range.
- * @failure Provider rejection degrades to an empty result set so Tiptap's
- * suggestion lifecycle cannot become an unhandled promise rejection.
- */
-declare function createLoomaMentionExtension(options?: LoomaMentionOptions): AnyExtension;
-
-/** Editor state a slash command may replace and then act upon. */
-interface LoomaSlashCommandContext {
-    editor: Editor;
-    range: Range;
-}
-/**
- * Ephemeral render model published to any slash-menu UI.
- * Replace snapshots rather than merging them: the `select` callback closes over
- * a particular Tiptap range and becomes invalid when the suggestion updates.
- *
- * @lifecycle `select` is valid only until the next snapshot or suggestion exit;
- * retaining it can apply a command to a stale source range.
- */
-interface LoomaSlashMenuSnapshot {
-    active: boolean;
-    items: LoomaSlashCommand[];
-    selectedIndex: number;
-    query: string;
-    rect: DOMRect | null;
-    select: ((index: number) => void) | null;
-}
-/**
- * Application-owned command inventory and integration callbacks.
- * Replacing `commands` changes search and execution together; the extension
- * never merges domain commands into defaults implicitly. Asset selection stays
- * callback-driven because uploads and persistence are outside editor ownership.
- *
- * @ownership The application owns command objects and callback side effects;
- * the extension only searches the inventory and publishes replacement snapshots.
- */
-interface LoomaSlashCommandOptions {
-    commands: LoomaSlashCommand[];
-    onStateChange?: (state: LoomaSlashMenuSnapshot) => void;
-    onOpenImagePicker?: () => void;
-}
-/**
- * Builds Looma's default command policy as fresh objects for one editor.
- * The image command delegates asset selection because Looma does not own upload,
- * persistence, or media-library concerns.
- *
- * @ownership Returned command objects belong to the caller and are recreated
- * per call so one editor cannot mutate another editor's command inventory.
- */
-declare function getDefaultSlashCommands(onOpenImagePicker?: () => void): LoomaSlashCommand[];
-/**
- * One application-extensible command.
- *
- * Commands own their editor mutation, including removal of `context.range`.
- * Keeping that policy in the command lets custom items behave exactly like
- * built-ins without coupling the headless suggestion lifecycle to Tiptap nodes.
- */
-interface LoomaSlashCommand {
-    title: string;
-    description: string;
-    icon: LoomaIconName;
-    keywords: string[];
-    command: (context: LoomaSlashCommandContext) => void;
-}
-/**
- * Framework-neutral slash-command extension used by the turnkey editor.
- * Consumers embedding Looma into their own Tiptap instance can configure the
- * same behavior and render any menu they choose from `onStateChange`.
- *
- * @ownership The extension owns query and keyboard-selection state; the caller
- * owns the command inventory and every menu snapshot after publication.
- * @lifecycle Snapshot callbacks are valid only for the suggestion range that
- * produced them and are replaced on every update or exit.
- */
-declare const LoomaSlashCommand: Extension<LoomaSlashCommandOptions, any>;
-/**
- * Creates an independently configured extension instance.
- * Prefer this factory when callbacks or commands are editor-specific; the
- * exported base extension remains a convenient zero-configuration preset.
- *
- * @ownership The caller owns supplied commands and callbacks. The returned
- * extension captures them for one configuration without mutating the inventory.
- */
-declare function createLoomaSlashCommandExtension(options?: Partial<LoomaSlashCommandOptions>): Extension<LoomaSlashCommandOptions, any>;
-
-export { type ActiveTableUiState, DEFAULT_MENTION_RESULT_LIMIT, type DefaultEditorExtensionsOptions, type InsertTableAtRangeOptions, LOOMA_CALLOUT_TONES, LoomaCallout, type LoomaCalloutTone, type LoomaMentionItem, type LoomaMentionMenuSnapshot, type LoomaMentionOptions, type LoomaMentionProvider, type LoomaMentionProviderContext, LoomaMentionSuggestionPluginKey, LoomaSlashCommand, type LoomaSlashCommandContext, LoomaSlashCommand as LoomaSlashCommandItem, type LoomaSlashCommandOptions, type LoomaSlashMenuSnapshot, LoomaSmartPaste, LoomaTable, LoomaTableCell, LoomaTableHeader, LoomaTableKit, MAX_MENTION_RESULT_LIMIT, type TableActionCapabilities, type TableCellAlignment, type TableCellBackground, createLoomaMentionExtension, createLoomaSlashCommandExtension, filterLoomaMentionItems, getActiveTableCellAlignment, getActiveTableCellBackground, getActiveTableUiState, getDefaultEditorExtensions, getDefaultSlashCommands, getLoomaTableExtensions, handleTableAction, handleTableOverlayAction, insertTableAtRange, normalizeActiveTableColumnWidths, normalizeMentionResultLimit, setActiveTableCellAlignment, setActiveTableCellBackground, shouldShowTextFormattingToolbar };
+export { LoomaCallout, LOOMA_CALLOUT_TONES, type LoomaCalloutTone, } from "./callout.js";
+export { getDefaultEditorExtensions, getLoomaTableExtensions, LoomaTableKit, type DefaultEditorExtensionsOptions, } from "./preset.js";
+export { LoomaSmartPaste } from "./smart-paste.js";
+export { getActiveTableUiState, handleTableAction, handleTableOverlayAction, insertTableAtRange, normalizeActiveTableColumnWidths, shouldShowTextFormattingToolbar, type ActiveTableUiState, type InsertTableAtRangeOptions, type TableActionCapabilities, } from "./table-commands.js";
+export { LoomaTable, getActiveTableCellAlignment, getActiveTableCellBackground, LoomaTableCell, LoomaTableHeader, setActiveTableCellAlignment, setActiveTableCellBackground, TABLE_CELL_BACKGROUND_PRESETS, type TableCellAlignment, type TableCellBackground, } from "./table-formatting.js";
+export { createLoomaMentionExtension, DEFAULT_MENTION_RESULT_LIMIT, filterLoomaMentionItems, LoomaMentionSuggestionPluginKey, MAX_MENTION_RESULT_LIMIT, normalizeMentionResultLimit, type LoomaMentionItem, type LoomaMentionMenuSnapshot, type LoomaMentionOptions, type LoomaMentionProvider, type LoomaMentionProviderContext, } from "./mention.js";
+export { createLoomaSlashCommandExtension, getDefaultSlashCommands, LoomaSlashCommand, type LoomaSlashCommand as LoomaSlashCommandItem, type LoomaSlashCommandContext, type LoomaSlashCommandOptions, type LoomaSlashMenuSnapshot, } from "./slash-command.js";