@threadlabs/looma 0.4.0 → 0.5.1

package/editor/extensions/index.js

@@ -1,64 +1,3 @@
-import {
-  DEFAULT_MENTION_RESULT_LIMIT,
-  LOOMA_CALLOUT_TONES,
-  LoomaCallout,
-  LoomaMentionSuggestionPluginKey,
-  LoomaSlashCommand,
-  LoomaSmartPaste,
-  LoomaTable,
-  LoomaTableCell,
-  LoomaTableHeader,
-  LoomaTableKit,
-  MAX_MENTION_RESULT_LIMIT,
-  createLoomaMentionExtension,
-  createLoomaSlashCommandExtension,
-  filterLoomaMentionItems,
-  getActiveTableCellAlignment,
-  getActiveTableCellBackground,
-  getActiveTableUiState,
-  getDefaultEditorExtensions,
-  getDefaultSlashCommands,
-  getLoomaTableExtensions,
-  handleTableAction,
-  handleTableOverlayAction,
-  insertTableAtRange,
-  normalizeActiveTableColumnWidths,
-  normalizeMentionResultLimit,
-  setActiveTableCellAlignment,
-  setActiveTableCellBackground,
-  shouldShowTextFormattingToolbar
-} from "../chunk-EUIH3TBV.js";
-import {
-  TABLE_CELL_BACKGROUND_PRESETS
-} from "../chunk-JK53ENSG.js";
-export {
-  DEFAULT_MENTION_RESULT_LIMIT,
-  LOOMA_CALLOUT_TONES,
-  LoomaCallout,
-  LoomaMentionSuggestionPluginKey,
-  LoomaSlashCommand,
-  LoomaSmartPaste,
-  LoomaTable,
-  LoomaTableCell,
-  LoomaTableHeader,
-  LoomaTableKit,
-  MAX_MENTION_RESULT_LIMIT,
-  TABLE_CELL_BACKGROUND_PRESETS,
-  createLoomaMentionExtension,
-  createLoomaSlashCommandExtension,
-  filterLoomaMentionItems,
-  getActiveTableCellAlignment,
-  getActiveTableCellBackground,
-  getActiveTableUiState,
-  getDefaultEditorExtensions,
-  getDefaultSlashCommands,
-  getLoomaTableExtensions,
-  handleTableAction,
-  handleTableOverlayAction,
-  insertTableAtRange,
-  normalizeActiveTableColumnWidths,
-  normalizeMentionResultLimit,
-  setActiveTableCellAlignment,
-  setActiveTableCellBackground,
-  shouldShowTextFormattingToolbar
-};
+import { n as TABLE_CELL_BACKGROUND_PRESETS } from "../chunks/table-backgrounds.js";
+import { C as DEFAULT_MENTION_RESULT_LIMIT, D as LOOMA_CALLOUT_TONES, E as normalizeMentionResultLimit, O as LoomaCallout, S as createLoomaMentionExtension, T as filterLoomaMentionItems, _ as getActiveTableCellBackground, a as handleTableAction, b as LoomaSmartPaste, c as normalizeActiveTableColumnWidths, d as getDefaultEditorExtensions, f as getLoomaTableExtensions, g as getActiveTableCellAlignment, h as LoomaTableHeader, i as getActiveTableUiState, l as shouldShowTextFormattingToolbar, m as LoomaTableCell, n as createLoomaSlashCommandExtension, o as handleTableOverlayAction, p as LoomaTable, r as getDefaultSlashCommands, s as insertTableAtRange, t as LoomaSlashCommand, u as LoomaTableKit, v as setActiveTableCellAlignment, w as MAX_MENTION_RESULT_LIMIT, x as LoomaMentionSuggestionPluginKey, y as setActiveTableCellBackground } from "../chunks/extensions.js";
+export { DEFAULT_MENTION_RESULT_LIMIT, LOOMA_CALLOUT_TONES, LoomaCallout, LoomaMentionSuggestionPluginKey, LoomaSlashCommand, LoomaSmartPaste, LoomaTable, LoomaTableCell, LoomaTableHeader, LoomaTableKit, MAX_MENTION_RESULT_LIMIT, TABLE_CELL_BACKGROUND_PRESETS, createLoomaMentionExtension, createLoomaSlashCommandExtension, filterLoomaMentionItems, getActiveTableCellAlignment, getActiveTableCellBackground, getActiveTableUiState, getDefaultEditorExtensions, getDefaultSlashCommands, getLoomaTableExtensions, handleTableAction, handleTableOverlayAction, insertTableAtRange, normalizeActiveTableColumnWidths, normalizeMentionResultLimit, setActiveTableCellAlignment, setActiveTableCellBackground, shouldShowTextFormattingToolbar };

