@zuilib/text-editor 0.11.0 → 0.12.0

package/dist/lexical.d.ts

@@ -0,0 +1,117 @@
+export { $ as $deleteTableColumnAt, z as $deleteTableColumnNear, A as $deleteTableRowAt, G as $deleteTableRowNear, J as $getSelectedTable, K as $getSelectedTableCell, L as $getTableCellPosition, N as $getTableDensity, P as $getTableSettings, Q as $getTableWidth, R as $insertTableColumnAt, S as $insertTableColumnNear, U as $insertTableRowAt, V as $insertTableRowNear, W as $isTableWidthExplicit, X as $setTableDensity, Y as $setTableSettings, Z as $setTableWidth, _ as createMarkdownEditor } from './table-grid-D70tNhp2.js';
+export { E as EditorPreset, M as MARKDOWN_NODES, b as MARKDOWN_PRESET, c as MARKDOWN_TRANSFORMERS, T as TransformersInput, r as resolveTransformers, s as shortcutTransformers } from './presets-BtNPH0pa.js';
+export { $ as $createDrawingNode, a as $isDrawingNode, D as DIAGRAM, b as DRAWING, c as DRAWING_PRESET, d as DRAWING_PRESET_NODES, e as DRAWING_PRESET_TRANSFORMERS, f as DrawingNode, S as SerializedDrawingNode } from './drawing-preset-Ag7a7F9h.js';
+import { Transformer, MultilineElementTransformer, ElementTransformer } from '@lexical/markdown';
+import { LexicalEditor, EditorThemeClasses, ElementNode, NodeKey, EditorConfig, SerializedElementNode, LexicalNode } from 'lexical';
+import { registerCodeHighlighting } from '@lexical/code';
+export { $ as $createMentionNode, a as $isMentionNode, M as MENTION, b as MentionNode, S as SerializedMentionNode } from './mention-node-eSsjUpaE.js';
+export { $ as $createImageNode, a as $getSelectedImage, b as $isImageNode, c as IMAGE, d as ImageNode, S as SerializedImageNode } from './image-node-kR1Zf5kz.js';
+export { $ as $getCommentIds, a as $getMarkNodes, b as $plainTextOffset, c as $removeComment, C as COMMENT } from './comment-markers-BrrrAdSL.js';
+import 'react';
+import '@lexical/table';
+import './drawing-data-EWzEQ1_i.js';
+import '@lexical/mark';
+
+type LexicalTokenizer = NonNullable<Parameters<typeof registerCodeHighlighting>[1]>;
+/**
+ * The tokenizer handed to `@lexical/code`. It never touches Prism: the
+ * registry's grammars produce the tokens, and `$tokenize` turns them into the
+ * flat CodeHighlightNode / LineBreakNode / TabNode structure CodeNode expects.
+ */
+declare const codeTokenizer: LexicalTokenizer;
+/**
+ * Registers syntax highlighting for every CodeNode in the editor, driven by
+ * the language registry. Unknown languages render as plain text with the
+ * same line structure, so editing behaves identically.
+ */
+declare function registerCodeBlockHighlighting(editor: LexicalEditor): () => void;
+
+/** Tag on every import update: the sync listener must not echo it back as a change */
+declare const EXTERNAL_UPDATE_TAG = "initial-load";
+/**
+ * Replaces the whole document with `markdown` inside one update (one undo
+ * step). The caret is put back at the same path/offset when the new
+ * document still has that position.
+ */
+declare function $replaceMarkdown(markdown: string, transformers: Transformer[]): void;
+declare function replaceMarkdown(editor: LexicalEditor, markdown: string, transformers: Transformer[]): void;
+
+declare const editorNodeClassNames: EditorThemeClasses;
+/**
+ * `overrides` on top of `base`, one level deep: a nested group (`heading`,
+ * `list`, `text`, ...) is merged key by key, a string replaces the string.
+ */
+declare function mergeNodeClassNames(base: EditorThemeClasses, overrides: EditorThemeClasses): EditorThemeClasses;
+
+type SerializedFrontmatterNode = SerializedElementNode;
+/**
+ * A block node holding a document's YAML frontmatter — the metadata section
+ * delimited by `---` lines at the very top of a markdown file (as used by
+ * Claude skills, static-site generators, etc.).
+ *
+ * Content is stored as plain TextNode children separated by LineBreakNodes, so
+ * `getTextContent()` yields the raw YAML with `\n` line separators — exactly
+ * what the FRONTMATTER transformer re-serializes on export.
+ */
+declare class FrontmatterNode extends ElementNode {
+    static getType(): string;
+    static clone(node: FrontmatterNode): FrontmatterNode;
+    constructor(key?: NodeKey);
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): boolean;
+    static importJSON(_serializedNode: SerializedFrontmatterNode): FrontmatterNode;
+    exportJSON(): SerializedFrontmatterNode;
+    isInline(): false;
+    canBeEmpty(): boolean;
+    canIndent(): false;
+}
+declare function $createFrontmatterNode(): FrontmatterNode;
+declare function $isFrontmatterNode(node: LexicalNode | null | undefined): node is FrontmatterNode;
+/**
+ * Markdown transformer for a leading YAML frontmatter block:
+ *
+ * ```
+ * ---
+ * name: my-skill
+ * description: ...
+ * ---
+ * ```
+ *
+ * Import only claims the block when it's the very first thing in the document
+ * (frontmatter is defined as leading metadata); a `---` fence appearing later
+ * falls through to normal handling. Must be ordered before other multiline
+ * transformers so its `export` runs first for a FrontmatterNode.
+ */
+declare const FRONTMATTER: MultilineElementTransformer;
+
+/**
+ * Markdown transformer for GFM tables. Adapted from the Lexical playground.
+ * Rows are matched line-by-line on import and stitched into a single
+ * TableNode; the divider row promotes the row above it to a header row.
+ * A `<!-- width: text; density: compact -->` settings line directly
+ * above the table (see tableSettings.ts) is consumed on import and
+ * re-emitted on export.
+ */
+declare const TABLE: ElementTransformer;
+
+/**
+ * List import/export companion to `@lexical/markdown`'s list transformers.
+ * On import it is a pre-pass: when a list line is reached it normalises the
+ * whole run of list lines that follows (never a fenced code block, which
+ * is consumed before its lines are seen) and then declines the match so
+ * the regular list transformers create the nodes. On export it claims
+ * every list first (multiline transformers export before element ones)
+ * and writes 2-space nesting.
+ */
+declare const LISTS: MultilineElementTransformer;
+
+/**
+ * `@lexical/markdown`'s CODE transformer, except that a block whose language
+ * is the highlighter's default (`plain`, assigned to every untagged block)
+ * exports as a bare ``` fence — markdown in, markdown out — and a fence
+ * info string beyond the language (```js title=a.js) is preserved instead
+ * of leaking into the code body.
+ */
+declare const CODE_BLOCK: MultilineElementTransformer;
+
+export { $createFrontmatterNode, $isFrontmatterNode, $replaceMarkdown, CODE_BLOCK, EXTERNAL_UPDATE_TAG, FRONTMATTER, FrontmatterNode, LISTS, type SerializedFrontmatterNode, TABLE, codeTokenizer, editorNodeClassNames, mergeNodeClassNames, registerCodeBlockHighlighting, replaceMarkdown };

