@zuilib/text-editor 0.11.0 → 0.12.0

package/dist/index-A4S7bRwQ.d.ts

@@ -0,0 +1,425 @@
+import { LexicalEditor, TextFormatType, NodeKey, LexicalCommand } from 'lexical';
+import { HeadingTagType } from '@lexical/rich-text';
+import { a as BlockWidth } from './presets-BtNPH0pa.js';
+import { l as TableDensity, k as TableCellPosition } from './table-grid-D70tNhp2.js';
+import { RefObject, KeyboardEvent, FocusEvent } from 'react';
+
+/** Block kinds the toolbar can switch the selected blocks to */
+type BlockType = 'paragraph' | HeadingTagType | 'quote' | 'bullet' | 'number' | 'check';
+type MarkdownEditorApi = Readonly<{
+    /** The underlying Lexical editor, for dispatching your own commands */
+    editor: LexicalEditor;
+    /** Text formats active at the current selection */
+    activeFormats: ReadonlySet<TextFormatType>;
+    toggleFormat: (format: TextFormatType) => void;
+    /** Kind of the block the selection is in; `null` without a range selection */
+    blockType: BlockType | null;
+    /** Turn the selected blocks into the given kind. Repeating the current list kind lifts the list. */
+    setBlockType: (type: BlockType) => void;
+    /** The link the selection is in (`null` outside links) */
+    link: {
+        key: NodeKey;
+        url: string;
+    } | null;
+    /**
+     * Wrap the selection in a link (or change the current link's URL);
+     * `null` removes it. Outside a link a collapsed selection is a no-op:
+     * there is nothing to wrap, and Lexical would otherwise link the whole
+     * text node the caret sits in.
+     */
+    setLink: (url: string | null) => void;
+    /** Whether the selection is a non-empty range (something the link button can wrap) */
+    hasSelection: boolean;
+    /**
+     * Insert a table at the selection. `width` defaults to
+     * `newBlockWidth.table` (Root prop); when given it is written to the
+     * markdown explicitly, even when `full`.
+     */
+    insertTable: (options?: {
+        rows?: number;
+        columns?: number;
+        width?: BlockWidth;
+    }) => void;
+    /**
+     * Insert an empty drawing at the selection. `width` defaults to
+     * `newBlockWidth.drawing` (Root prop); when given it is written to
+     * the markdown explicitly, even when `full`.
+     */
+    insertDrawing: (options?: {
+        width?: BlockWidth;
+    }) => void;
+    /**
+     * Width of the block containing the selection — the focused drawing, or
+     * else the table the caret is in; `null` outside both.
+     */
+    blockWidth: BlockWidth | null;
+    /** Resize that block; no-op when `blockWidth` is `null` */
+    setBlockWidth: (width: BlockWidth) => void;
+    /**
+     * Width of the table containing the selection; `null` outside tables.
+     * @deprecated Use `blockWidth`, which also covers drawings.
+     */
+    tableWidth: BlockWidth | null;
+    /**
+     * Resize the table containing the selection; no-op outside tables.
+     * @deprecated Use `setBlockWidth`, which also covers drawings.
+     */
+    setTableWidth: (width: BlockWidth) => void;
+    /** Density of the table containing the selection; `null` outside tables */
+    tableDensity: TableDensity | null;
+    /** Change the density of the table containing the selection; no-op outside tables */
+    setTableDensity: (density: TableDensity) => void;
+    /** The selection's cell in its table (row, column, counts, header); `null` outside tables */
+    tableCell: TableCellPosition | null;
+    /**
+     * Insert an empty row next to the selection's row (default `below`) and
+     * move the caret into it; no-op outside tables. A row is never inserted
+     * above the header row: `above` there inserts right below it.
+     */
+    insertTableRow: (position?: 'above' | 'below') => void;
+    /**
+     * Remove the selection's row; no-op outside tables and on the last
+     * remaining row. Deleting the header row makes the next row the header.
+     */
+    deleteTableRow: () => void;
+    /**
+     * Insert an empty column next to the selection's column (default
+     * `after`) and move the caret into it; no-op outside tables.
+     */
+    insertTableColumn: (position?: 'before' | 'after') => void;
+    /** Remove the selection's column; no-op outside tables and on the last remaining column. */
+    deleteTableColumn: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    undo: () => void;
+    redo: () => void;
+}>;
+/**
+ * Headless access to the editor. Must be rendered under `MarkdownEditor.Root`
+ * (or `MarkdownEditor`). Use it to wire editor actions into your own buttons.
+ */
+declare function useMarkdownEditor(): MarkdownEditorApi;
+
+type CollapsibleHeadingsLabels = Readonly<{
+    collapse: string;
+    expand: string;
+    collapsed: string;
+    expanded: string;
+}>;
+
+type TableColumnShortcutsLabels = Readonly<{
+    inserted: string;
+    deleted: string;
+}>;
+
+type TableRowShortcutsLabels = Readonly<{
+    inserted: string;
+    deleted: string;
+}>;
+
+/**
+ * Schemes a link may use. Anything else (`javascript:`, `data:`,
+ * `vbscript:`, ...) is rejected by `LinkPlugin`, so a pasted or typed URL
+ * cannot run script when the rendered document is clicked. Scheme-less
+ * values (`example.com/path`, `#anchor`, `/relative`) are allowed.
+ */
+declare const SAFE_LINK_PROTOCOLS: readonly string[];
+/**
+ * Opens the link bubble for the selection. Nothing is written to the
+ * document until the bubble applies a URL: outside a link the selection
+ * must be non-empty (there is nothing to wrap otherwise), inside a link the
+ * bubble edits that link.
+ */
+declare const EDIT_LINK_COMMAND: LexicalCommand<undefined>;
+declare function isSafeUrl(url: string): boolean;
+
+type ToolbarOrientation = 'horizontal' | 'vertical';
+/**
+ * Items take part in the roving tabindex by opting in with this attribute
+ * (`ToolbarButton` and the built-in controls set it). Anything else inside
+ * the toolbar, a popover's own buttons or a host's nested widget, keeps its
+ * own focus handling.
+ */
+declare const TOOLBAR_ITEM_ATTRIBUTE = "data-toolbar-item";
+/**
+ * APG toolbar keyboard pattern: one Tab stop, arrow keys move between the
+ * items, Home / End jump to the ends. Spread the result onto the
+ * `role="toolbar"` element.
+ */
+declare function useToolbarKeyboard<T extends HTMLElement = HTMLDivElement>(orientation?: ToolbarOrientation): {
+    ref: RefObject<T>;
+    onKeyDown: (event: KeyboardEvent<T>) => void;
+    onFocus: (event: FocusEvent<T>) => void;
+    'aria-orientation': ToolbarOrientation;
+};
+
+/**
+ * Semantic token vocabulary for code highlighting. Closed on purpose: every
+ * grammar maps its syntax onto these names, and the theme maps each name onto
+ * one class (`zui-token-<type>`) and one color custom property
+ * (`--zui-code-<type>`). Adding a language never adds a color.
+ */
+declare const CODE_TOKEN_TYPES: readonly ["comment", "string", "number", "keyword", "builtin", "type", "function", "property", "variable", "constant", "operator", "punctuation", "tag", "attr", "regex", "meta", "inserted", "deleted"];
+type CodeTokenType = (typeof CODE_TOKEN_TYPES)[number];
+/** A run of source text. `text` is uncolored (identifiers, whitespace, …). */
+type CodeToken = Readonly<{
+    type: CodeTokenType | 'text';
+    text: string;
+}>;
+/**
+ * One lexer rule: a regular-expression *source* (no flags, no capturing
+ * groups — use `(?:…)`, no backreferences) tried at the current position.
+ * Rules are tried in order; the first one that matches wins.
+ */
+type CodeRule = Readonly<{
+    type: CodeTokenType;
+    match: string;
+}>;
+/**
+ * A language definition. Pure data: the lexer compiles it once (cached per
+ * object identity) and walks the source with it.
+ *
+ * Identifiers not consumed by a rule are classified by the word lists, then
+ * by the two heuristics, and otherwise left as plain text.
+ */
+type CodeGrammar = Readonly<{
+    /** Canonical name, as written after ``` in markdown */
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    /** Regex source for identifiers (default: `[A-Za-z_$][\w$]*`) */
+    identifier?: string;
+    /** Word lists and rules match case-insensitively (SQL) */
+    caseInsensitive?: boolean;
+    /** An identifier directly followed by `(` is a `function` */
+    callIsFunction?: boolean;
+    /**
+     * A Capitalized identifier is a `type`; a SCREAMING_CASE one is a
+     * `constant`
+     */
+    capitalizedIsType?: boolean;
+}>;
+
+/**
+ * Splits `code` into a flat list of tokens covering the whole input, in
+ * order; adjacent tokens of the same type are merged. Never throws on user
+ * input and always makes progress (an empty match counts as no match).
+ */
+declare function tokenizeCode(code: string, grammar: CodeGrammar): CodeToken[];
+
+/**
+ * Language registry: canonical names and aliases, lower-cased, mapped to a
+ * grammar. Unknown names resolve to `plain` (line structure, no colors) so
+ * every fenced block gets the same editing behavior. The built-in grammars
+ * are registered on first use, not at import, so the module has no side
+ * effects and bundlers can drop it when unused.
+ */
+declare const PLAIN_LANGUAGE = "plain";
+/** Adds (or replaces) a language. Call before the editor mounts. */
+declare function registerCodeLanguage(grammar: CodeGrammar): void;
+declare function hasCodeLanguage(name: string): boolean;
+/** Resolves a fence name (canonical, alias, or `diff-<lang>`) to a grammar. */
+declare function resolveCodeLanguage(name: string | null | undefined): CodeGrammar;
+/** Canonical names of every registered language, sorted */
+declare function getCodeLanguages(): string[];
+
+/** The built-in grammars. The registry loads them on first lookup. */
+declare const BUILTIN_CODE_LANGUAGES: readonly [Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>, Readonly<{
+    name: string;
+    aliases?: readonly string[];
+    rules: readonly CodeRule[];
+    keywords?: readonly string[];
+    builtins?: readonly string[];
+    types?: readonly string[];
+    constants?: readonly string[];
+    identifier?: string;
+    caseInsensitive?: boolean;
+    callIsFunction?: boolean;
+    capitalizedIsType?: boolean;
+}>];
+
+export { BUILTIN_CODE_LANGUAGES as B, CODE_TOKEN_TYPES as C, EDIT_LINK_COMMAND as E, type MarkdownEditorApi as M, PLAIN_LANGUAGE as P, SAFE_LINK_PROTOCOLS as S, TOOLBAR_ITEM_ATTRIBUTE as T, type BlockType as a, type CodeGrammar as b, type CodeRule as c, type CodeToken as d, type CodeTokenType as e, type CollapsibleHeadingsLabels as f, type TableColumnShortcutsLabels as g, type TableRowShortcutsLabels as h, getCodeLanguages as i, hasCodeLanguage as j, isSafeUrl as k, resolveCodeLanguage as l, useToolbarKeyboard as m, registerCodeLanguage as r, tokenizeCode as t, useMarkdownEditor as u };