@aicayzer/inkkit 0.0.17 → 0.1.0

package/dist/files.d.ts

@@ -1,40 +0,0 @@
-import type { DocumentContext, FileAdapter, FileContext, FilePresentation, FileReference } from './types.js';
-import type { EditorLabels } from './labels.js';
-export interface FileViewRuntime {
-    adapter: FileAdapter;
-    capture(): {
-        context: DocumentContext;
-        isCurrent(): boolean;
-    };
-    active(): boolean;
-    labels: Readonly<EditorLabels>;
-    error?(error: Error): void;
-}
-export declare function withFileSignal<T>(operation: Promise<T>, signal: AbortSignal): Promise<T>;
-export declare function resolveFile(adapter: FileAdapter, reference: FileReference, context: FileContext): Promise<FilePresentation>;
-export type FileResolutionState = {
-    status: 'idle';
-} | {
-    status: 'loading';
-} | {
-    status: 'resolved';
-    presentation: FilePresentation;
-} | {
-    status: 'failed';
-    error: Error;
-};
-export declare class FileResolution {
-    private readonly runtime;
-    private readonly changed;
-    state: FileResolutionState;
-    private reference?;
-    private key;
-    private request?;
-    private dead;
-    constructor(runtime: FileViewRuntime, changed: () => void);
-    update(reference: FileReference): void;
-    retry(): void;
-    private current;
-    cancel(): void;
-    destroy(): void;
-}

package/dist/files.js

@@ -1,133 +0,0 @@
-function abort(signal) {
-    if (signal.aborted)
-        throw new DOMException('File resolution cancelled', 'AbortError');
-}
-export function withFileSignal(operation, signal) {
-    return new Promise((resolve, reject) => {
-        const cleanup = () => signal.removeEventListener('abort', cancelled);
-        const cancelled = () => {
-            cleanup();
-            reject(new DOMException('File operation cancelled', 'AbortError'));
-        };
-        if (signal.aborted)
-            cancelled();
-        else
-            signal.addEventListener('abort', cancelled, { once: true });
-        operation.then((result) => {
-            cleanup();
-            if (signal.aborted)
-                cancelled();
-            else
-                resolve(result);
-        }, (error) => {
-            cleanup();
-            reject(error);
-        });
-    });
-}
-export async function resolveFile(adapter, reference, context) {
-    abort(context.signal);
-    const presentation = await withFileSignal(adapter.resolve(Object.freeze({ ...reference }), context), context.signal);
-    abort(context.signal);
-    if (!presentation ||
-        typeof presentation !== 'object' ||
-        !['image', 'audio', 'video', 'pdf', 'file', 'missing', 'error'].includes(presentation.kind))
-        throw new TypeError('File adapter returned an unsupported presentation');
-    if (presentation.label !== undefined &&
-        typeof presentation.label !== 'string')
-        throw new TypeError('File presentation label must be text');
-    if (presentation.kind === 'error' && typeof presentation.message !== 'string')
-        throw new TypeError('File presentation error must include a message');
-    if ('url' in presentation) {
-        if (typeof presentation.url !== 'string' || !presentation.url.trim())
-            throw new TypeError('File presentation needs a resource URL');
-        const url = new URL(presentation.url, document.baseURI);
-        if (['javascript:', 'vbscript:'].includes(url.protocol))
-            throw new TypeError('Executable file presentation URLs are not supported');
-        const prefix = presentation.kind === 'pdf' ? 'application/pdf' : `${presentation.kind}/`;
-        const mime = presentation.mimeType?.toLowerCase().split(';')[0]?.trim();
-        if (mime &&
-            (presentation.kind === 'pdf' ? mime !== prefix : !mime.startsWith(prefix)))
-            throw new TypeError('File presentation MIME type does not match its kind');
-        const dataMime = url.pathname.toLowerCase().split(/[;,]/)[0] ?? '';
-        if (url.protocol === 'data:' &&
-            (presentation.kind === 'pdf'
-                ? dataMime !== prefix
-                : !dataMime.startsWith(prefix)))
-            throw new TypeError('File presentation data URL does not match its kind');
-    }
-    else if (['image', 'audio', 'video', 'pdf'].includes(presentation.kind)) {
-        throw new TypeError('File presentation needs a resource URL');
-    }
-    return Object.freeze({ ...presentation });
-}
-export class FileResolution {
-    runtime;
-    changed;
-    state = { status: 'idle' };
-    reference;
-    key = '';
-    request;
-    dead = false;
-    constructor(runtime, changed) {
-        this.runtime = runtime;
-        this.changed = changed;
-    }
-    update(reference) {
-        const key = JSON.stringify([
-            reference.reference,
-            reference.kind,
-            reference.fragment,
-        ]);
-        this.reference = Object.freeze({ ...reference });
-        if (this.key === key && this.request?.isCurrent())
-            return;
-        this.key = key;
-        this.retry();
-    }
-    retry() {
-        this.cancel();
-        if (this.dead || !this.reference || !this.runtime.active())
-            return;
-        const captured = this.runtime.capture();
-        const request = {
-            controller: new AbortController(),
-            isCurrent: captured.isCurrent,
-        };
-        this.request = request;
-        this.state = { status: 'loading' };
-        this.changed();
-        void resolveFile(this.runtime.adapter, this.reference, {
-            ...captured.context,
-            signal: request.controller.signal,
-        }).then((presentation) => {
-            if (!this.current(request))
-                return;
-            this.state = { status: 'resolved', presentation };
-            this.changed();
-        }, (failure) => {
-            if (!this.current(request))
-                return;
-            const error = failure instanceof Error ? failure : new Error(String(failure));
-            this.state = { status: 'failed', error };
-            this.changed();
-            this.runtime.error?.(error);
-        });
-    }
-    current(request) {
-        return (!this.dead &&
-            this.request === request &&
-            !request.controller.signal.aborted &&
-            this.runtime.active() &&
-            request.isCurrent());
-    }
-    cancel() {
-        this.request?.controller.abort();
-        this.request = undefined;
-        this.state = { status: 'idle' };
-    }
-    destroy() {
-        this.dead = true;
-        this.cancel();
-    }
-}

