quoin-editor 0.4.2 → 1.0.1

package/dist/types-C6_QkXzy.d.ts

@@ -0,0 +1,358 @@
+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.js';
+
+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 {
+    #private;
+    readonly before: EditorState;
+    readonly time: number;
+    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 };