package/dist/lexical.js

@@ -0,0 +1,2 @@
+'use client';
+"use client";import{b as e,c as o,e as t,f as r,g as a,h as b,i as D,k as h}from"./chunk-R5PL4Q7X.js";import{A as v,B as H,C as U,u as k,v as z,w as K,x as L,y as B}from"./chunk-3TZVOXWX.js";import{h as c,i as I,j as C,k as O,l as w,m as _,n as W,o as u,p as y,q as F,r as G,s as P}from"./chunk-N5JWZ2VW.js";import{a as X,b as j,c as q,d as J}from"./chunk-5VRVC56Y.js";import{c as Q,d as V,e as Y,f as Z,g as ee}from"./chunk-A7MCBSAZ.js";import{c as oe,d as te,e as re,f as ae,g as ne}from"./chunk-7Z3CW6Q3.js";import{a as p,b as $,e as f,f as g,g as R,h as E,k as x,l as A,m as S,n as M}from"./chunk-AGTPMKLK.js";import{g as n,h as d,i,j as m,k as l,l as s,m as N,n as T}from"./chunk-LDVPFZCN.js";import"./chunk-XRJNLGI4.js";import"./chunk-YFFSTMIR.js";export{z as $createDrawingNode,I as $createFrontmatterNode,te as $createImageNode,j as $createMentionNode,A as $deleteTableColumnAt,M as $deleteTableColumnNear,g as $deleteTableRowAt,E as $deleteTableRowNear,Y as $getCommentIds,V as $getMarkNodes,ae as $getSelectedImage,T as $getSelectedTable,p as $getSelectedTableCell,$ as $getTableCellPosition,s as $getTableDensity,n as $getTableSettings,m as $getTableWidth,x as $insertTableColumnAt,S as $insertTableColumnNear,f as $insertTableRowAt,R as $insertTableRowNear,K as $isDrawingNode,C as $isFrontmatterNode,re as $isImageNode,q as $isMentionNode,i as $isTableWidthExplicit,ee as $plainTextOffset,Z as $removeComment,r as $replaceMarkdown,N as $setTableDensity,d as $setTableSettings,l as $setTableWidth,W as CODE_BLOCK,Q as COMMENT,B as DIAGRAM,L as DRAWING,U as DRAWING_PRESET,v as DRAWING_PRESET_NODES,H as DRAWING_PRESET_TRANSFORMERS,k as DrawingNode,t as EXTERNAL_UPDATE_TAG,O as FRONTMATTER,c as FrontmatterNode,ne as IMAGE,oe as ImageNode,_ as LISTS,u as MARKDOWN_NODES,F as MARKDOWN_PRESET,y as MARKDOWN_TRANSFORMERS,J as MENTION,X as MentionNode,w as TABLE,e as codeTokenizer,h as createMarkdownEditor,b as editorNodeClassNames,D as mergeNodeClassNames,o as registerCodeBlockHighlighting,a as replaceMarkdown,G as resolveTransformers,P as shortcutTransformers};