package/dist/highlight.d.ts

@@ -1 +0,0 @@
-export declare const highlightPlugin: import("@milkdown/kit/utils").$Prose;

package/dist/highlight.js

@@ -1,136 +0,0 @@
-import { common, createLowlight } from 'lowlight';
-import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
-import { Decoration, DecorationSet } from '@milkdown/kit/prose/view';
-import { $prose } from '@milkdown/kit/utils';
-const lowlight = createLowlight(common);
-// Colors are decorations over the plain text, so the markdown is untouched;
-// a block without a known language stays plain.
-function blockDecorations(node, pos) {
-    const language = String(node.attrs.language ?? '').toLowerCase();
-    const found = [];
-    if (!language || !lowlight.registered(language))
-        return found;
-    let offset = pos + 1;
-    const walk = (children, classes) => {
-        for (const child of children) {
-            if (child.type === 'text') {
-                const end = offset + child.value.length;
-                if (classes.length > 0)
-                    found.push(Decoration.inline(offset, end, { class: classes.join(' ') }));
-                offset = end;
-            }
-            else if (child.type === 'element') {
-                const own = child.properties?.className ?? [];
-                walk(child.children, [...classes, ...own]);
-            }
-        }
-    };
-    walk(lowlight.highlight(language, node.textContent).children, []);
-    return found;
-}
-function decorations(doc) {
-    const found = [];
-    doc.descendants((node, pos) => {
-        if (!node.isTextblock)
-            return true;
-        if (node.type.name === 'code_block')
-            for (const decoration of blockDecorations(node, pos))
-                found.push(decoration);
-        return false;
-    });
-    return DecorationSet.create(doc, found);
-}
-// Every range of the new document an update may have touched: each step's own
-// range, plus the whole span where the two documents differ, which also covers
-// steps that change a node without changing its size.
-function touched(tr) {
-    const ranges = [];
-    tr.mapping.maps.forEach((map, index) => {
-        const rest = tr.mapping.slice(index + 1);
-        map.forEach((_, __, from, to) => ranges.push([rest.map(from, -1), rest.map(to, 1)]));
-    });
-    const start = tr.before.content.findDiffStart(tr.doc.content);
-    if (start != null) {
-        const end = tr.before.content.findDiffEnd(tr.doc.content);
-        // The scans overlap when inserted or deleted text repeats its neighbours.
-        if (end)
-            ranges.push([start, end.b + Math.max(0, start - Math.min(end.a, end.b))]);
-    }
-    return ranges;
-}
-// Mapping carries colors of unchanged blocks to their new positions without
-// reading them, but leaves stale colors inside any block that was edited. Those
-// blocks are highlighted again; no other block is. Stale colors are dropped by
-// rebuilding the set: DecorationSet.remove compares every removed decoration
-// with every other in its block, which is quadratic in a large block.
-function update(mapped, tr) {
-    const stale = [];
-    const fresh = [];
-    const seen = new Set();
-    for (const [from, to] of touched(tr)) {
-        let start = from;
-        let end = to;
-        const blocks = [];
-        tr.doc.nodesBetween(from, to, (node, pos) => {
-            if (!node.isTextblock)
-                return true;
-            start = Math.min(start, pos);
-            end = Math.max(end, pos + node.nodeSize);
-            if (node.type.name === 'code_block' && !seen.has(pos)) {
-                seen.add(pos);
-                blocks.push([node, pos]);
-            }
-            return false;
-        });
-        stale.push([start, end]);
-        for (const [node, pos] of blocks)
-            for (const decoration of blockDecorations(node, pos))
-                fresh.push(decoration);
-    }
-    const found = [];
-    for (const [start, end] of stale)
-        for (const decoration of mapped.find(start, end))
-            found.push(decoration);
-    if (found.length === 0)
-        return mapped.add(tr.doc, fresh);
-    // remove is quadratic in the decorations it removes, so only a large block takes the rebuild below.
-    if (found.length <= 256)
-        return mapped.remove(found).add(tr.doc, fresh);
-    stale.sort((a, b) => a[0] - b[0]);
-    const merged = [];
-    for (const range of stale) {
-        const last = merged.at(-1);
-        if (last && range[0] <= last[1])
-            last[1] = Math.max(last[1], range[1]);
-        else
-            merged.push([range[0], range[1]]);
-    }
-    const kept = mapped.find().filter((decoration) => {
-        let low = 0;
-        let high = merged.length;
-        while (low < high) {
-            const middle = (low + high) >> 1;
-            if (merged[middle][0] < decoration.to)
-                low = middle + 1;
-            else
-                high = middle;
-        }
-        const range = merged[low - 1];
-        return !range || range[1] <= decoration.from;
-    });
-    return DecorationSet.create(tr.doc, kept.concat(fresh));
-}
-export const highlightPlugin = $prose(() => new Plugin({
-    key: new PluginKey('highlight'),
-    state: {
-        init: (_, state) => decorations(state.doc),
-        apply: (tr, previous) => tr.docChanged
-            ? update(previous.map(tr.mapping, tr.doc), tr)
-            : previous,
-    },
-    props: {
-        decorations(state) {
-            return this.getState(state);
-        },
-    },
-}));

