@dou-ui/editor 0.0.0-stage → 0.1.0-alpha.1

package/dist/types/editor.d.ts

@@ -0,0 +1,252 @@
+import type { EditorState, Command, Plugin } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+import type { CommentAction, CommentAuthor, CommentThread } from 'dou-ui';
+import { type ComputedRef, type InjectionKey, type ShallowRef } from 'vue';
+import type { CommentAnchor, CommentRange } from './core/comments';
+import type { EditorExtension, ResolvedEditorExtensions } from './core/extension';
+import type { BlockChanges } from './core/changes';
+import type { Block, EditorDocument, PartialBlock } from './core/model';
+import type { EditorSearchQuery } from './core/search';
+import type { BlockEdge, BlockPatch, BlockPlacement, EditorTransaction, EditorTransactionMeta } from './core/transaction';
+import type { EditorMessages, EditorMessagesOverride } from './locale';
+export interface EditorProps {
+    /**
+     * The document, bound with `v-model`. With collaboration the shared
+     * document is the source of truth: leave `v-model` out and read changes
+     * from the `change` event.
+     */
+    modelValue?: EditorDocument<PartialBlock>;
+    /**
+     * Blocks, marks, shortcuts and menu entries. Defaults to `[editorKit()]`;
+     * read once, when the editor mounts.
+     */
+    extensions?: (EditorExtension | EditorExtension[])[];
+    /** Show the document without editing it. Links stay clickable. */
+    readonly?: boolean;
+    /** The built-in find panel (`Ctrl/⌘+F`). Off, the keys are left to the browser. On by default. */
+    searchable?: boolean;
+    /** The hint in the empty block under the cursor. */
+    placeholder?: string;
+    /** Replace any of the built-in texts. */
+    messages?: EditorMessagesOverride;
+    /** The accessible name of the editing area. */
+    ariaLabel?: string;
+    /** Focus the editor once it is mounted. */
+    autofocus?: boolean;
+    /**
+     * Extra ProseMirror plugins, e.g. for collaboration. They run before
+     * the built-in ones, so their keys win.
+     */
+    plugins?: Plugin[];
+    /** Leave out the built-in undo history (collaboration brings its own). */
+    history?: boolean;
+    /** Undo and redo commands to replace the built-in ones. */
+    undo?: Command;
+    redo?: Command;
+    /**
+     * The comment threads, bound with `v-model:comments`. The text a thread
+     * is about carries its id in the document; leave this out to turn
+     * comments off.
+     */
+    comments?: CommentThread[];
+    /** Who is commenting. Without it comments can be read but not written. */
+    author?: CommentAuthor;
+    /** The id of the thread shown beside its text, bound with `v-model:activeComment`. */
+    activeComment?: string | null;
+    /** Whether threads can be started and answered; also while `readonly`. Defaults to `true`. */
+    commentable?: boolean;
+    /**
+     * An older version of the document, e.g. one the app saved. The editor
+     * then shows the document read-only, with what changed since marked:
+     * blocks added and removed, and in each changed block the text added
+     * and removed. Blocks are matched by `id`; a block without one shows as
+     * removed.
+     */
+    compare?: EditorDocument<PartialBlock> | null;
+    /**
+     * The block with the cursor and the selected blocks, bound with
+     * `v-model:selection`. Setting it puts the cursor at the end of `block`,
+     * or selects `blocks` when there are several siblings, without focusing.
+     */
+    selection?: EditorSelection;
+}
+/**
+ * Who made a change: `'external'` for a new `v-model` value or
+ * `setBlocks`, `'remote'` for a collaborator's, `'restore'` for `restore`,
+ * `'undo'` and `'redo'`, or
+ * the `origin` given to `transact`. Typing and the editor's own commands
+ * leave it out.
+ */
+export type EditorOrigin = 'external' | 'remote' | 'restore' | 'undo' | 'redo' | (string & {});
+/** What a change to the document did, as the `transaction` event hands it over. */
+export interface EditorTransactionResult {
+    /** The document after the change, as `update:modelValue` gets it next. */
+    blocks: Block[];
+    /** The blocks the change touched, by id. */
+    changes: BlockChanges;
+    meta: {
+        origin?: EditorOrigin;
+        /** Whether undo can take the change back: not for others' changes, nor for undo and redo themselves. */
+        history: boolean;
+    };
+}
+/** Where the selection is, by block. */
+export interface EditorSelection {
+    /** The innermost block at the cursor (the moving end of a selection); `null` while none is. */
+    block: string | null;
+    /**
+     * The blocks the selection covers: the selected blocks, or the blocks a
+     * text selection runs across, at the level they share.
+     */
+    blocks: string[];
+}
+export interface EditorEmits {
+    'update:modelValue': [document: EditorDocument];
+    /** The document changed: typing, formatting, moving blocks. */
+    change: [document: EditorDocument];
+    /** Every change to the document, with what it touched; `update:modelValue` follows. */
+    transaction: [result: EditorTransactionResult];
+    /** The cursor moved to another block, or other blocks were selected. */
+    'update:selection': [selection: EditorSelection];
+    /** Before a link opens (Ctrl / ⌘ + click, or a click while read-only); `preventDefault()` keeps it from opening in a new tab. */
+    linkOpen: [event: EditorLinkOpenEvent];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+    'update:comments': [threads: CommentThread[]];
+    'update:activeComment': [id: string | null];
+    /** A change to the comments made here: to send to a server, notify people, keep a log. */
+    commentAction: [action: CommentAction];
+}
+/**
+ * Before a link is followed. `preventDefault()` stops the editor from
+ * opening it in a new tab, e.g. to use the app's router or ask first.
+ */
+export interface EditorLinkOpenEvent {
+    /** The address as the text's `link` holds it. */
+    link: string;
+    /** The id of the block the link is in. */
+    block: string;
+    defaultPrevented: boolean;
+    preventDefault: () => void;
+}
+export interface EditorExpose {
+    /** The ProseMirror view, once mounted. */
+    readonly view: EditorView | null;
+    focus: () => void;
+    blur: () => void;
+    /** The current document. */
+    getBlocks: () => Block[];
+    /** Replace the document. The change does not go into the undo history. */
+    setBlocks: (blocks: PartialBlock[]) => void;
+    /** The current document as HTML, written by the extensions (see `blocksToHTML`). */
+    getHTML: () => string;
+    /** Replace the document with HTML, read like pasted HTML. */
+    setHTML: (html: string) => void;
+    /** Run a ProseMirror command, e.g. one of the exported ones. */
+    run: (command: Command) => boolean;
+    /**
+     * Opens the find panel (`Ctrl/⌘+F`), with a query put in; with `replace`
+     * in it, the replace box opens too. `false` when `searchable` is off or
+     * the editor is not mounted.
+     */
+    openSearch: (query?: Partial<EditorSearchQuery>) => boolean;
+    /** Closes the find panel; `false` when it was not open. */
+    closeSearch: () => boolean;
+    /**
+     * Make changes by blocks and ids, applied together as one undo step.
+     * Returns what happened, or `null` when nothing changed. Works while
+     * read-only too.
+     */
+    transact: (fn: (tr: EditorTransaction) => void, meta?: EditorTransactionMeta) => EditorTransactionResult | null;
+    /** One block, or `null` when there is none with that id. */
+    getBlock: (id: string) => Block | null;
+    /**
+     * Insert blocks, by default after the block with the cursor. Returns the
+     * new blocks' ids (an id already in use is replaced). One undo step.
+     */
+    insertBlocks: (blocks: PartialBlock[], placement?: BlockPlacement) => string[];
+    /** Change a block's type, props (merged), content or children. One undo step. */
+    updateBlock: (id: string, patch: BlockPatch) => boolean;
+    /** Remove blocks with their children. One undo step. */
+    removeBlocks: (ids: string[]) => boolean;
+    /** Move blocks, in the order given, before, after or into another block. One undo step. */
+    moveBlocks: (ids: string[], placement: BlockPlacement) => boolean;
+    /** Focus the editor with the cursor at the start or end (the default) of a block, scrolled into view. */
+    focusBlock: (id: string, edge?: BlockEdge) => boolean;
+    /** The selection by block, as `v-model:selection` has it. */
+    getSelection: () => EditorSelection;
+    undo: () => boolean;
+    redo: () => boolean;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    /**
+     * Start a thread on the selected text and open the box for its first
+     * comment; with the cursor on commented text, open that thread to reply.
+     */
+    comment: () => boolean;
+    /** Where each thread is anchored; `null` for a thread whose text was deleted. */
+    getCommentAnchors: () => Record<string, CommentAnchor | null>;
+    /**
+     * Replace the document with `doc`, e.g. an older version, as one
+     * change undo takes back. With collaboration only the blocks that differ
+     * are written, and everyone sees it. The `transaction` event has origin
+     * `'restore'`. Like the other methods it works while `readonly`; it is
+     * the one change allowed while comparing. Returns `false` when nothing
+     * differs.
+     */
+    restore: (doc: EditorDocument<PartialBlock>) => boolean;
+    /** With `compare`: scroll to the next change after the one last shown; `false` when there is none. */
+    nextChange: () => boolean;
+    /** With `compare`: scroll to the change before the one last shown. */
+    previousChange: () => boolean;
+}
+/** The comments, as the parts around the editing area see them. */
+export interface EditorComments {
+    /** Comments are on: there are threads to show. */
+    enabled: ComputedRef<boolean>;
+    /** Threads can be started and answered. */
+    writable: ComputedRef<boolean>;
+    threads: ComputedRef<readonly CommentThread[]>;
+    author: ComputedRef<CommentAuthor | undefined>;
+    /** The thread shown beside its text. */
+    active: ComputedRef<string | null>;
+    /** The text a new thread is being started on. */
+    pending: ShallowRef<CommentRange | null>;
+    /** Goes up when the open thread's reply box should take focus. */
+    focusRequest: ShallowRef<number>;
+    /** The selected text, also in a read-only editor; `null` when there is none. */
+    selection: () => CommentRange | null;
+    /** Start a thread on the selected text, or open the one the cursor is in. */
+    start: () => boolean;
+    apply: (action: CommentAction) => void;
+    open: (id: string | null) => void;
+    /** Close the card, dropping a thread not yet started. */
+    close: () => void;
+}
+/** What the parts around the editing area (menus, handle, toolbar) share. */
+export interface EditorContext {
+    view: ShallowRef<EditorView | null>;
+    /** Updated on every transaction, so computeds follow the selection too. */
+    state: ShallowRef<EditorState | null>;
+    focused: ShallowRef<boolean>;
+    /** Blocks are being dragged by the handle. */
+    dragging: ShallowRef<boolean>;
+    editable: ComputedRef<boolean>;
+    messages: ComputedRef<EditorMessages>;
+    /** What the extensions contribute: schema, menu entries, toolbar toggles. */
+    kit: ResolvedEditorExtensions;
+    /** The element the overlays are positioned against. */
+    root: ShallowRef<HTMLElement | null>;
+    comments: EditorComments;
+}
+export declare const editorKey: InjectionKey<EditorContext>;
+/** For the formatting toolbar: the open state of the menus in it. */
+export declare function provideToolbarMenus(): Set<ShallowRef<boolean>>;
+/**
+ * The open state for a menu in the formatting toolbar (an extension's
+ * `toolbar` component), to bind with `v-model:open`: the toolbar stays
+ * while the menu is open, though the focus has left the editor.
+ */
+export declare function useToolbarMenu(): ShallowRef<boolean>;
+/** The editor around a block component, for its messages, state and view. */
+export declare function useEditor(): EditorContext;