package/editor/extensions/list-behavior.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Looma list behavior extension:
+ * - Enter in list/task items keeps the user in the list
+ * - Backspace at start of an empty list/task item exits the list
+ */
+import { Extension } from "@tiptap/core";
+export declare const LoomaListBehavior: Extension<any, any>;

package/editor/extensions/mention.d.ts

@@ -0,0 +1,35 @@
+import type { AnyExtension } from "@tiptap/core";
+import { PluginKey } from "@tiptap/pm/state";
+import { type LoomaMentionOptions } from "../mention-contract.js";
+export * from "../mention-contract.js";
+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.
+ */
+export 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.
+ */
+export declare function createLoomaMentionExtension(options?: LoomaMentionOptions): AnyExtension;

package/editor/extensions/preset.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Default Tiptap extension preset for Looma editor.
+ * Uses the Vanilla JS Tiptap API; apps provide @tiptap/core and Looma ships the preset extensions.
+ */
+import { type AnyExtension } from "@tiptap/core";
+/**
+ * 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.
+ */
+export 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.
+ */
+export declare const LoomaTableKit: AnyExtension;
+/** Returns a fresh ordered list of the same schema extensions as `LoomaTableKit`. */
+export 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.
+ */
+export declare function getDefaultEditorExtensions(options?: DefaultEditorExtensionsOptions): AnyExtension[];

package/editor/extensions/slash-command.d.ts

@@ -0,0 +1,80 @@
+import { Extension, type Editor, type Range } from "@tiptap/core";
+import type { LoomaIconName } from "../icons.js";
+/** Editor state a slash command may replace and then act upon. */
+export interface LoomaSlashCommandContext {
+    editor: Editor;
+    range: Range;
+}
+/**
+ * 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.
+ */
+export interface LoomaSlashCommand {
+    title: string;
+    description: string;
+    icon: LoomaIconName;
+    keywords: string[];
+    command: (context: LoomaSlashCommandContext) => void;
+}
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export declare function getDefaultSlashCommands(onOpenImagePicker?: () => void): LoomaSlashCommand[];
+/**
+ * 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.
+ */
+export 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.
+ */
+export declare function createLoomaSlashCommandExtension(options?: Partial<LoomaSlashCommandOptions>): Extension<LoomaSlashCommandOptions, any>;

package/editor/extensions/smart-paste.d.ts

@@ -0,0 +1,13 @@
+import { Extension } from "@tiptap/core";
+/**
+ * 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.
+ */
+export declare const LoomaSmartPaste: Extension<any, any>;

package/editor/extensions/table-commands.d.ts

@@ -0,0 +1,114 @@
+/**
+ * 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.
+ */
+import type { Editor, Range } from "@tiptap/core";
+import type { TableContextMenuActionEventDetail } from "../table-context-menu.js";
+import type { TableOverlayActionEventDetail } from "../table-overlay.js";
+import { type TableCellAlignment, type TableCellBackground } from "./table-formatting.js";
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export declare function handleTableOverlayAction(editor: Editor, detail: TableOverlayActionEventDetail): boolean;

package/editor/extensions/table-formatting.d.ts

@@ -0,0 +1,60 @@
+import type { AnyExtension, Editor } from "@tiptap/core";
+export { TABLE_CELL_BACKGROUND_PRESETS } from "../table-backgrounds.js";
+/** Persistable horizontal alignments accepted by Looma table cells. */
+export type TableCellAlignment = "left" | "center" | "right";
+/** CSS color stored in document attrs; null removes authored cell background. */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export declare function setActiveTableCellBackground(editor: Editor, backgroundColor: TableCellBackground): boolean;

package/editor/icons.d.ts