package/dist/image-blocks.d.ts

@@ -1,71 +0,0 @@
-import type { MilkdownPlugin } from '@milkdown/kit/ctx';
-import { type Node as ProseNode, type NodeType } from '@milkdown/kit/prose/model';
-import type { ParserState } from '@milkdown/kit/transformer';
-export declare const imageBlockName = "image_block";
-/** Attributes shared by an inline image and a standalone image block. */
-export declare const imageAttrs: {
-    src: {
-        default: string;
-        validate: string;
-    };
-    alt: {
-        default: string;
-        validate: string;
-    };
-    title: {
-        default: string;
-        validate: string;
-    };
-    inkkitFileRaw: {
-        default: null;
-    };
-    inkkitFileTarget: {
-        default: null;
-    };
-    inkkitFileFragment: {
-        default: null;
-    };
-    inkkitFileWidth: {
-        default: null;
-    };
-    inkkitFileInTable: {
-        default: boolean;
-    };
-};
-interface MarkdownParagraph {
-    children?: unknown[];
-    value?: unknown;
-}
-interface MarkdownImage {
-    type: string;
-    url?: unknown;
-    alt?: unknown;
-    title?: unknown;
-    inkkitFileRaw?: unknown;
-    inkkitFileTarget?: unknown;
-    inkkitFileFragment?: unknown;
-    inkkitFileWidth?: unknown;
-    inkkitFileInTable?: unknown;
-}
-export declare function markdownImageAttrs(node: MarkdownImage): {
-    src: string;
-    alt: string;
-    title: string;
-    inkkitFileRaw: {} | null;
-    inkkitFileTarget: {} | null;
-    inkkitFileFragment: {} | null;
-    inkkitFileWidth: {} | null;
-    inkkitFileInTable: {};
-};
-/** Whether a node displays an authored image, inline or as its own block. */
-export declare function isImage(node: ProseNode): boolean;
-export declare function isImageBlock(node: ProseNode | null | undefined): boolean;
-/** The image a paragraph holds as its only content, without marks, which makes the paragraph a
- *  standalone image block. A linked or emphasised image stays inline so its marks are kept. */
-export declare function standaloneImage(children: readonly ProseNode[]): ProseNode | undefined;
-/** Reads a Markdown paragraph, as an image block when it holds a standalone image and the enclosing
- *  block accepts one. */
-export declare function readParagraph(state: ParserState, node: MarkdownParagraph, paragraph: NodeType): void;
-export declare const imageBlockSchema: import("@milkdown/kit/utils").$NodeSchema<"image_block">;
-export declare const imageBlocks: MilkdownPlugin[];
-export {};

