@k2b/ui 0.34.0 → 0.35.0

package/dist/types/actions/Dropdown.d.ts

@@ -102,6 +102,8 @@ export type DropdownProps = {
      * Defaults to `menu`. A controlled menu (`open`) always stays a menu.
      */
     phone?: "menu" | "sheet";
+    /** Content above the phone sheet's menu. `close` dismisses it with normal history and focus restoration. */
+    sheetTop?: (close: () => void) => JSX.Element;
     /**
      * Renders the entries only once the menu first opens, for a menu repeated on every row of a long list: the page
      * then carries each row's trigger, not each row's entries. Fixed for the menu's lifetime.

package/dist/types/content/MatchText.d.ts

@@ -0,0 +1,21 @@
+import { type JSX } from "solid-js";
+/** A half-open `[start, end)` range of Unicode code points. */
+export type MatchRange = readonly [number, number];
+export type MatchTextProps = {
+    text: string;
+    /** Code point ranges to mark, as search engines such as Filegate return them; not UTF-16 offsets. */
+    ranges?: readonly MatchRange[];
+};
+/** Splits text into marked and plain parts. Ranges are clipped to the text, sorted, and merged when they touch. */
+export declare function matchParts(text: string, ranges?: readonly MatchRange[]): {
+    text: string;
+    hit: boolean;
+}[];
+/**
+ * Text with its search matches marked, for result names and paths. It renders inline text and `mark` elements
+ * only, so the host's element keeps truncating and styling the whole text. The marks change only the fill, never
+ * the text's width, and screen readers read the text unchanged.
+ * @example <span class="name"><MatchText text="Rechnung Oktober.pdf" ranges={[[0, 8]]} /></span>
+ */
+export declare function MatchText(props: MatchTextProps): JSX.Element;
+export default MatchText;

package/dist/types/content/index.d.ts

@@ -40,6 +40,7 @@ export { MapAttribution } from "./MapAttribution";
 export { MapView } from "./MapView";
 export { MapViewFrame } from "./MapViewFrame";
 export { default as MarkdownView, type MarkdownRenderOptions, type MarkdownViewProps, renderSafeMarkdown } from "./MarkdownView";
+export { type MatchRange, MatchText, type MatchTextProps, matchParts } from "./MatchText";
 export type { MessageEventGroupProps, MessageEventRowProps, MessageGroupEntry, MessageRowAction, MessageRowAttachment, MessageRowAuthor, MessageRowFile, MessageRowMedia, MessageRowOrigin, MessageRowProgress, MessageRowProps, MessageRowQuote, MessageRowReaction, MessageRowStatus, MessageRowThread, MessageSystemRowProps, } from "./MessageRow";
 export { MessageEventGroup, MessageEventRow, MessageRow, MessageSystemRow, startsMessageGroup } from "./MessageRow";
 export { type MapPaletteColors, type MapTheme, mapPalette } from "./map-palette";

package/dist/types/text-editor/TextEditor.d.ts

@@ -0,0 +1,69 @@
+import type { Extension } from "@codemirror/state";
+import { type JSX } from "solid-js";
+import { type DropdownPosition } from "../actions/Dropdown";
+import { type TextEditorController, type TextEditorMode, type TextEditorOptions } from "./engine";
+import { type InlineFormat } from "./format";
+import { type TableHost } from "./table";
+export type TextEditorProps = {
+    label: string;
+    initialValue?: string;
+    mode?: TextEditorMode;
+    onModeChange?: (mode: TextEditorMode) => void;
+    readOnly?: boolean;
+    loading?: boolean;
+    placeholder?: string;
+    extensions?: Extension;
+    /** Host-owned Markdown presentation; see `createTextEditor`. The host then also styles the editor surface. */
+    presentation?: TextEditorOptions["presentation"];
+    /** `false` when the host renders its own formatting toolbar and mode control; place `controls.TableMenu` in it. */
+    toolbar?: boolean;
+    /** Collaboration supplies history and server-owned structure here. */
+    host?: Pick<TableHost, "structure" | "renderCell" | "onCellSelection" | "tabMovesFocus"> & Partial<Pick<TableHost, "undo" | "redo" | "boundary">>;
+    maxLength: number;
+    maxPasteCells?: number;
+    onChange?: (text: string) => void;
+    onReady?: (editor: TextEditorController, controls: TextEditorControls) => void;
+    /** Return `true` when the host attached the images itself; otherwise the editor shows its attachment hint. */
+    onDroppedImages?: (count: number, files: File[]) => boolean | void;
+    /** Opens the host's attachment picker when clipboard images cannot be inserted. */
+    onAttachImages?: () => void;
+    onTableCheck?: (needsCheck: boolean) => void;
+    /** Host-owned sync status; its place is reserved across transitions. */
+    status?: JSX.Element;
+    class?: string;
+};
+export type TableSizePickerProps = {
+    maxRows: number;
+    maxColumns: number;
+    onPick: (size: {
+        rows: number;
+        columns: number;
+    }) => void;
+    /** Share this picker with slash commands or secondary menus. */
+    onReady?: (open: () => void) => void;
+    disabled?: boolean;
+    class?: string;
+    size?: "xs" | "sm";
+};
+/** Shared table-size control: pointer grid on desktop, large fields in a phone sheet. */
+export declare function TableSizePicker(props: TableSizePickerProps): JSX.Element;
+type TableMenuTrigger = {
+    text?: string;
+    class?: string;
+    size?: "xs" | "sm";
+    position?: DropdownPosition;
+};
+/** Shared table controls for a host-owned toolbar (`toolbar={false}`). */
+export type TextEditorControls = {
+    /** A table cell has focus in the formatted view. */
+    tableActive: () => boolean;
+    /** The shared cell menu behind a host-styled trigger; on phones it opens as a sheet. */
+    TableMenu: (props: TableMenuTrigger) => JSX.Element;
+    /** Formats the focused cell's selection; `false` when no cell has focus. */
+    formatCell: (format: InlineFormat) => boolean;
+    /** Shows a host message, such as a server's reason for a rejected table action, in the editor's notice. */
+    notify: (message: string) => void;
+};
+/** A Markdown text field with app-injected collaboration and a directly editable table view. */
+export declare function TextEditor(props: TextEditorProps): JSX.Element;
+export {};

package/dist/types/text-editor/clipboard-html.d.ts

@@ -0,0 +1,9 @@
+/** Parse only the HTML vocabulary that the Markdown converter consumes.
+ * Resource attributes and active elements never reach a clipboard consumer.
+ * The returned detached body is read as data and never mounted in the editor.
+ */
+export declare const parseClipboardHtml: (html: string) => HTMLElement;
+export declare const convertHtml: (html: string, code: boolean) => {
+    markdown: string;
+    droppedImages: number;
+} | null;

package/dist/types/text-editor/clipboard-loading.d.ts

@@ -0,0 +1,8 @@
+import { type EditorView, ViewPlugin } from "@codemirror/view";
+import type { TableHost } from "./table";
+/** Load the HTML sanitizer only when needed, before either paste consumer runs.
+ * A delayed paste never overwrites edits made while its parser was loading.
+ */
+export declare const clipboardLoading: (getHost: (view: EditorView) => TableHost | null, syncSelection?: (view: EditorView) => void) => ViewPlugin<{
+    destroy(): void;
+}, undefined>;

package/dist/types/text-editor/clipboard.d.ts

@@ -0,0 +1,20 @@
+export declare const htmlClipboardReady: () => boolean;
+export declare const loadHtmlClipboard: () => Promise<void>;
+export declare const parseClipboardHtml: (html: string) => HTMLElement;
+export declare const convertClipboardHtml: (html: string, code: boolean) => {
+    markdown: string;
+    droppedImages: number;
+} | null;
+/** All clipboard entry paths share one preflight, before insertion or conversion. */
+export declare function inspectClipboard(data: DataTransfer, limits: {
+    maxLength: number;
+    maxPasteCells: number;
+}): {
+    error: "textTooLarge" | "pasteTooLarge";
+} | {
+    text: string;
+    html: string;
+    images: number;
+    files: File[];
+    tsv: string[][] | null;
+};

package/dist/types/text-editor/engine.d.ts

@@ -0,0 +1,34 @@
+import { type Extension } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { type TableHost } from "./table";
+export type TextEditorMode = "formatted" | "source" | "plain";
+export type TextEditorOptions = {
+    parent: HTMLElement;
+    /** Initial Markdown. Subsequent collaborative changes arrive through extensions. */
+    doc?: string;
+    mode?: TextEditorMode;
+    readOnly?: boolean;
+    placeholder?: string;
+    label: string;
+    extensions?: Extension;
+    /**
+     * Replaces the built-in Markdown language, highlighting, formatted markers and
+     * formatting keys of the formatted and source modes. The engine keeps the
+     * table grid, clean paste, limits and history routing in every mode.
+     */
+    presentation?: (mode: Exclude<TextEditorMode, "plain">) => Extension;
+    /** The host owns history; collaboration bindings supply theirs. */
+    host: TableHost;
+    onChange?: (text: string) => void;
+    onDroppedImages?: (count: number, files: File[]) => void;
+};
+/** Shared engine; application extensions own transport, awareness and domain features. */
+export declare function createTextEditor(options: TextEditorOptions): {
+    view: EditorView;
+    /** Also re-reads `presentation`, so a host can refresh it, e.g. after a theme change. */
+    setMode: (mode: TextEditorMode) => void;
+    setLabel: (label: string) => void;
+    setReadOnly: (readOnly: boolean) => void;
+    destroy: () => void;
+};
+export type TextEditorController = ReturnType<typeof createTextEditor>;

package/dist/types/text-editor/format.d.ts

@@ -0,0 +1,34 @@
+/** Toolbar and keyboard commands. Each one is a plain Markdown edit of the selection. */
+import { type EditorState, Facet, type TransactionSpec } from "@codemirror/state";
+import type { EditorView } from "@codemirror/view";
+/** Insertion text follows the editor's inherited locale, including keyboard commands. */
+export declare const formatLabels: Facet<{
+    link: string;
+    column: (column: number) => string;
+}, {
+    link: string;
+    column: (column: number) => string;
+}>;
+/** Named Markdown marks or an app's single-line paired delimiter (for example Notebook's `==`). */
+export type InlineFormat = "bold" | "italic" | "code" | "strike" | "link" | {
+    marker: string;
+};
+/** Pure transaction spec, also used when a missing table cell must be materialized atomically. */
+export declare const inlineFormat: (state: EditorState, name: InlineFormat) => TransactionSpec;
+export declare const commands: {
+    bold: (view: EditorView) => boolean;
+    italic: (view: EditorView) => boolean;
+    code: (view: EditorView) => boolean;
+    strike: (view: EditorView) => boolean;
+    heading: (view: EditorView) => boolean;
+    heading1: (view: EditorView) => boolean;
+    heading2: (view: EditorView) => boolean;
+    heading3: (view: EditorView) => boolean;
+    codeBlock: (view: EditorView) => boolean;
+    bulletList: (view: EditorView) => boolean;
+    orderedList: (view: EditorView) => boolean;
+    quote: (view: EditorView) => boolean;
+    link: (view: EditorView) => boolean;
+    table: (view: EditorView) => boolean;
+    rule: (view: EditorView) => boolean;
+};

package/dist/types/text-editor/formatted.d.ts

@@ -0,0 +1 @@
+export declare const formattedView: import("@codemirror/state").Extension[];

package/dist/types/text-editor/language.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Markdown language without `@codemirror/lang-markdown`: that package pulls in
+ * `@codemirror/lang-html` (and with it CSS and JavaScript) for HTML blocks.
+ * The shared editor needs only the GFM tree, so it wraps `@lezer/markdown`.
+ */
+import { Language, LanguageSupport } from "@codemirror/language";
+export declare const markdownLanguage: Language;
+export declare const markdown: () => LanguageSupport;

package/dist/types/text-editor/markdown-table.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Pure GFM table edits in original Markdown coordinates. Markdown is the only
+ * model; callers reparse after applying a transaction. No repair of damaged
+ * tables or prose is attempted. Extra and missing body cells remain inspectable.
+ */
+import type { ChangeDesc } from "@codemirror/state";
+export type Align = "left" | "center" | "right" | null;
+export type Change = {
+    from: number;
+    to: number;
+    insert: string;
+};
+/** Trimmed raw content, with absolute UTF-16 source offsets. */
+export type Cell = {
+    from: number;
+    to: number;
+    text: string;
+};
+export type Line = {
+    from: number;
+    to: number;
+    pipes: number[];
+    leadingPipe: boolean;
+    trailingPipe: boolean;
+    cells: Cell[];
+    /** Original terminator, used when inserting rows. */
+    lineBreak?: string;
+};
+export type Table = {
+    from: number;
+    to: number;
+    /** Header, delimiter, then body rows. */
+    lines: Line[];
+    align: Align[];
+    columns: number;
+};
+/** Only top-level Lezer GFM tables: never code, block quotes, or list items. */
+export declare const findTables: (doc: string) => Table[];
+export declare const tableAt: (doc: string, pos: number) => Table | null;
+/**
+ * Problems that must stay visible before formatted output is sent. A damaged
+ * separator makes GFM fall back to a paragraph: two adjacent pipe-framed rows
+ * there still need review. This only inspects top-level paragraph nodes, never
+ * code, quotations or lists, and does not repair or rewrite any text.
+ */
+export declare const inspectTableStructure: (doc: string) => {
+    extraCells: boolean;
+    missingSeparator: boolean;
+};
+export declare const gridLine: (table: Table, row: number) => Line | undefined;
+export declare const rowCount: (table: Table) => number;
+/** Literal displayed text → safe raw content. Call once, never on existing raw Markdown. */
+export declare const escapeCell: (value: string) => string;
+/** Display text and a raw offset for every displayed UTF-16 boundary. */
+export declare const cellDisplayMap: (raw: string) => {
+    text: string;
+    offsets: number[];
+};
+/** Decode only table pipes and backslashes; leave inline Markdown source editable. */
+export declare const displayCell: (raw: string) => string;
+/**
+ * One minimal contiguous source edit from literal displayed input. Unchanged
+ * escapes keep their exact bytes, including noncanonical lone backslashes.
+ * `from` is the old cell's absolute start; input must NOT be pre-escaped.
+ */
+export declare const cellChanges: (raw: string, nextDisplayed: string, from: number) => Change[];
+/**
+ * Map an edit based on an old cell through intervening document changes.
+ * Deletes only surviving old-source spans (iterGaps), preserving remote inserts
+ * and excluding replaced/deleted identities. Returns current-document offsets.
+ * The caller must first verify that the mapped range is still the same cell;
+ * concurrent structural/escape edits require resyncing its displayed snapshot.
+ */
+export declare const mappedCellChanges: (raw: string, nextDisplayed: string, from: number, changes: ChangeDesc) => Change[];
+/** Spike-compatible escaped RAW input; fills ragged cells within the existing grid width. */
+export declare const setCellText: (table: Table, row: number, col: number, next: string) => Change[];
+export declare const insertRow: (table: Table, after: number) => Change[];
+export declare const deleteRow: (table: Table, row: number) => Change[];
+/** Move a body row, retaining every untouched row's original source and identities. */
+export declare const moveRow: (source: string, table: Table, row: number, to: number) => Change[];
+/** Swap adjacent columns, including their alignment, without rewriting other cells. */
+export declare const moveColumn: (table: Table, column: number, to: number) => Change[];
+/** A hidden header is an empty GFM header; its former values become the first body row. */
+export declare const toggleHeader: (source: string, table: Table) => Change[];
+/** Delete only the selected table; surrounding prose remains byte-for-byte intact. */
+export declare const deleteTable: (table: Table) => Change[];
+/** Insert before `at`, including at the widest row's end; pad ragged rows without dropping cells. */
+export declare const insertColumn: (table: Table, at: number) => Change[];
+/** Complete a ragged grid without changing or removing any existing cell. */
+export declare const completeColumns: (table: Table) => Change[];
+export declare const deleteColumn: (table: Table, col: number) => Change[];
+export declare const setAlign: (table: Table, col: number, align: Align) => Change[];
+/** First grid row is the header; pad short rows, preserve every extra cell. */
+export declare const tableFromGrid: (grid: string[][]) => string;
+/** Quoted TSV (including doubled quotes and embedded newlines). Invalid quotes stay raw. */
+export declare const parseTsv: (text: string) => string[][] | null;
+/** Apply sorted or unsorted, non-overlapping edits in old-document coordinates. */
+export declare const applyChanges: (doc: string, changes: Change[]) => string;
+/**
+ * Settle recognized ragged GFM tables without deleting or rewriting source.
+ * Extra cells become named-grid positions with empty headers, never discarded.
+ * Unrecognizable tables remain raw text for the application's check state;
+ * code, quotes and lists are not repair candidates.
+ */
+export declare const repairTables: (doc: string, maxLength: number) => Change[];

package/dist/types/text-editor/messages.d.ts

@@ -0,0 +1,113 @@
+export declare const textEditorMessages: import("@k2b/stdlib").Catalog<{
+    formatting: string;
+    formatted: string;
+    source: string;
+    view: string;
+    loading: string;
+    bold: string;
+    italic: string;
+    heading: string;
+    heading1: string;
+    heading2: string;
+    heading3: string;
+    strike: string;
+    codeBlock: string;
+    inlineCode: string;
+    column: (column: number) => string;
+    menuRow: (row: number) => string;
+    menuColumn: (name: string) => string;
+    menuAbove: string;
+    menuBelow: string;
+    menuUp: string;
+    menuDown: string;
+    menuInsertLeft: string;
+    menuInsertRight: string;
+    menuMoveLeft: string;
+    menuMoveRight: string;
+    menuDelete: string;
+    menuCopy: string;
+    menuMarkdown: string;
+    columnAlignment: (column: number) => string;
+    discardRecovery: string;
+    bulletList: string;
+    orderedList: string;
+    quote: string;
+    link: string;
+    code: string;
+    table: string;
+    insertTable: string;
+    rows: string;
+    columns: string;
+    insertSize: ({ rows, columns }: {
+        rows: number;
+        columns: number;
+    }) => string;
+    rule: string;
+    rowAbove: string;
+    rowBelow: string;
+    colLeft: string;
+    colRight: string;
+    deleteRow: string;
+    deleteCol: string;
+    moveRowUp: string;
+    moveRowDown: string;
+    moveColLeft: string;
+    moveColRight: string;
+    toggleHeader: string;
+    deleteTable: string;
+    alignment: string;
+    copyTable: string;
+    copyMarkdown: string;
+    copyingTable: string;
+    copiedTable: string;
+    copiedMarkdown: string;
+    copyFailed: string;
+    alignLeft: string;
+    alignCenter: string;
+    alignRight: string;
+    cellLabel: ({ row, column, name }: {
+        row: number;
+        column: number;
+        name?: string;
+    }) => string;
+    structureUnavailable: string;
+    recoveredInput: string;
+    cellRemoved: string;
+    structureFailed: string;
+    pasteTooLarge: string;
+    textTooLarge: string;
+    checkTable: string;
+    checkTableDetail: string;
+    checkSeparatorDetail: string;
+    reviewMarkdown: string;
+    imageHint: string;
+    dismiss: string;
+    tableMenu: string;
+    tableChanged: ({ rows, columns }: {
+        rows: number;
+        columns: number;
+    }) => string;
+    rowMenu: string;
+    columnMenu: string;
+    addRow: string;
+    emptyCell: string;
+    editMarkdown: string;
+    showTable: string;
+    done: string;
+    markdownValid: string;
+    markdownInvalid: string;
+    markdownLine: (line: number) => string;
+    markdownSeparator: ({ header, separator }: {
+        header: number;
+        separator: number;
+    }) => string;
+    markdownExtra: (line: number) => string;
+    applyingTable: string;
+    markdownApplyFailed: string;
+    markdownStructural: string;
+    markdownChanged: string;
+    discardMarkdown: string;
+    continueMarkdown: string;
+    addColumn: string;
+    completeColumns: string;
+}>;

package/dist/types/text-editor/paste.d.ts

@@ -0,0 +1,6 @@
+/** HTML clipboard content as Markdown; `null` when it is better pasted as plain text. */
+export declare const htmlToMarkdown: (html: string) => {
+    markdown: string;
+    droppedImages: number;
+} | null;
+export declare const cleanPaste: (onDroppedImages?: (count: number, files: File[]) => void, plain?: boolean) => import("@codemirror/state").Extension;

package/dist/types/text-editor/table.d.ts

@@ -0,0 +1,81 @@
+import { EditorState, type Extension, Facet } from "@codemirror/state";
+import { EditorView } from "@codemirror/view";
+import { type InlineFormat } from "./format";
+import * as T from "./markdown-table";
+export type TableTarget = {
+    tableFrom: number;
+    rowFrom: number;
+    columnFrom: number;
+    row: number;
+    column: number;
+};
+/** Resolve a server-returned identity against the current document immediately before focus. */
+export type TableFocusTarget = () => TableTarget | null;
+export type TableHost = {
+    undo: () => void;
+    redo: () => void;
+    boundary: () => void;
+    cellLabel: (row: number, column: number, name?: string) => string;
+    sourceLabels?: () => {
+        edit: string;
+        valid: string;
+        invalid: string;
+        changed: string;
+        structural: string;
+        applying?: string;
+        applyFailed?: string;
+        done: string;
+        discard: string;
+        continue: string;
+        line?: (line: number) => string;
+        separator?: (header: number, separator: number) => string;
+        extra?: (line: number) => string;
+        complete?: string;
+    };
+    actionLabel?: (action: "rowMenu" | "columnMenu" | "addRow" | "addColumn" | "emptyCell") => string;
+    /** Respect a host's personal Tab-for-focus preference inside cells too. */
+    tabMovesFocus?: () => boolean;
+    /** Capture durable anchors synchronously, then send the action to the owning server. */
+    structure?: {
+        available: () => boolean;
+        perform: (action: MenuAction, target: TableTarget) => Promise<TableFocusTarget | void>;
+        /** Resolves only after the confirmed update is applied; rejects without discarding the draft. */
+        replaceSource?: (target: TableTarget, expected: string, source: string, caret: {
+            row: number;
+            column: number;
+        }) => Promise<TableFocusTarget | void>;
+    };
+    onError: (code: "structureUnavailable" | "structureFailed" | "pasteTooLarge" | "textTooLarge" | "cellRemoved") => void;
+    onRecovery: (text: string) => void;
+    /** Cell focus is separate from CodeMirror contentDOM focus; collaboration maps these offsets to its own cursor. */
+    onCellSelection?: (selection: {
+        anchor: number;
+        head: number;
+    } | null) => void;
+    onDroppedImages?: (count: number, files: File[]) => void;
+    maxLength: number;
+    maxPasteCells: number;
+    /** App-owned presentation, e.g. formula results. Called only outside the active cell. */
+    renderCell?: (element: HTMLElement, raw: string, table: T.Table, row: number, column: number) => void;
+};
+export type MenuAction = "completeColumns" | "rowAbove" | "rowBelow" | "colLeft" | "colRight" | "deleteRow" | "deleteCol" | "moveRowUp" | "moveRowDown" | "moveColLeft" | "moveColRight" | "toggleHeader" | "deleteTable" | "alignLeft" | "alignCenter" | "alignRight";
+export declare const tableHost: Facet<TableHost, TableHost | null>;
+export declare const tablesIn: (state: EditorState) => T.Table[];
+/** A local source draft for one table. Invalid drafts never replace shared text.
+ * Collaborative structure changes require the host's confirmed anchored action. */
+export declare const editTableSource: (view: EditorView, wrap: HTMLElement) => void;
+export declare const tableActionEnabled: (view: EditorView, wrap: HTMLElement, action: MenuAction) => boolean;
+/** Copy the visible table through the browser clipboard, with spreadsheet and rich-text payloads. */
+export declare const copyTable: (view: EditorView, wrap: HTMLElement, format: "table" | "markdown") => Promise<void>;
+export declare const runMenuAction: (view: EditorView, wrap: HTMLElement, action: MenuAction) => void;
+/** Structural actions also work in source mode, without a mounted table widget. */
+export declare const runTableAction: (view: EditorView, tableFrom: number, r: number, c: number, action: MenuAction, 
+/** `false` when the gesture already moved the caret out of the table: the result must not pull it back. */
+options?: {
+    follow?: boolean;
+}) => void;
+/** Route formatting to the active cell instead of the hidden outer-editor caret. */
+export declare const formatActiveCell: (view: EditorView, name: InlineFormat) => boolean;
+/** First `<table>` of pasted HTML as a grid (Excel, Sheets, Word, web pages). */
+export declare const htmlTableGrid: (html: string) => string[][] | null;
+export declare const tableGrid: () => Extension;

package/dist/types/text-editor.d.ts

@@ -0,0 +1,4 @@
+export { createTextEditor, type TextEditorController, type TextEditorMode, type TextEditorOptions } from "./text-editor/engine";
+export { commands as textEditorCommands, formatLabels as textEditorFormatLabels, type InlineFormat } from "./text-editor/format";
+export { TableSizePicker, type TableSizePickerProps, TextEditor, type TextEditorControls, type TextEditorProps, } from "./text-editor/TextEditor";
+export { editTableSource, type MenuAction, runMenuAction, runTableAction, type TableFocusTarget, type TableHost, type TableTarget, tableGrid, tableHost, } from "./text-editor/table";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@k2b/ui",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Production-ready components for SolidJS applications.",
   "repository": {
     "type": "git",
@@ -37,7 +37,18 @@
       "default": "./dist/ssr/charts.js"
     },
     "./package.json": "./package.json",
-    "./map-glyphs/*": "./map-glyphs/*"
+    "./map-glyphs/*": "./map-glyphs/*",
+    "./text-editor": {
+      "types": "./dist/types/text-editor.d.ts",
+      "browser": "./dist/browser/text-editor.js",
+      "import": "./dist/ssr/text-editor.js",
+      "default": "./dist/ssr/text-editor.js"
+    },
+    "./text-editor/model": {
+      "types": "./dist/types/text-editor/markdown-table.d.ts",
+      "import": "./dist/ssr/text-editor/markdown-table.js",
+      "default": "./dist/ssr/text-editor/markdown-table.js"
+    }
   },
   "files": [
     "dist",
@@ -55,10 +66,16 @@
     "prepack": "bun run build"
   },
   "dependencies": {
+    "@codemirror/commands": "6.10.4",
+    "@codemirror/language": "6.12.4",
+    "@codemirror/state": "6.7.1",
+    "@codemirror/view": "6.43.7",
     "@fontsource/ibm-plex-mono": "5.3.0",
     "@fontsource/ibm-plex-sans": "5.3.0",
     "@k2b/stdlib": "0.30.0",
+    "@lezer/markdown": "1.7.2",
     "@tabler/icons-webfont": "3.48.0",
+    "dompurify": "3.4.17",
     "maplibre-gl": "6.14.0",
     "marked": "18.0.14",
     "qr-scanner": "1.4.2"
@@ -86,7 +103,10 @@
     "typescript": "7.0.2",
     "@typescript/typescript6": "6.0.2",
     "@maplibre/maplibre-gl-style-spec": "26.4.4",
-    "fontnik": "0.7.7"
+    "fontnik": "0.7.7",
+    "yjs": "13.6.33",
+    "y-codemirror.next": "0.3.6",
+    "y-protocols": "1.0.7"
   },
   "publishConfig": {
     "access": "public"