@@ -0,0 +1,55 @@
+import { type IconNode } from 'lucide';
+/** The opinionated Lucide set used by Looma's shipped interaction surfaces. */
+export declare const LOOMA_ICONS: {
+    'align-center': IconNode;
+    'align-left': IconNode;
+    'align-right': IconNode;
+    bold: IconNode;
+    braces: IconNode;
+    'circle-check': IconNode;
+    'circle-x': IconNode;
+    'chevron-down': IconNode;
+    'chevron-left': IconNode;
+    'code-xml': IconNode;
+    columns: IconNode;
+    ellipsis: IconNode;
+    eraser: IconNode;
+    'grip-horizontal': IconNode;
+    'grip-vertical': IconNode;
+    'heading-1': IconNode;
+    'heading-2': IconNode;
+    'heading-3': IconNode;
+    highlighter: IconNode;
+    image: IconNode;
+    info: IconNode;
+    italic: IconNode;
+    list: IconNode;
+    'list-ordered': IconNode;
+    'list-todo': IconNode;
+    merge: IconNode;
+    'notebook-pen': IconNode;
+    minus: IconNode;
+    'paint-bucket': IconNode;
+    'panel-bottom': IconNode;
+    'panel-left': IconNode;
+    'panel-right': IconNode;
+    'panel-top': IconNode;
+    pilcrow: IconNode;
+    plus: IconNode;
+    quote: IconNode;
+    redo: IconNode;
+    rows: IconNode;
+    split: IconNode;
+    strikethrough: IconNode;
+    table: IconNode;
+    trash: IconNode;
+    'triangle-alert': IconNode;
+    underline: IconNode;
+    undo: IconNode;
+};
+/** Stable key selecting an icon from Looma's shipped interaction vocabulary. */
+export type LoomaIconName = keyof typeof LOOMA_ICONS;
+/** Framework-neutral Lucide element tree used to produce Looma icon markup. */
+export type LoomaIconNode = IconNode;
+/** Creates consistent, currentColor-driven SVG markup for framework-neutral components. */
+export declare function loomaIconMarkup(name: LoomaIconName, className?: string): string;

package/editor/index.d.ts

@@ -1,6 +1,8 @@
-export { A as ActiveCellRect, T as TABLE_CELL_BACKGROUND_OPTIONS, a as TABLE_CELL_BACKGROUND_PRESETS, b as TableCellBackgroundAction, c as TableContextMenuAction, d as TableContextMenuActionEventDetail, e as TableInsertionAction, f as TableOverlayAction, g as TableOverlayActionEventDetail, h as TableOverlayGeometry, d as TableToolbarActionEventDetail, m as measureTableOverlayGeometry, r as resolveTableCellAt } from './table-overlay-DZFGHQDt.js';
-export { InsertTableEventDetail, MentionMenuHighlightEventDetail, MentionMenuSelectEventDetail, SlashMenuAnchorRect, SlashMenuHighlightEventDetail, SlashMenuItem, SlashMenuSelectEventDetail } from './ui.js';
-export { ActiveTableUiState, DEFAULT_MENTION_RESULT_LIMIT, DefaultEditorExtensionsOptions, InsertTableAtRangeOptions, LOOMA_CALLOUT_TONES, LoomaCallout, LoomaCalloutTone, LoomaMentionItem, LoomaMentionMenuSnapshot, LoomaMentionOptions, LoomaMentionProvider, LoomaMentionProviderContext, LoomaMentionSuggestionPluginKey, LoomaSlashCommand, LoomaSlashCommandContext, LoomaSlashCommand as LoomaSlashCommandItem, LoomaSlashCommandOptions, LoomaSlashMenuSnapshot, LoomaSmartPaste, LoomaTable, LoomaTableCell, LoomaTableHeader, LoomaTableKit, MAX_MENTION_RESULT_LIMIT, TableActionCapabilities, TableCellAlignment, TableCellBackground, createLoomaMentionExtension, createLoomaSlashCommandExtension, filterLoomaMentionItems, getActiveTableCellAlignment, getActiveTableCellBackground, getActiveTableUiState, getDefaultEditorExtensions, getDefaultSlashCommands, getLoomaTableExtensions, handleTableAction, handleTableOverlayAction, insertTableAtRange, normalizeActiveTableColumnWidths, normalizeMentionResultLimit, setActiveTableCellAlignment, setActiveTableCellBackground, shouldShowTextFormattingToolbar } from './extensions/index.js';
-import '@threadlabs/looma/core';
-import '@tiptap/core';
-import '@tiptap/pm/state';
+/**
+ * The Looma editor: the editor components' contracts and the Tiptap extensions and commands
+ * (also available alone from `./extensions`).
+ */
+export * from "./ui.js";
+export * from "./extensions/index.js";
+export { LOOMA_ICONS, loomaIconMarkup, type LoomaIconName, type LoomaIconNode } from "./icons.js";
+export { getVisualViewportRect, type ViewportRect } from "./viewport.js";