package/dist/markdown.d.ts

@@ -0,0 +1,29 @@
+import { M as MarkdownEditorProps, E as EditorRootProps, a as EditorContent, T as ToolbarButton, b as ToolbarDivider, F as FormatButtons, B as BlockButtons, I as InsertButtons, H as HistoryButtons, O as OutlinePlugin, C as CharacterCount } from './table-grid-D70tNhp2.js';
+export { D as DEFAULT_LABELS, c as DEFAULT_TABLE_SETTINGS, d as DeepPartial, e as EditorContentProps, f as EditorFieldProps, g as EditorLabels, h as EditorLabelsInput, i as EditorMode, j as TABLE_WIDTH_MARKER, k as TableCellPosition, l as TableDensity, m as TableSettings, n as TableSettingsOptions, o as Toolbar, p as ToolbarItems, q as canDeleteColumn, r as canDeleteRow, s as formatTableSettingsMarker, t as insertableColumnIndices, u as insertableRowIndices, v as parseTableSettingsMarker, w as resolveLabels, x as useEditorContext, y as useLabels } from './table-grid-D70tNhp2.js';
+export { B as BUILTIN_CODE_LANGUAGES, a as BlockType, C as CODE_TOKEN_TYPES, b as CodeGrammar, c as CodeRule, d as CodeToken, e as CodeTokenType, f as CollapsibleHeadingsLabels, E as EDIT_LINK_COMMAND, M as MarkdownEditorApi, P as PLAIN_LANGUAGE, S as SAFE_LINK_PROTOCOLS, T as TOOLBAR_ITEM_ATTRIBUTE, g as TableColumnShortcutsLabels, h as TableRowShortcutsLabels, i as getCodeLanguages, j as hasCodeLanguage, k as isSafeUrl, r as registerCodeLanguage, l as resolveCodeLanguage, t as tokenizeCode, u as useMarkdownEditor, m as useToolbarKeyboard } from './index-A4S7bRwQ.js';
+export { B as BLOCK_WIDTHS, a as BlockWidth, N as NewBlockWidths, i as isBlockWidth } from './presets-BtNPH0pa.js';
+import * as react from 'react';
+import 'lexical';
+import '@lexical/table';
+import '@lexical/rich-text';
+import '@lexical/markdown';
+
+declare const MarkdownEditor: {
+    ({ placeholder, toolbar, outline, collapsible, showCharacterCount, children, ...rootProps }: MarkdownEditorProps): react.ReactElement;
+    Root: (props: Omit<EditorRootProps, "preset">) => react.ReactElement;
+    Content: typeof EditorContent;
+    Toolbar: ({ children, className, }: Readonly<{
+        children?: react.ReactNode;
+        className?: string;
+    }>) => react.ReactElement | null;
+    ToolbarButton: typeof ToolbarButton;
+    ToolbarDivider: typeof ToolbarDivider;
+    FormatButtons: typeof FormatButtons;
+    BlockButtons: typeof BlockButtons;
+    InsertButtons: typeof InsertButtons;
+    HistoryButtons: typeof HistoryButtons;
+    Outline: typeof OutlinePlugin;
+    CharacterCount: typeof CharacterCount;
+};
+
+export { BlockButtons, CharacterCount, EditorRootProps, FormatButtons, HistoryButtons, InsertButtons, MarkdownEditor, MarkdownEditorProps, ToolbarButton, ToolbarDivider };

