quoin-editor 0.4.2 → 1.0.0

package/dist/types-Cz7XJLaK.d.cts

@@ -0,0 +1,366 @@
+import { E as EngineDoc, P as Pos, B as BlockAttrs, I as Inline, a as Selection, M as Mark, S as Schema, A as Attrs, Q as QuoinBlock, g as BlockSpec, k as MarkSpec, c as AtomSpec } from './types-DULc8wwg.cjs';
+
+type Align = 'left' | 'center' | 'right' | 'justify';
+
+type Assoc = -1 | 1;
+type PosMap = (pos: Pos, assoc?: Assoc) => Pos;
+type StepResult = {
+    doc: EngineDoc;
+    map: PosMap;
+};
+type StepJSON = {
+    readonly stepType: string;
+} & Readonly<Record<string, unknown>>;
+interface Step {
+    readonly stepType: string;
+    apply(doc: EngineDoc): StepResult;
+    invert(before: EngineDoc): Step;
+    toJSON(): StepJSON;
+}
+type CreatedBlock = {
+    id: string;
+    type: string;
+    attrs: BlockAttrs;
+    indent: number;
+    region: string;
+    regions?: Record<string, Inline>;
+};
+
+type TransactionOrigin = 'input' | 'command' | 'paste' | 'drop' | 'remote' | 'reconcile' | 'ai' | 'history';
+declare class Transaction {
+    readonly before: EditorState;
+    readonly time: number;
+    private currentDoc;
+    private currentSelection;
+    private currentStoredMarks;
+    private selectionWasSet;
+    private storedMarksWereSet;
+    private readonly stepList;
+    private readonly docList;
+    private readonly mapList;
+    private readonly metaValues;
+    constructor(state: EditorState, time?: number);
+    get doc(): EngineDoc;
+    get docs(): readonly EngineDoc[];
+    get steps(): readonly Step[];
+    get maps(): readonly PosMap[];
+    get docChanged(): boolean;
+    get selection(): Selection | null;
+    get selectionSet(): boolean;
+    get storedMarks(): readonly Mark[] | null;
+    get storedMarksSet(): boolean;
+    get meta(): ReadonlyMap<string, unknown>;
+    get origin(): TransactionOrigin;
+    get addToHistory(): boolean;
+    step(step: Step): this;
+    maybeStep(step: Step): boolean;
+    setSelection(selection: Selection | null): this;
+    setStoredMarks(marks: readonly Mark[] | null): this;
+    setOrigin(origin: TransactionOrigin): this;
+    setMeta(key: string, value: unknown): this;
+    getMeta<T>(key: string): T | undefined;
+    mapPos(pos: Pos, assoc?: Assoc, fromStep?: number): Pos;
+}
+
+type PluginKey<T> = {
+    readonly name: string;
+    readonly __value?: T;
+};
+declare function createPluginKey<T>(name: string): PluginKey<T>;
+type PluginSpec<T> = {
+    readonly key: PluginKey<T>;
+    init(state: EditorState): T;
+    apply(tr: Transaction, value: T, oldState: EditorState, newState: EditorState): T;
+};
+
+type EditorState = {
+    readonly doc: EngineDoc;
+    readonly selection: Selection | null;
+    readonly storedMarks: readonly Mark[] | null;
+    readonly schema: Schema;
+    readonly plugins: readonly PluginSpec<unknown>[];
+    readonly pluginState: ReadonlyMap<string, unknown>;
+    readonly clock: () => number;
+};
+declare function createState(config: {
+    doc: EngineDoc;
+    schema: Schema;
+    selection?: Selection | null;
+    plugins?: readonly PluginSpec<unknown>[];
+    clock?: () => number;
+}): EditorState;
+declare function applyTransaction(state: EditorState, tr: Transaction): EditorState;
+declare function getPluginState<T>(state: EditorState, key: PluginKey<T>): T;
+
+type Command = (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;
+
+type BlockStructureOptions = {
+    newId?: () => string;
+};
+declare function duplicateBlocks(options?: BlockStructureOptions): Command;
+declare function insertBlockAfter(type: string, attrs?: BlockAttrs, options?: BlockStructureOptions): Command;
+
+declare function setAttrs(patch: Record<string, unknown>): Command;
+declare function setTextAlign(align: Align | null): Command;
+declare function setBlockColor(colors: {
+    color?: string | null;
+    background?: string | null;
+}): Command;
+
+type InsertTextOptions = {
+    origin?: TransactionOrigin;
+    newId?: () => string;
+};
+/**
+ * Inserts `value` at the selection, in place of any selected text or blocks, as a command an extension can return. It is
+ * an undo step of its own unless `options.origin` is `input`, which groups it with the typing around it.
+ */
+declare function insertText(value: string, options?: InsertTextOptions): Command;
+
+declare function toggleMark(type: string, attrs?: Attrs): Command;
+declare function setMark(type: string, attrs?: Attrs): Command;
+declare function unsetMark(type: string): Command;
+declare function setLink(href: string, title?: string): Command;
+declare function insertAtom(type: string, attrs: Attrs): Command;
+declare function insertMention(mention: {
+    id: string;
+    label: string;
+    kind?: string;
+}): Command;
+
+/** Moves the blocks and their nested blocks to `toIndex`, counted among the blocks that stay, as one range. */
+declare function moveBlocksTo(ids: readonly string[], toIndex: number, indent: number): Command;
+
+declare function setSelection(selection: Selection | null): Command;
+
+declare function splitBlock(options?: {
+    newId?: () => string;
+}): Command;
+
+declare function setBlockType(type: string, attrs?: BlockAttrs): Command;
+
+type CommandFactories = Readonly<Record<string, (...args: never[]) => Command>>;
+type BoundCommands<F extends CommandFactories> = {
+    [K in keyof F]: (...args: Parameters<F[K]>) => boolean;
+};
+type Chain<F extends CommandFactories> = {
+    [K in keyof F]: (...args: Parameters<F[K]>) => Chain<F>;
+} & {
+    run(): boolean;
+};
+
+type InputRuleRange = {
+    block: string;
+    region: string;
+    from: number;
+    to: number;
+};
+type InputRuleContext = {
+    readonly newId: () => string;
+};
+type InputRule = {
+    readonly name: string;
+    readonly match: RegExp;
+    readonly blockTypes?: readonly string[];
+    readonly kinds?: readonly string[];
+    handler(state: EditorState, match: RegExpExecArray, range: InputRuleRange, context?: InputRuleContext): Transaction | null;
+};
+declare function insertTextWithRules(value: string, rules: readonly InputRule[], options?: {
+    newId?: () => string;
+}): Command;
+
+type DOMParserLike = {
+    parseFromString(html: string, type: 'text/html'): {
+        readonly body: object;
+    };
+};
+type FromHTMLOptions = {
+    parser?: DOMParserLike;
+    newId?: () => string;
+};
+declare function fromHTML(html: string, options?: FromHTMLOptions): QuoinBlock[];
+
+type Slice = {
+    readonly blocks: readonly QuoinBlock[];
+    readonly openStart: boolean;
+    readonly openEnd: boolean;
+    /** Read from plain text: its first line takes the type of an empty block it is pasted into. */
+    readonly plainText?: boolean;
+};
+
+type TextStats = {
+    characters: number;
+    words: number;
+};
+
+declare function insertSlice(slice: Slice, options?: {
+    newId?: () => string;
+}): Command;
+
+declare function pasteLinkOverSelection(text: string): Command;
+
+declare const coreCommands: {
+    insertSlice: typeof insertSlice;
+    pasteLinkOverSelection: typeof pasteLinkOverSelection;
+    insertTextWithRules: typeof insertTextWithRules;
+    insertText: typeof insertText;
+    insertHardBreak: () => Command;
+    deleteSelection: () => Command;
+    deleteBackward: () => Command;
+    deleteForward: () => Command;
+    deleteWordBackward: () => Command;
+    deleteWordForward: () => Command;
+    deleteToLineStart: () => Command;
+    deleteToLineEnd: () => Command;
+    splitBlock: typeof splitBlock;
+    undo: () => Command;
+    redo: () => Command;
+    undoInputRule: () => Command;
+    toggleMark: typeof toggleMark;
+    setMark: typeof setMark;
+    unsetMark: typeof unsetMark;
+    setLink: typeof setLink;
+    unsetLink: () => Command;
+    clearFormatting: () => Command;
+    insertAtom: typeof insertAtom;
+    insertMention: typeof insertMention;
+    setBlockType: typeof setBlockType;
+    setAttrs: typeof setAttrs;
+    toggleTask: () => Command;
+    indent: () => Command;
+    outdent: () => Command;
+    moveBlocksUp: () => Command;
+    moveBlocksDown: () => Command;
+    moveBlocksTo: typeof moveBlocksTo;
+    duplicateBlocks: typeof duplicateBlocks;
+    deleteBlocks: () => Command;
+    insertBlockAfter: typeof insertBlockAfter;
+    setTextAlign: typeof setTextAlign;
+    setBlockColor: typeof setBlockColor;
+    selectAll: () => Command;
+    selectBlock: () => Command;
+    setSelection: typeof setSelection;
+};
+type CoreCommands = typeof coreCommands;
+type CoreExtensionOptions = {
+    typography?: {
+        dashes?: 'em' | 'en' | 'none';
+    } | false;
+    newId?: () => string;
+};
+declare function coreExtensions(options?: CoreExtensionOptions): Extension[];
+
+type KeyLike = {
+    key: string;
+    code?: string;
+    altKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    shiftKey: boolean;
+};
+declare function normalizeKey(name: string, isMac: boolean): string;
+declare function keyName(event: KeyLike, isMac: boolean): string;
+
+type EditorOptions = {
+    blocks: readonly QuoinBlock[];
+    extensions?: readonly Extension[];
+    onChange?: (blocks: QuoinBlock[]) => void;
+    onTransaction?: (tr: Transaction, state: EditorState) => void;
+    newId?: () => string;
+    now?: () => number;
+    isMac?: boolean;
+    /** Turns a storage key into the url written for IMAGE and FILE blocks in copies and, by default, in toMarkdown. */
+    resolveAssetUrl?: (key: string) => string;
+};
+type MarkdownOptions = {
+    comments?: boolean;
+    /** Write what markdown cannot hold as quoin comments. Plain export drops block-level extras and other data. */
+    lossless?: boolean;
+    resolveAssetUrl?: (key: string) => string;
+};
+type Editor<F extends CommandFactories = CoreCommands> = {
+    readonly state: EditorState;
+    readonly schema: Schema;
+    dispatch(tr: Transaction): void;
+    createTransaction(): Transaction;
+    subscribe(listener: (state: EditorState, tr: Transaction | null) => void): () => void;
+    readonly commands: BoundCommands<F>;
+    chain(): Chain<F>;
+    can(): BoundCommands<F>;
+    isActive(name: string, attrs?: Record<string, unknown>): boolean;
+    insertText(text: string): boolean;
+    handleKey(event: KeyLike): boolean;
+    paste(data: {
+        json?: string;
+        html?: string;
+        text?: string;
+    }, parser?: DOMParserLike): boolean;
+    copy(): {
+        json: string;
+        html: string;
+        text: string;
+    } | null;
+    getBlocks(): QuoinBlock[];
+    setBlocks(blocks: readonly QuoinBlock[]): boolean;
+    /** Runs the extensions' `onMount`, as a view does when it attaches; returns the means to end that mount. */
+    mount(): () => void;
+    decorations(): readonly Decoration[];
+    toMarkdown(options?: MarkdownOptions): string;
+    stats(): TextStats;
+    destroy(): void;
+};
+declare function createEditor<F extends CommandFactories = CoreCommands>(options: EditorOptions): Editor<F>;
+
+type Decoration = {
+    readonly kind: 'inline';
+    readonly block: string;
+    readonly region: string;
+    readonly from: number;
+    readonly to: number;
+    readonly attrs: Attrs;
+} | {
+    readonly kind: 'widget';
+    readonly block: string;
+    readonly region: string;
+    readonly offset: number;
+    readonly key: string;
+    readonly widget: string;
+    readonly attrs: Attrs;
+    readonly side?: -1 | 1;
+}
+/** Attributes written on the element of a whole block: `data-*` and `aria-*` names only. */
+ | {
+    readonly kind: 'block';
+    readonly block: string;
+    readonly attrs: Attrs;
+};
+type PasteRule = {
+    readonly name: string;
+    match(text: string, state: EditorState): Command | null;
+};
+type Extension = {
+    readonly name: string;
+    readonly priority?: number;
+    readonly blocks?: readonly BlockSpec[];
+    readonly marks?: readonly MarkSpec[];
+    readonly atoms?: readonly AtomSpec[];
+    readonly inputRules?: readonly InputRule[];
+    readonly pasteRules?: readonly PasteRule[];
+    readonly keymap?: Readonly<Record<string, Command>>;
+    readonly commands?: CommandFactories;
+    readonly plugins?: readonly PluginSpec<unknown>[];
+    readonly decorations?: (state: EditorState) => readonly Decoration[];
+    readonly onTransaction?: (tr: Transaction, state: EditorState) => void;
+    /**
+     * Refuses a transaction before it applies by returning false: the editor drops it whole. Undo and redo, the undo of an
+     * input rule, the blocks the host supplies and remote transactions are never filtered.
+     */
+    readonly filterTransaction?: (tr: Transaction, state: EditorState) => boolean;
+    /** Returns false to refuse blocks the host supplies that differ from the document, which then stays as it is. */
+    readonly filterHostBlocks?: (blocks: readonly QuoinBlock[], state: EditorState) => boolean;
+    /** Runs on each `editor.mount()`; what it returns runs when that mount ends or the editor is destroyed. */
+    readonly onMount?: (editor: Editor<CommandFactories>) => (() => void) | void;
+    readonly ui?: unknown;
+};
+
+export { type Align as A, type BlockStructureOptions as B, type CommandFactories as C, type Decoration as D, type Extension as E, type FromHTMLOptions as F, createState as G, fromHTML as H, type InputRule as I, getPluginState as J, type KeyLike as K, insertBlockAfter as L, type MarkdownOptions as M, insertText as N, insertTextWithRules as O, type PluginKey as P, keyName as Q, normalizeKey as R, type Step as S, Transaction as T, setBlockType as U, toggleMark as V, type Editor as a, type Command as b, type EditorState as c, type PluginSpec as d, type Assoc as e, type BoundCommands as f, type Chain as g, type CoreCommands as h, type CoreExtensionOptions as i, type CreatedBlock as j, type DOMParserLike as k, type EditorOptions as l, type InputRuleContext as m, type InputRuleRange as n, type InsertTextOptions as o, type PasteRule as p, type PosMap as q, type Slice as r, type StepJSON as s, type StepResult as t, type TextStats as u, type TransactionOrigin as v, applyTransaction as w, coreExtensions as x, createEditor as y, createPluginKey as z };

package/dist/types-DULc8wwg.d.cts

@@ -0,0 +1,120 @@
+type Attrs = Readonly<Record<string, string>>;
+type Mark = {
+    readonly type: string;
+    readonly attrs?: Attrs;
+};
+type TextNode = {
+    readonly kind: 'text';
+    readonly text: string;
+    readonly marks: readonly Mark[];
+};
+type AtomNode = {
+    readonly kind: 'atom';
+    readonly type: string;
+    readonly attrs: Attrs;
+    readonly marks: readonly Mark[];
+};
+type InlineNode = TextNode | AtomNode;
+type Inline = readonly InlineNode[];
+type BlockAttrs = Readonly<Record<string, unknown>>;
+type EngineBlock = {
+    readonly id: string;
+    readonly type: string;
+    readonly indent: number;
+    readonly attrs: BlockAttrs;
+    readonly regions: Readonly<Record<string, Inline>>;
+};
+type EngineDoc = {
+    readonly blocks: readonly EngineBlock[];
+    readonly index: ReadonlyMap<string, number>;
+};
+type Pos = {
+    readonly block: string;
+    readonly region: string;
+    readonly offset: number;
+};
+type TextSelection = {
+    readonly kind: 'text';
+    readonly anchor: Pos;
+    readonly head: Pos;
+};
+type NodeSelection = {
+    readonly kind: 'node';
+    readonly block: string;
+};
+type BlockRangeSelection = {
+    readonly kind: 'blocks';
+    readonly anchor: string;
+    readonly head: string;
+};
+type Selection = TextSelection | NodeSelection | BlockRangeSelection;
+
+/** A document is an ordered array of these; `type` is looked up in the registered block definitions. */
+type QuoinBlock = {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    /** Nesting depth shared by every block type, such as list nesting and toggle children; 0 when absent. */
+    indent?: number;
+};
+
+type ParseInlineOptions = {
+    softBreak?: 'newline' | 'space';
+    refs?: ReadonlyMap<string, {
+        href: string;
+        title?: string;
+    }>;
+};
+type SerializeInlineOptions = {
+    escapeLineStart?: boolean;
+    escapePipes?: boolean;
+    hardBreak?: 'backslash' | 'br';
+};
+type InlineCodec = {
+    parse(markdown: string, options?: ParseInlineOptions): Inline;
+    serialize(inline: Inline, options?: SerializeInlineOptions): string;
+};
+type CodecContext = {
+    readonly inline: InlineCodec;
+    newId(): string;
+};
+type BlockContent = {
+    attrs: BlockAttrs;
+    regions: Record<string, Inline>;
+};
+type BlockFlow = 'text' | 'void' | 'structured';
+type MarkdownExportContext = CodecContext & {
+    resolveAssetUrl(storageKey: string): string;
+    comments: boolean;
+};
+type BlockSpec = {
+    readonly type: string;
+    readonly flow: BlockFlow;
+    readonly primaryRegion?: string;
+    readonly enter?: 'split' | 'hardBreak';
+    fromData(data: Record<string, unknown>, ctx: CodecContext): BlockContent;
+    toData(block: EngineBlock, ctx: CodecContext): Record<string, unknown>;
+    initial(): BlockContent;
+    splitAttrs?(attrs: BlockAttrs): {
+        type: string;
+        attrs: BlockAttrs;
+    };
+    toMarkdown?(block: EngineBlock, ctx: MarkdownExportContext): string;
+    toPlainText?(block: EngineBlock): string;
+};
+type MarkSpec = {
+    readonly type: string;
+    readonly inclusive: boolean;
+};
+type AtomSpec = {
+    readonly type: string;
+    plainText(attrs: Attrs): string;
+};
+type Schema = {
+    readonly blocks: ReadonlyMap<string, BlockSpec>;
+    readonly marks: ReadonlyMap<string, MarkSpec>;
+    readonly atoms: ReadonlyMap<string, AtomSpec>;
+    readonly defaultTextBlock: string;
+};
+
+export type { Attrs as A, BlockAttrs as B, CodecContext as C, EngineDoc as E, Inline as I, Mark as M, NodeSelection as N, Pos as P, QuoinBlock as Q, Schema as S, TextNode as T, Selection as a, AtomNode as b, AtomSpec as c, BlockContent as d, BlockFlow as e, BlockRangeSelection as f, BlockSpec as g, EngineBlock as h, InlineCodec as i, InlineNode as j, MarkSpec as k, MarkdownExportContext as l, ParseInlineOptions as m, SerializeInlineOptions as n, TextSelection as o };

package/dist/types-DULc8wwg.d.ts

@@ -0,0 +1,120 @@
+type Attrs = Readonly<Record<string, string>>;
+type Mark = {
+    readonly type: string;
+    readonly attrs?: Attrs;
+};
+type TextNode = {
+    readonly kind: 'text';
+    readonly text: string;
+    readonly marks: readonly Mark[];
+};
+type AtomNode = {
+    readonly kind: 'atom';
+    readonly type: string;
+    readonly attrs: Attrs;
+    readonly marks: readonly Mark[];
+};
+type InlineNode = TextNode | AtomNode;
+type Inline = readonly InlineNode[];
+type BlockAttrs = Readonly<Record<string, unknown>>;
+type EngineBlock = {
+    readonly id: string;
+    readonly type: string;
+    readonly indent: number;
+    readonly attrs: BlockAttrs;
+    readonly regions: Readonly<Record<string, Inline>>;
+};
+type EngineDoc = {
+    readonly blocks: readonly EngineBlock[];
+    readonly index: ReadonlyMap<string, number>;
+};
+type Pos = {
+    readonly block: string;
+    readonly region: string;
+    readonly offset: number;
+};
+type TextSelection = {
+    readonly kind: 'text';
+    readonly anchor: Pos;
+    readonly head: Pos;
+};
+type NodeSelection = {
+    readonly kind: 'node';
+    readonly block: string;
+};
+type BlockRangeSelection = {
+    readonly kind: 'blocks';
+    readonly anchor: string;
+    readonly head: string;
+};
+type Selection = TextSelection | NodeSelection | BlockRangeSelection;
+
+/** A document is an ordered array of these; `type` is looked up in the registered block definitions. */
+type QuoinBlock = {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    /** Nesting depth shared by every block type, such as list nesting and toggle children; 0 when absent. */
+    indent?: number;
+};
+
+type ParseInlineOptions = {
+    softBreak?: 'newline' | 'space';
+    refs?: ReadonlyMap<string, {
+        href: string;
+        title?: string;
+    }>;
+};
+type SerializeInlineOptions = {
+    escapeLineStart?: boolean;
+    escapePipes?: boolean;
+    hardBreak?: 'backslash' | 'br';
+};
+type InlineCodec = {
+    parse(markdown: string, options?: ParseInlineOptions): Inline;
+    serialize(inline: Inline, options?: SerializeInlineOptions): string;
+};
+type CodecContext = {
+    readonly inline: InlineCodec;
+    newId(): string;
+};
+type BlockContent = {
+    attrs: BlockAttrs;
+    regions: Record<string, Inline>;
+};
+type BlockFlow = 'text' | 'void' | 'structured';
+type MarkdownExportContext = CodecContext & {
+    resolveAssetUrl(storageKey: string): string;
+    comments: boolean;
+};
+type BlockSpec = {
+    readonly type: string;
+    readonly flow: BlockFlow;
+    readonly primaryRegion?: string;
+    readonly enter?: 'split' | 'hardBreak';
+    fromData(data: Record<string, unknown>, ctx: CodecContext): BlockContent;
+    toData(block: EngineBlock, ctx: CodecContext): Record<string, unknown>;
+    initial(): BlockContent;
+    splitAttrs?(attrs: BlockAttrs): {
+        type: string;
+        attrs: BlockAttrs;
+    };
+    toMarkdown?(block: EngineBlock, ctx: MarkdownExportContext): string;
+    toPlainText?(block: EngineBlock): string;
+};
+type MarkSpec = {
+    readonly type: string;
+    readonly inclusive: boolean;
+};
+type AtomSpec = {
+    readonly type: string;
+    plainText(attrs: Attrs): string;
+};
+type Schema = {
+    readonly blocks: ReadonlyMap<string, BlockSpec>;
+    readonly marks: ReadonlyMap<string, MarkSpec>;
+    readonly atoms: ReadonlyMap<string, AtomSpec>;
+    readonly defaultTextBlock: string;
+};
+
+export type { Attrs as A, BlockAttrs as B, CodecContext as C, EngineDoc as E, Inline as I, Mark as M, NodeSelection as N, Pos as P, QuoinBlock as Q, Schema as S, TextNode as T, Selection as a, AtomNode as b, AtomSpec as c, BlockContent as d, BlockFlow as e, BlockRangeSelection as f, BlockSpec as g, EngineBlock as h, InlineCodec as i, InlineNode as j, MarkSpec as k, MarkdownExportContext as l, ParseInlineOptions as m, SerializeInlineOptions as n, TextSelection as o };