package/dist/types/editor.vue.d.ts

@@ -0,0 +1,210 @@
+import { Plugin } from 'prosemirror-state';
+import { type Block, type EditorDocument, type PartialBlock } from './core/model';
+import { type EditorExpose, type EditorProps, type EditorLinkOpenEvent, type EditorSelection, type EditorTransactionResult } from './editor';
+declare const __VLS_export: import("vue").DefineComponent<EditorProps, EditorExpose, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    change: (document: EditorDocument<Block>) => any;
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (document: EditorDocument<Block>) => any;
+    transaction: (result: EditorTransactionResult) => any;
+    "update:selection": (selection: EditorSelection) => any;
+    linkOpen: (event: EditorLinkOpenEvent) => any;
+    "update:comments": (threads: import("dou-ui").CommentThread[]) => any;
+    "update:activeComment": (id: string | null) => any;
+    commentAction: (action: import("dou-ui").CommentAction) => any;
+}, string, import("vue").PublicProps, Readonly<EditorProps> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((document: EditorDocument<Block>) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((document: EditorDocument<Block>) => any) | undefined;
+    onTransaction?: ((result: EditorTransactionResult) => any) | undefined;
+    "onUpdate:selection"?: ((selection: EditorSelection) => any) | undefined;
+    onLinkOpen?: ((event: EditorLinkOpenEvent) => any) | undefined;
+    "onUpdate:comments"?: ((threads: import("dou-ui").CommentThread[]) => any) | undefined;
+    "onUpdate:activeComment"?: ((id: string | null) => any) | undefined;
+    onCommentAction?: ((action: import("dou-ui").CommentAction) => any) | undefined;
+}>, {
+    placeholder: string;
+    comments: import("dou-ui").CommentThread[];
+    selection: EditorSelection;
+    undo: import("prosemirror-state").Command;
+    redo: import("prosemirror-state").Command;
+    plugins: Plugin<any>[];
+    history: boolean;
+    messages: {
+        placeholder?: string | undefined;
+        emptyPlaceholder?: string | undefined;
+        headingPlaceholder?: string | undefined;
+        types?: {
+            paragraph?: string | undefined;
+            heading1?: string | undefined;
+            heading2?: string | undefined;
+            heading3?: string | undefined;
+            bulletItem?: string | undefined;
+            numberedItem?: string | undefined;
+            checkItem?: string | undefined;
+            quote?: string | undefined;
+            codeBlock?: string | undefined;
+            divider?: string | undefined;
+            image?: string | undefined;
+            toggle?: string | undefined;
+            callout?: string | undefined;
+            table?: string | undefined;
+            attachment?: string | undefined;
+            embed?: string | undefined;
+        } | undefined;
+        hints?: {
+            paragraph?: string | undefined;
+            heading1?: string | undefined;
+            heading2?: string | undefined;
+            heading3?: string | undefined;
+            bulletItem?: string | undefined;
+            numberedItem?: string | undefined;
+            checkItem?: string | undefined;
+            quote?: string | undefined;
+            codeBlock?: string | undefined;
+            divider?: string | undefined;
+            image?: string | undefined;
+            toggle?: string | undefined;
+            callout?: string | undefined;
+            table?: string | undefined;
+            attachment?: string | undefined;
+            embed?: string | undefined;
+        } | undefined;
+        image?: {
+            empty?: string | undefined;
+            upload?: string | undefined;
+            embed?: string | undefined;
+            urlPlaceholder?: string | undefined;
+            apply?: string | undefined;
+            uploading?: string | undefined;
+            failed?: string | undefined;
+            caption?: string | undefined;
+            resize?: string | undefined;
+        } | undefined;
+        codeBlock?: {
+            language?: string | undefined;
+            plainText?: string | undefined;
+        } | undefined;
+        toggle?: {
+            expand?: string | undefined;
+            collapse?: string | undefined;
+        } | undefined;
+        callout?: {
+            change?: string | undefined;
+            tones?: {
+                info?: string | undefined;
+                tip?: string | undefined;
+                warning?: string | undefined;
+                danger?: string | undefined;
+            } | undefined;
+        } | undefined;
+        mention?: {
+            label?: string | undefined;
+            searching?: string | undefined;
+            noResults?: string | undefined;
+        } | undefined;
+        table?: {
+            row?: string | undefined;
+            column?: string | undefined;
+            insertAbove?: string | undefined;
+            insertBelow?: string | undefined;
+            insertLeft?: string | undefined;
+            insertRight?: string | undefined;
+            moveUp?: string | undefined;
+            moveDown?: string | undefined;
+            moveLeft?: string | undefined;
+            moveRight?: string | undefined;
+            deleteRow?: string | undefined;
+            deleteColumn?: string | undefined;
+            merge?: string | undefined;
+            split?: string | undefined;
+            clear?: string | undefined;
+            headerRow?: string | undefined;
+            headerColumn?: string | undefined;
+            alignLeft?: string | undefined;
+            alignCenter?: string | undefined;
+            alignRight?: string | undefined;
+            addRow?: string | undefined;
+            addColumn?: string | undefined;
+        } | undefined;
+        colors?: {
+            label?: string | undefined;
+            text?: string | undefined;
+            background?: string | undefined;
+            none?: string | undefined;
+            names?: {
+                gray?: string | undefined;
+                red?: string | undefined;
+                orange?: string | undefined;
+                yellow?: string | undefined;
+                green?: string | undefined;
+                blue?: string | undefined;
+                purple?: string | undefined;
+                pink?: string | undefined;
+            } | undefined;
+        } | undefined;
+        align?: {
+            label?: string | undefined;
+            left?: string | undefined;
+            center?: string | undefined;
+            right?: string | undefined;
+        } | undefined;
+        attachment?: {
+            empty?: string | undefined;
+            upload?: string | undefined;
+            uploading?: string | undefined;
+            failed?: string | undefined;
+            retry?: string | undefined;
+            download?: string | undefined;
+        } | undefined;
+        embed?: {
+            empty?: string | undefined;
+            urlPlaceholder?: string | undefined;
+            apply?: string | undefined;
+            invalid?: string | undefined;
+            insecure?: string | undefined;
+            caption?: string | undefined;
+            edit?: string | undefined;
+            cancel?: string | undefined;
+        } | undefined;
+        noResults?: string | undefined;
+        addBlock?: string | undefined;
+        dragHandle?: string | undefined;
+        turnInto?: string | undefined;
+        duplicate?: string | undefined;
+        delete?: string | undefined;
+        moveUp?: string | undefined;
+        moveDown?: string | undefined;
+        bold?: string | undefined;
+        italic?: string | undefined;
+        underline?: string | undefined;
+        strike?: string | undefined;
+        code?: string | undefined;
+        link?: string | undefined;
+        linkPlaceholder?: string | undefined;
+        applyLink?: string | undefined;
+        removeLink?: string | undefined;
+        comment?: string | undefined;
+        commentThread?: string | undefined;
+        removedBlock?: string | undefined;
+        restored?: string | undefined;
+        changeAdded?: string | undefined;
+        changeRemoved?: string | undefined;
+        changeChanged?: string | undefined;
+        formatting?: string | undefined;
+        blockTypes?: string | undefined;
+    };
+    autofocus: boolean;
+    modelValue: EditorDocument<PartialBlock>;
+    readonly: boolean;
+    author: import("dou-ui").CommentAuthor;
+    compare: EditorDocument<PartialBlock> | null;
+    extensions: (import("./index.js").EditorExtension | import("./index.js").EditorExtension[])[];
+    searchable: boolean;
+    ariaLabel: string;
+    activeComment: string | null;
+    commentable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/extensions/align/align-menu.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/extensions/align/align-sub.vue.d.ts

@@ -0,0 +1,7 @@
+import type { Block } from '../../core/model';
+type __VLS_Props = {
+    block: Block;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/extensions/align/commands.d.ts

@@ -0,0 +1,13 @@
+import type { Command, EditorState } from 'prosemirror-state';
+import type { BlockAlign } from '../../core/align';
+/**
+ * Align the selected blocks (or the block with `id`). `'left'` and `null`
+ * both go back to the reading direction, stored as no `align` at all.
+ * Blocks that can't be aligned are left alone.
+ */
+export declare function setAlign(align: BlockAlign | null, id?: string): Command;
+/**
+ * The alignment the selected blocks share: `null` for none set, `'mixed'`
+ * when they differ, `undefined` when none can be aligned.
+ */
+export declare function currentAlign(state: EditorState): BlockAlign | 'mixed' | null | undefined;

package/dist/types/extensions/align/index.d.ts

@@ -0,0 +1,7 @@
+export { currentAlign, setAlign } from './commands';
+/**
+ * Aligning paragraphs, headings and quotes left, centered or right: a menu
+ * in the formatting toolbar and in the block menu, and `Mod+Shift+L/E/R`.
+ * The blocks keep it as `props.align`.
+ */
+export declare const align: import("../..").EditorExtension;

package/dist/types/extensions/attachment/attachment-block.vue.d.ts

@@ -0,0 +1,17 @@
+import type { BlockProps } from '../../core/model';
+import type { Uploads } from '../image/uploads';
+type __VLS_Props = {
+    block: {
+        id: string;
+        type: string;
+        props: BlockProps;
+    };
+    updateProps: (props: BlockProps) => void;
+    selected: boolean;
+    editable: boolean;
+    uploads: Uploads;
+    accept?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/extensions/attachment/files.d.ts

@@ -0,0 +1,6 @@
+/** Addresses an attachment may link to: web, relative, and files held in the page. */
+export declare function isSafeFileSrc(src: string): boolean;
+/** `1.2 MB`, `340 KB`, `12 B`. */
+export declare function formatFileSize(size: unknown): string;
+/** The kind of file, for its icon. */
+export declare function fileKind(mime: string, name: string): 'image' | 'video' | 'audio' | 'archive' | 'text' | 'spreadsheet' | 'other';

package/dist/types/extensions/attachment/index.d.ts

@@ -0,0 +1,20 @@
+import type { EditorExtension } from '../../core/extension';
+import { type FileUploader } from '../image/uploads';
+import { formatFileSize, isSafeFileSrc } from './files';
+export interface AttachmentOptions {
+    /**
+     * Store the file and resolve with its address. Without it, files are
+     * kept in the document as data URLs, which suits trying things out but
+     * makes documents large.
+     */
+    upload?: FileUploader;
+    /** The file types the picker offers, as the `accept` of a file input. */
+    accept?: string;
+}
+/**
+ * Attachment blocks: a file with its name and size and a download button.
+ * Files dropped or pasted into the editor become attachments (images stay
+ * images when the image block is there).
+ */
+export declare function attachment(options?: AttachmentOptions): EditorExtension;
+export { formatFileSize, isSafeFileSrc, type FileUploader };

package/dist/types/extensions/blocks.d.ts

@@ -0,0 +1,8 @@
+/** The paragraph itself is part of the frame; this adds its menu entry and shortcut. */
+export declare const paragraph: import("..").EditorExtension;
+/** Headings, levels 1 to 3. `# ` to `### ` turn a paragraph into one. */
+export declare const heading: import("..").EditorExtension;
+/** A quotation. `> ` turns a paragraph into one. */
+export declare const quote: import("..").EditorExtension;
+/** A horizontal line. `---` in an empty paragraph. */
+export declare const divider: import("..").EditorExtension;

package/dist/types/extensions/callout/callout-block.vue.d.ts

@@ -0,0 +1,14 @@
+import type { BlockProps } from '../../core/model';
+type __VLS_Props = {
+    block: {
+        id: string;
+        type: string;
+        props: BlockProps;
+    };
+    updateProps: (props: BlockProps) => void;
+    selected: boolean;
+    editable: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/extensions/callout/html.d.ts

@@ -0,0 +1,4 @@
+import { type BlockOutput } from '../../core/output';
+export declare const calloutOutput: BlockOutput;
+/** `<aside data-callout>` from `blocksToHTML`, and quotes that start with `[!TIP]` as Markdown writes them. */
+export declare function prepareCallouts(root: HTMLElement): void;

package/dist/types/extensions/callout/index.d.ts

@@ -0,0 +1,3 @@
+/** A callout: text in a tinted box with an icon; the icon picks the tone. */
+export declare const callout: import("../..").EditorExtension;
+export type { CalloutTone } from './tones';

package/dist/types/extensions/callout/tones.d.ts

@@ -0,0 +1,8 @@
+/** The callout's tones and their icons. */
+export declare const calloutTones: {
+    info: import("@dou-ui/icons").IconComponent;
+    tip: import("@dou-ui/icons").IconComponent;
+    warning: import("@dou-ui/icons").IconComponent;
+    danger: import("@dou-ui/icons").IconComponent;
+};
+export type CalloutTone = keyof typeof calloutTones;

package/dist/types/extensions/code-block/code-block-view.vue.d.ts

@@ -0,0 +1,16 @@
+import type { BlockProps } from '../../core/model';
+import type { CodeLanguage } from './languages';
+type __VLS_Props = {
+    block: {
+        id: string;
+        type: string;
+        props: BlockProps;
+    };
+    updateProps: (props: BlockProps) => void;
+    selected: boolean;
+    editable: boolean;
+    languages: CodeLanguage[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/extensions/code-block/index.d.ts

@@ -0,0 +1,19 @@
+import { type EditorExtension } from '../../core/extension';
+import { type CodeHighlighter } from '../../core/highlight';
+import { defaultLanguages, type CodeLanguage } from './languages';
+export interface CodeBlockOptions {
+    /**
+     * Highlights the code, the same function `DouCodeBlock` takes. Defaults
+     * to `DouCodeBlock.highlight` in the ConfigProvider's `defaults`; without
+     * either the code stays plain.
+     */
+    highlight?: CodeHighlighter;
+    /** The languages offered in the picker. Strings serve as both value and name. */
+    languages?: (CodeLanguage | string)[];
+}
+/**
+ * Code in a monospace font, without formatting, with a language picker and
+ * a copy button. ` ``` ` at the start of a block.
+ */
+export declare function codeBlock(options?: CodeBlockOptions): EditorExtension;
+export { defaultLanguages, type CodeHighlighter, type CodeLanguage };

package/dist/types/extensions/code-block/languages.d.ts

@@ -0,0 +1,9 @@
+/** A language in the code block's picker. `value` goes to the highlighter. */
+export interface CodeLanguage {
+    value: string;
+    label: string;
+}
+/** Common languages, named as shiki names them. */
+export declare const defaultLanguages: CodeLanguage[];
+/** Strings name themselves. */
+export declare const toLanguage: (item: CodeLanguage | string) => CodeLanguage;

package/dist/types/extensions/colors/color-menu.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/extensions/colors/index.d.ts

@@ -0,0 +1,7 @@
+export { setHighlight, setTextColor, textColors, type TextColor } from './palette';
+/**
+ * Text and background colors from a palette that follows the theme. The
+ * formatting toolbar gets a color menu; the text runs keep the names as
+ * `color` and `highlight`.
+ */
+export declare const colors: import("../..").EditorExtension;