package/dist/markdown.js

@@ -0,0 +1,2 @@
+'use client';
+"use client";import"./chunk-TGVEPLDM.js";import{a as t,d as E,j as q,k as r}from"./chunk-R5PL4Q7X.js";import{a as e,b as i,d as m,e as p,f as d,g as n,q as o,v,w as y}from"./chunk-N5JWZ2VW.js";import{c as A,d as D,i as K,j as N,o as O,p as T,q as W,r as _,s as b,t as g,u as h,v as j}from"./chunk-AGTPMKLK.js";import{b as M,c as k,d as s,e as w,f as x,o as R,p as l,q as u,t as P,u as S}from"./chunk-LDVPFZCN.js";import{a,b as c,c as f}from"./chunk-YFFSTMIR.js";var F=r(o);export{v as BLOCK_WIDTHS,e as BUILTIN_CODE_LANGUAGES,g as BlockButtons,E as CODE_TOKEN_TYPES,q as CharacterCount,k as DEFAULT_LABELS,x as DEFAULT_TABLE_SETTINGS,c as EDIT_LINK_COMMAND,b as FormatButtons,j as HistoryButtons,h as InsertButtons,F as MarkdownEditor,i as PLAIN_LANGUAGE,a as SAFE_LINK_PROTOCOLS,R as TABLE_WIDTH_MARKER,P as TOOLBAR_ITEM_ATTRIBUTE,T as Toolbar,_ as ToolbarButton,W as ToolbarDivider,N as canDeleteColumn,D as canDeleteRow,u as formatTableSettingsMarker,n as getCodeLanguages,p as hasCodeLanguage,K as insertableColumnIndices,A as insertableRowIndices,y as isBlockWidth,f as isSafeUrl,l as parseTableSettingsMarker,m as registerCodeLanguage,d as resolveCodeLanguage,s as resolveLabels,t as tokenizeCode,M as useEditorContext,w as useLabels,O as useMarkdownEditor,S as useToolbarKeyboard};

package/dist/mention-node-eSsjUpaE.d.ts

@@ -0,0 +1,44 @@
+import { TextNode, NodeKey, Spread, SerializedTextNode, EditorConfig, DOMExportOutput, DOMConversionMap, LexicalNode } from 'lexical';
+import { TextMatchTransformer } from '@lexical/markdown';
+
+type SerializedMentionNode = Spread<{
+    mentionId: string;
+    mentionName: string;
+    trigger: string;
+}, SerializedTextNode>;
+/**
+ * An inline reference to a person, page or tag: `@name` in the document,
+ * `[@name](mention:id)` in markdown. A token text node: the caret cannot
+ * enter it, Backspace removes it whole and its text is the trigger plus the
+ * name (so plain-text export reads naturally).
+ */
+declare class MentionNode extends TextNode {
+    __id: string;
+    __name: string;
+    __trigger: string;
+    static getType(): string;
+    static clone(node: MentionNode): MentionNode;
+    constructor(id: string, name: string, trigger?: string, key?: NodeKey);
+    static importJSON(json: SerializedMentionNode): MentionNode;
+    exportJSON(): SerializedMentionNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    getMentionId(): string;
+    getMentionName(): string;
+    getTrigger(): string;
+    canInsertTextBefore(): boolean;
+    canInsertTextAfter(): boolean;
+    isTextEntity(): true;
+}
+declare function $createMentionNode(id: string, name: string, trigger?: string): MentionNode;
+declare function $isMentionNode(node: LexicalNode | null | undefined): node is MentionNode;
+/**
+ * Markdown transformer for mentions. Export writes `[<trigger><name>](mention:<id>)`,
+ * a link other renderers show as plain text with a `mention:` href; import
+ * (and typing the closing `)`) turns it back into a `MentionNode`. Put it
+ * before the built-ins so it claims the syntax ahead of `LINK`.
+ */
+declare const MENTION: TextMatchTransformer;
+
+export { $createMentionNode as $, MENTION as M, type SerializedMentionNode as S, $isMentionNode as a, MentionNode as b };

package/dist/mentions-plugin-gio3_XKd.d.ts