package/dist/image-blocks.js

@@ -1,286 +0,0 @@
-import { keydownHandler } from '@milkdown/kit/prose/keymap';
-import { GapCursor } from '@milkdown/kit/prose/gapcursor';
-import { Fragment, } from '@milkdown/kit/prose/model';
-import { NodeSelection, Plugin, PluginKey, Selection, TextSelection, } from '@milkdown/kit/prose/state';
-import { $nodeSchema, $prose } from '@milkdown/kit/utils';
-export const imageBlockName = 'image_block';
-/** Attributes shared by an inline image and a standalone image block. */
-export const imageAttrs = {
-    src: { default: '', validate: 'string' },
-    alt: { default: '', validate: 'string' },
-    title: { default: '', validate: 'string' },
-    inkkitFileRaw: { default: null },
-    inkkitFileTarget: { default: null },
-    inkkitFileFragment: { default: null },
-    inkkitFileWidth: { default: null },
-    inkkitFileInTable: { default: false },
-};
-// Remark represents a missing title as null; the image schema accepts strings.
-export function markdownImageAttrs(node) {
-    return {
-        src: String(node.url ?? ''),
-        alt: String(node.alt ?? ''),
-        title: String(node.title ?? ''),
-        inkkitFileRaw: node.inkkitFileRaw ?? null,
-        inkkitFileTarget: node.inkkitFileTarget ?? null,
-        inkkitFileFragment: node.inkkitFileFragment ?? null,
-        inkkitFileWidth: node.inkkitFileWidth ?? null,
-        inkkitFileInTable: node.inkkitFileInTable ?? false,
-    };
-}
-/** Whether a node displays an authored image, inline or as its own block. */
-export function isImage(node) {
-    return node.type.name === 'image' || node.type.name === imageBlockName;
-}
-export function isImageBlock(node) {
-    return node?.type.name === imageBlockName;
-}
-function accepts(parent, index, type) {
-    return parent.canReplaceWith(index, index + 1, type);
-}
-/** The image a paragraph holds as its only content, without marks, which makes the paragraph a
- *  standalone image block. A linked or emphasised image stays inline so its marks are kept. */
-export function standaloneImage(children) {
-    const [image] = children;
-    return children.length === 1 &&
-        image.type.name === 'image' &&
-        !image.marks.length
-        ? image
-        : undefined;
-}
-/** Reads a Markdown paragraph, as an image block when it holds a standalone image and the enclosing
- *  block accepts one. */
-export function readParagraph(state, node, paragraph) {
-    state.openNode(paragraph);
-    if (node.children)
-        state.next(node.children);
-    else
-        state.addText(String(node.value ?? ''));
-    const type = state.schema.nodes[imageBlockName];
-    const element = state.top();
-    const image = standaloneImage(element.content);
-    state.close();
-    const parent = state.top();
-    if (image &&
-        type &&
-        parent?.type.contentMatch
-            .matchFragment(Fragment.fromArray(parent.content))
-            ?.matchType(type))
-        state.addNode(type, image.attrs);
-    else {
-        state.openNode(paragraph);
-        for (const child of element.content)
-            state.top().push(child);
-        state.closeNode();
-    }
-}
-// A standalone image is a block with no inside, so no edit can put text beside it. In Markdown it
-// remains a paragraph holding the image, which is how it is read and written.
-export const imageBlockSchema = $nodeSchema(imageBlockName, () => ({
-    group: 'block',
-    atom: true,
-    selectable: true,
-    draggable: true,
-    marks: '',
-    attrs: imageAttrs,
-    toDOM: (node) => [
-        'p',
-        { class: 'inkkit-image-block' },
-        [
-            'img',
-            {
-                src: String(node.attrs.src),
-                alt: String(node.attrs.alt),
-                title: String(node.attrs.title),
-            },
-        ],
-    ],
-    parseMarkdown: { match: () => false, runner: () => undefined },
-    toMarkdown: {
-        match: (node) => node.type.name === imageBlockName,
-        runner: (state, node) => {
-            state.openNode('paragraph');
-            state.next(node.type.schema.nodes.image.create(node.attrs));
-            state.closeNode();
-        },
-    },
-}));
-// An edit can leave a paragraph holding only an image, which reading its Markdown again would give
-// as an image block. The caret keeps its side of the image.
-const normalise = $prose(() => new Plugin({
-    key: new PluginKey('inkkitImageBlockNormalise'),
-    appendTransaction(transactions, old, state) {
-        const type = state.schema.nodes[imageBlockName];
-        if (!type || !transactions.some((tr) => tr.docChanged))
-            return null;
-        // Compare the documents, as mark and attribute steps change no positions.
-        const start = old.doc.content.findDiffStart(state.doc.content);
-        const end = old.doc.content.findDiffEnd(state.doc.content);
-        if (start == null || !end)
-            return null;
-        const found = new Map();
-        state.doc.nodesBetween(Math.min(start, end.b), Math.max(start, end.b), (node, pos, parent, index) => {
-            if (!node.isTextblock)
-                return true;
-            const children = [];
-            node.forEach((child) => children.push(child));
-            if (node.type.name === 'paragraph' &&
-                standaloneImage(children) &&
-                parent &&
-                accepts(parent, index, type))
-                found.set(pos, node);
-            return false;
-        });
-        if (!found.size)
-            return null;
-        const tr = state.tr;
-        const { head } = state.selection;
-        let caret;
-        for (const [pos, node] of [...found].sort(([a], [b]) => b - a)) {
-            const end = pos + node.nodeSize;
-            if (head > pos && head < end)
-                caret = head > pos + 1 ? { pos: end, side: 1 } : { pos, side: -1 };
-            tr.replaceWith(pos, end, type.create(node.firstChild.attrs));
-        }
-        if (caret)
-            tr.setSelection(new GapCursor(tr.doc.resolve(tr.mapping.map(caret.pos, caret.side))));
-        return tr;
-    },
-}));
-/** The image block a selection rests beside or selects, as the position for a new paragraph. */
-function newParagraphAt(state) {
-    const { selection } = state;
-    if (selection instanceof NodeSelection && isImageBlock(selection.node))
-        return selection.to;
-    if (selection instanceof GapCursor &&
-        (isImageBlock(selection.$head.nodeBefore) ||
-            isImageBlock(selection.$head.nodeAfter)))
-        return selection.head;
-    return undefined;
-}
-/** Opens an empty paragraph beside a selected image block, or at a gap beside one. */
-function openParagraph(state) {
-    const pos = newParagraphAt(state);
-    const paragraph = state.schema.nodes.paragraph;
-    if (pos == null || !paragraph)
-        return undefined;
-    const $pos = state.doc.resolve(pos);
-    if (!accepts($pos.parent, $pos.index(), paragraph))
-        return undefined;
-    const tr = state.tr.insert(pos, paragraph.create());
-    return tr.setSelection(TextSelection.create(tr.doc, pos + 1));
-}
-const enter = (state, dispatch) => {
-    const tr = openParagraph(state);
-    if (!tr)
-        return false;
-    dispatch?.(tr.scrollIntoView());
-    return true;
-};
-/** Backspace or Delete toward an image block selects it before anything is deleted; from a gap beside
- *  one toward text, the caret moves into the text. An empty paragraph next to one is removed. */
-function towardImage(dir) {
-    return (state, dispatch) => {
-        const { selection, doc } = state;
-        if (!selection.empty)
-            return false;
-        const $head = selection.$head;
-        if (selection instanceof GapCursor) {
-            const node = dir < 0 ? $head.nodeBefore : $head.nodeAfter;
-            const other = dir < 0 ? $head.nodeAfter : $head.nodeBefore;
-            if (!node || !(isImageBlock(other) || isImageBlock(node)))
-                return false;
-            const next = isImageBlock(node)
-                ? NodeSelection.create(doc, dir < 0 ? $head.pos - 1 : $head.pos)
-                : Selection.findFrom($head, dir, true);
-            if (!next)
-                return false;
-            dispatch?.(state.tr.setSelection(next).scrollIntoView());
-            return true;
-        }
-        if (!$head.parent.isTextblock || $head.depth === 0)
-            return false;
-        const atEdge = dir < 0
-            ? $head.parentOffset === 0
-            : $head.parentOffset === $head.parent.content.size;
-        if (!atEdge)
-            return false;
-        const index = $head.index(-1) + dir;
-        const parent = $head.node(-1);
-        const neighbour = index >= 0 && index < parent.childCount ? parent.child(index) : undefined;
-        if (!isImageBlock(neighbour))
-            return false;
-        const block = dir < 0 ? $head.before() - 1 : $head.after();
-        // An empty paragraph goes, unless its parent needs it, such as a list item's first line.
-        if ($head.parent.content.size === 0 &&
-            $head.parent.type.name === 'paragraph' &&
-            parent.canReplace($head.index(-1), $head.index(-1) + 1)) {
-            const tr = state.tr.delete($head.before(), $head.after());
-            dispatch?.(tr
-                .setSelection(new GapCursor(tr.doc.resolve($head.before())))
-                .scrollIntoView());
-            return true;
-        }
-        if (!dispatch)
-            return true;
-        dispatch(state.tr.setSelection(NodeSelection.create(doc, block)).scrollIntoView());
-        return true;
-    };
-}
-const keys = keydownHandler({
-    Enter: enter,
-    'Shift-Enter': enter,
-    Backspace: towardImage(-1),
-    Delete: towardImage(1),
-});
-const interaction = $prose(() => new Plugin({
-    key: new PluginKey('inkkitImageBlocks'),
-    props: {
-        handleKeyDown: (view, event) => !view.composing && view.editable && keys(view, event),
-        handleTextInput(view, _from, _to, text) {
-            const tr = openParagraph(view.state);
-            if (!tr)
-                return false;
-            view.dispatch(tr.insertText(text).scrollIntoView());
-            return true;
-        },
-        // A click beside an image card, not on it, puts the caret after the image.
-        handleClickOn(view, _pos, node, nodePos, event, direct) {
-            if (!direct ||
-                !view.editable ||
-                !isImageBlock(node) ||
-                !(event.target instanceof Element) ||
-                event.target.closest('.image'))
-                return false;
-            view.dispatch(view.state.tr.setSelection(new GapCursor(view.state.doc.resolve(nodePos + node.nodeSize))));
-            return true;
-        },
-        handleDOMEvents: {
-            // ProseMirror replaces a selection when composition starts; a selected image is kept and
-            // the composed text goes after it.
-            compositionstart(view) {
-                const { selection } = view.state;
-                if (view.editable &&
-                    selection instanceof NodeSelection &&
-                    isImageBlock(selection.node))
-                    view.dispatch(view.state.tr.setSelection(new GapCursor(view.state.doc.resolve(selection.to))));
-                return false;
-            },
-            // Composed text needs a paragraph to land in before the browser writes it, as the gap
-            // cursor plugin does for its own gaps.
-            beforeinput(view, event) {
-                if (event.inputType !== 'insertCompositionText' || !view.editable)
-                    return false;
-                const tr = openParagraph(view.state);
-                if (tr)
-                    view.dispatch(tr);
-                return false;
-            },
-        },
-    },
-}));
-export const imageBlocks = [
-    imageBlockSchema,
-    normalise,
-    interaction,
-].flat();