@@ -0,0 +1,74 @@
+import { ReactNode, ReactElement } from 'react';
+import { LexicalCommand } from 'lexical';
+
+type MentionItem = Readonly<{
+    id: string;
+    name: string;
+    /** Secondary text shown after the name (a handle, a team, a path) */
+    hint?: string;
+}>;
+type MentionRenderState = Readonly<{
+    active: boolean;
+    query: string;
+    trigger: string;
+}>;
+type MentionTrigger = Readonly<{
+    /** One character that opens the menu, typed at the start of a word (`'@'`, `'#'`) */
+    trigger: string;
+    /** Items for the text typed after the trigger; called again on every keystroke */
+    search: (query: string) => Promise<readonly MentionItem[]>;
+    /** Custom option body; the option element, its role and selection state are the plugin's */
+    render?: (item: MentionItem, state: MentionRenderState) => ReactNode;
+}>;
+type MentionsLabels = Readonly<{
+    /** `aria-label` of the listbox */
+    suggestions: (trigger: string) => string;
+    noResults: string;
+    loading: string;
+}>;
+declare const DEFAULT_MENTIONS_LABELS: MentionsLabels;
+type InsertMentionPayload = Readonly<{
+    id: string;
+    name: string;
+    trigger?: string;
+}>;
+/** Inserts a mention at the selection (replacing any selected text) */
+declare const INSERT_MENTION_COMMAND: LexicalCommand<InsertMentionPayload>;
+type MentionsPluginProps = Readonly<{
+    /** The single trigger's character (default `'@'`); ignored when `triggers` is given */
+    trigger?: string;
+    /** The single trigger's search */
+    search?: MentionTrigger['search'];
+    /** The single trigger's option renderer */
+    render?: MentionTrigger['render'];
+    /** Several triggers, each with its own search (`@` people, `#` tags) */
+    triggers?: readonly MentionTrigger[];
+    /** At most this many options are listed (default 8) */
+    maxItems?: number;
+    labels?: Partial<MentionsLabels>;
+    /** Called after a mention was inserted */
+    onSelect?: (item: MentionItem, trigger: string) => void;
+}>;
+type MentionMatch = Readonly<{
+    trigger: string;
+    query: string;
+    /** Offset of the trigger character in the text node */
+    from: number;
+}>;
+/**
+ * The trigger + query ending at `offset` in `text`, or `null`. The trigger
+ * must start a word (start of text, or after whitespace or an opening
+ * bracket) and the query has no whitespace.
+ */
+declare function findMentionMatch(text: string, offset: number, triggers: readonly string[]): MentionMatch | null;
+/**
+ * Typeahead mentions. Typing a trigger character opens a listbox of the
+ * `search` results under the caret; arrows move, Enter or Tab inserts the
+ * highlighted item as a `MentionNode` followed by a space, Escape closes.
+ * The surface gets `aria-activedescendant` and `aria-controls` while the
+ * list is open. Requires `MentionNode` in `nodes` and `MENTION` in
+ * `transformers`.
+ */
+declare function MentionsPlugin({ trigger, search, render, triggers, maxItems, labels: labelsProp, onSelect, }: MentionsPluginProps): ReactElement | null;
+
+export { DEFAULT_MENTIONS_LABELS as D, INSERT_MENTION_COMMAND as I, type MentionItem as M, type InsertMentionPayload as a, type MentionMatch as b, type MentionRenderState as c, type MentionTrigger as d, type MentionsLabels as e, MentionsPlugin as f, type MentionsPluginProps as g, findMentionMatch as h };

package/dist/mentions.d.ts

@@ -0,0 +1,5 @@
+export { $ as $createMentionNode, a as $isMentionNode, M as MENTION, b as MentionNode, S as SerializedMentionNode } from './mention-node-eSsjUpaE.js';
+export { D as DEFAULT_MENTIONS_LABELS, I as INSERT_MENTION_COMMAND, a as InsertMentionPayload, M as MentionItem, b as MentionMatch, c as MentionRenderState, d as MentionTrigger, e as MentionsLabels, f as MentionsPlugin, g as MentionsPluginProps, h as findMentionMatch } from './mentions-plugin-gio3_XKd.js';
+import 'lexical';
+import '@lexical/markdown';
+import 'react';

package/dist/mentions.js

@@ -0,0 +1,2 @@
+'use client';
+"use client";import{a as i,b as M,c as r,d as s}from"./chunk-XP3MZRCW.js";import{a as e,b as n,c as o,d as t}from"./chunk-5VRVC56Y.js";import"./chunk-SDICQI2B.js";import"./chunk-XRJNLGI4.js";export{n as $createMentionNode,o as $isMentionNode,i as DEFAULT_MENTIONS_LABELS,M as INSERT_MENTION_COMMAND,t as MENTION,e as MentionNode,s as MentionsPlugin,r as findMentionMatch};