@aicayzer/inkkit 0.0.6 → 0.0.7

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { InkKitEditor } from './editor.js';
-export type { EditorEvents, CaretState, Mark, Block, FormatCommand, Keymap, } from './editor.js';
+export type { EditorEvents, EditingMode, CaretState, Mark, Block, FormatCommand, Keymap, } from './editor.js';
 export type { TableCommand, TableOptions } from './tables.js';
+export type { Heading } from './outline.js';
 export { InkKitError } from './types.js';
 export type { DocumentFormat, DocumentContext, DocumentInput, DocumentSnapshot, EditorErrorCode, ImageAdapter, CapturedImage, PortableImage, ClipboardInput, ClipboardOutput, ClipboardImage, ClipboardDiagram, PrintableDocument, PrintableWarning, } from './types.js';

package/dist/outline.d.ts

@@ -0,0 +1,22 @@
+import type { Ctx } from '@milkdown/kit/ctx';
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+import type { EditorView } from '@milkdown/kit/prose/view';
+export interface Heading {
+    readonly id: string;
+    readonly level: number;
+    readonly text: string;
+    readonly documentId: string;
+    readonly generation: number;
+    readonly revision: number;
+}
+export interface OutlineContext {
+    documentId: string;
+    generation: number;
+    revision: number;
+    epoch: number;
+    mode: 'source' | 'formatted';
+}
+export declare function collectFormattedHeadings(doc: ProseNode, context: OutlineContext): readonly Heading[];
+export declare function collectSourceHeadings(ctx: Ctx, source: string, context: OutlineContext): readonly Heading[];
+export declare function sourceHeadingPosition(ctx: Ctx, source: string, requested: Heading, context: OutlineContext): number;
+export declare function navigateFormattedHeading(view: EditorView, requested: Heading, context: OutlineContext): boolean;

package/dist/outline.js

@@ -0,0 +1,79 @@
+import { parserCtx, remarkCtx } from '@milkdown/kit/core';
+import { TextSelection } from '@milkdown/kit/prose/state';
+import { clipboardText } from './clipboard.js';
+import { revealCalloutAncestors } from './callouts.js';
+import { InkKitError } from './types.js';
+function formattedLocations(doc) {
+    const headings = [];
+    doc.descendants((node, position) => {
+        if (node.type.name === 'heading')
+            headings.push({ node, position });
+    });
+    return headings;
+}
+function sourceLocations(ctx, source) {
+    const processor = ctx.get(remarkCtx);
+    const tree = processor.runSync(processor.parse(source), {
+        value: source,
+    });
+    const positions = [];
+    const bom = source.startsWith('\uFEFF') ? 1 : 0;
+    const visit = (node) => {
+        if (node.type === 'heading' && node.position?.start.offset != null)
+            positions.push({
+                position: node.position.start.offset + bom,
+                level: node.depth,
+            });
+        node.children?.forEach(visit);
+    };
+    visit(tree);
+    const parsed = formattedLocations(ctx.get(parserCtx)(source));
+    if (positions.length !== parsed.length ||
+        positions.some((item, index) => item.level !== parsed[index].node.attrs.level))
+        throw new InkKitError('preservation', 'The current Markdown headings cannot be located safely');
+    return parsed.map((heading, index) => ({
+        ...heading,
+        position: positions[index].position,
+    }));
+}
+function entry(heading, context) {
+    return Object.freeze({
+        id: `heading:${context.epoch}:${context.mode}:${context.generation}:${context.revision}:${heading.position}`,
+        level: Number(heading.node.attrs.level),
+        text: clipboardText(heading.node.content),
+        documentId: context.documentId,
+        generation: context.generation,
+        revision: context.revision,
+    });
+}
+export function collectFormattedHeadings(doc, context) {
+    return Object.freeze(formattedLocations(doc).map((item) => entry(item, context)));
+}
+export function collectSourceHeadings(ctx, source, context) {
+    return Object.freeze(sourceLocations(ctx, source).map((item) => entry(item, context)));
+}
+function currentLocation(locations, requested, context) {
+    for (const location of locations) {
+        const current = entry(location, context);
+        if (current.id === requested.id &&
+            current.documentId === requested.documentId &&
+            current.generation === requested.generation &&
+            current.revision === requested.revision &&
+            current.level === requested.level &&
+            current.text === requested.text)
+            return location.position;
+    }
+    throw new InkKitError('stale-document', 'The heading is no longer current');
+}
+export function sourceHeadingPosition(ctx, source, requested, context) {
+    return currentLocation(sourceLocations(ctx, source), requested, context);
+}
+export function navigateFormattedHeading(view, requested, context) {
+    const position = currentLocation(formattedLocations(view.state.doc), requested, context);
+    revealCalloutAncestors(view, position + 1);
+    view.dispatch(view.state.tr
+        .setSelection(TextSelection.create(view.state.doc, position + 1))
+        .scrollIntoView());
+    view.focus();
+    return true;
+}

package/dist/search.d.ts

@@ -0,0 +1,14 @@
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+import type { EditorView } from '@milkdown/kit/prose/view';
+export interface TextMatch {
+    from: number;
+    to: number;
+}
+export interface LiteralReplacement extends TextMatch {
+    text: string;
+    count: number;
+}
+export declare function findLiteral(text: string, search: string, from?: number): TextMatch | undefined;
+export declare function replaceLiteral(text: string, search: string, replacement: string, selection: TextMatch, all?: boolean): LiteralReplacement;
+export declare function findFormatted(view: EditorView, text: string): void;
+export declare function replaceFormatted(view: EditorView, search: string, replacement: string, preflight: (doc: ProseNode) => void, all?: boolean): number;

package/dist/search.js

@@ -0,0 +1,171 @@
+import { Fragment, Slice } from '@milkdown/kit/prose/model';
+import { closeHistory } from '@milkdown/kit/prose/history';
+import { Selection, TextSelection } from '@milkdown/kit/prose/state';
+import { SearchQuery, setSearchState, getSearchState } from 'prosemirror-search';
+import { InkKitError } from './types.js';
+function escapedPattern(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function literalMatches(text, search) {
+    if (!search)
+        return [];
+    const pattern = new RegExp(escapedPattern(search), 'giu');
+    return [...text.matchAll(pattern)].map((match) => ({
+        from: match.index,
+        to: match.index + match[0].length,
+    }));
+}
+export function findLiteral(text, search, from = 0) {
+    const matches = literalMatches(text, search);
+    return matches.find((match) => match.from >= from) ?? matches[0];
+}
+export function replaceLiteral(text, search, replacement, selection, all = false) {
+    const matches = literalMatches(text, search);
+    const selected = matches.find((match) => match.from === selection.from && match.to === selection.to) ??
+        matches.find((match) => match.from >= selection.to) ??
+        matches[0];
+    const changed = (all ? matches : selected ? [selected] : []).filter((match) => text.slice(match.from, match.to) !== replacement);
+    if (!changed.length)
+        return { ...selection, text, count: 0 };
+    let output = text;
+    for (const match of [...changed].reverse())
+        output = output.slice(0, match.from) + replacement + output.slice(match.to);
+    if (!all)
+        return {
+            text: output,
+            count: 1,
+            from: changed[0].from,
+            to: changed[0].from + replacement.length,
+        };
+    const map = (position) => {
+        let difference = 0;
+        for (const match of changed) {
+            if (position < match.from)
+                break;
+            if (position <= match.to)
+                return (match.from +
+                    difference +
+                    (position === match.from ? 0 : replacement.length));
+            difference += replacement.length - (match.to - match.from);
+        }
+        return position + difference;
+    };
+    return {
+        text: output,
+        count: changed.length,
+        from: map(selection.from),
+        to: map(selection.to),
+    };
+}
+function formattedQuery(text) {
+    // Unicode regexp matching retains offsets when lowercasing would expand a character.
+    return new SearchQuery({
+        search: escapedPattern(text),
+        regexp: true,
+        literal: true,
+        filter: (state, match) => {
+            const from = state.doc.resolve(match.from);
+            const to = state.doc.resolve(match.to);
+            if (from.parent !== to.parent || !from.parent.inlineContent)
+                return false;
+            const content = state.doc.slice(match.from, match.to).content;
+            let textOnly = true;
+            content.forEach((node) => {
+                if (!node.isText)
+                    textOnly = false;
+            });
+            return textOnly;
+        },
+    });
+}
+export function findFormatted(view, text) {
+    const query = formattedQuery(text);
+    const previous = getSearchState(view.state)?.query.search;
+    let tr = setSearchState(view.state.tr, query);
+    if (text) {
+        const start = previous === query.search
+            ? view.state.selection.to
+            : view.state.selection.from;
+        const match = query.findNext(view.state, start) ?? query.findNext(view.state, 0);
+        if (match)
+            tr = tr
+                .setSelection(TextSelection.create(tr.doc, match.from, match.to))
+                .scrollIntoView();
+        else
+            tr = tr.setSelection(Selection.near(view.state.selection.$to));
+    }
+    else if (previous)
+        tr = tr.setSelection(Selection.near(view.state.selection.$to));
+    view.dispatch(tr);
+}
+export function replaceFormatted(view, search, replacement, preflight, all = false) {
+    if (!search)
+        return 0;
+    const state = view.state;
+    const query = formattedQuery(search);
+    if (!query.valid)
+        return 0;
+    const matches = [];
+    if (all) {
+        for (let position = 0;;) {
+            const match = query.findNext(state, position);
+            if (!match)
+                break;
+            matches.push(match);
+            position = match.to;
+        }
+    }
+    else {
+        const selection = state.selection;
+        const current = query.findNext(state, selection.from, selection.to);
+        const match = (current?.from === selection.from && current.to === selection.to
+            ? current
+            : undefined) ??
+            query.findNext(state, selection.to) ??
+            query.findNext(state, 0);
+        if (match)
+            matches.push(match);
+    }
+    const value = replacement.replace(/\r\n?/g, '\n');
+    const changed = matches.filter((match) => state.doc.textBetween(match.from, match.to) !== value);
+    if (!changed.length)
+        return 0;
+    let tr = setSearchState(state.tr, query);
+    for (const match of [...changed].reverse()) {
+        const from = state.doc.resolve(match.from);
+        const to = state.doc.resolve(match.to);
+        const marks = from.marksAcross(to) ?? from.marks();
+        let content = Fragment.empty;
+        if (from.parent.type.spec.code) {
+            if (value)
+                content = Fragment.from(state.schema.text(value, marks));
+        }
+        else {
+            const nodes = [];
+            const lines = value.split('\n');
+            lines.forEach((line, index) => {
+                if (index)
+                    nodes.push(state.schema.nodes.hardbreak.create({ isHTML: index === lines.length - 1 && line === '' }, null, marks));
+                if (line)
+                    nodes.push(state.schema.text(line, marks));
+            });
+            content = Fragment.fromArray(nodes);
+        }
+        tr.replace(match.from, match.to, new Slice(content, 0, 0));
+    }
+    if (!all) {
+        const match = changed[0];
+        tr = tr.setSelection(TextSelection.create(tr.doc, match.from, tr.mapping.map(match.to, 1)));
+    }
+    try {
+        preflight(tr.doc);
+    }
+    catch (error) {
+        if (error instanceof InkKitError)
+            throw error;
+        throw new InkKitError('preservation', error instanceof Error ? error.message : 'Cannot preserve replacement');
+    }
+    view.dispatch(closeHistory(tr).scrollIntoView());
+    view.dispatch(closeHistory(view.state.tr).setMeta('addToHistory', false));
+    return changed.length;
+}

package/dist/source.d.ts

@@ -0,0 +1,17 @@
+import type { Node as ProseNode } from '@milkdown/kit/prose/model';
+export declare const sourceAttribute = "inkkitSource";
+export interface SourceProvenance {
+    readonly text: string;
+    readonly format: 'md' | 'txt';
+    readonly from: number;
+    readonly to: number;
+}
+export declare function cleanSourceDoc(doc: ProseNode): ProseNode;
+export declare function rawOffset(source: string, normalized: number): number;
+export declare function normalizedOffset(source: string, raw: number): number;
+export declare function editedPlainSource(previous: string, value: string): string;
+export declare function sourceSelection(source: string, start: number, end: number): {
+    markdown: string;
+    shareable: string;
+};
+export declare function revealSourceCaret(plain: HTMLTextAreaElement): void;

package/dist/source.js

@@ -0,0 +1,117 @@
+import { literalCommentSpans } from './comments.js';
+export const sourceAttribute = 'inkkitSource';
+export function cleanSourceDoc(doc) {
+    return doc.attrs[sourceAttribute] == null
+        ? doc
+        : doc.type.create({ ...doc.attrs, [sourceAttribute]: null }, doc.content);
+}
+export function rawOffset(source, normalized) {
+    let position = 0, count = 0;
+    while (position < source.length && count < normalized) {
+        if (source[position] === '\r' && source[position + 1] === '\n')
+            position++;
+        position++;
+        count++;
+    }
+    return position;
+}
+export function normalizedOffset(source, raw) {
+    return source.slice(0, raw).replace(/\r\n?/g, '\n').length;
+}
+export function editedPlainSource(previous, value) {
+    const normalized = previous.replace(/\r\n?/g, '\n');
+    if (normalized === value)
+        return previous;
+    let prefix = 0, suffix = 0;
+    while (prefix < normalized.length &&
+        prefix < value.length &&
+        normalized[prefix] === value[prefix])
+        prefix++;
+    while (suffix < normalized.length - prefix &&
+        suffix < value.length - prefix &&
+        normalized[normalized.length - suffix - 1] ===
+            value[value.length - suffix - 1])
+        suffix++;
+    const ending = /\r\n|\r|\n/.exec(previous)?.[0] ?? '\n';
+    return (previous.slice(0, rawOffset(previous, prefix)) +
+        value
+            .slice(prefix, value.length - suffix)
+            .replace(/\r\n?/g, '\n')
+            .replaceAll('\n', ending) +
+        previous.slice(rawOffset(previous, normalized.length - suffix)));
+}
+export function sourceSelection(source, start, end) {
+    const from = rawOffset(source, start), to = rawOffset(source, end);
+    let shareable = '', cursor = from;
+    const bom = source.startsWith('\uFEFF') ? 1 : 0;
+    for (const parsed of literalCommentSpans(source.slice(bom))) {
+        const span = { start: parsed.start + bom, end: parsed.end + bom };
+        if (span.end <= from || span.start >= to)
+            continue;
+        if (span.start > cursor)
+            shareable += source.slice(cursor, Math.min(span.start, to));
+        cursor = Math.max(cursor, Math.min(span.end, to));
+    }
+    shareable += source.slice(cursor, to);
+    return { markdown: source.slice(from, to), shareable };
+}
+export function revealSourceCaret(plain) {
+    if (!plain.clientWidth || !plain.clientHeight)
+        return;
+    const document = plain.ownerDocument;
+    const style = document.defaultView.getComputedStyle(plain);
+    const mirror = document.createElement('div');
+    for (const property of [
+        'font',
+        'font-family',
+        'font-size',
+        'font-weight',
+        'font-style',
+        'font-stretch',
+        'font-variant',
+        'line-height',
+        'letter-spacing',
+        'word-spacing',
+        'tab-size',
+        'padding',
+        'text-indent',
+        'text-transform',
+        'direction',
+        'word-break',
+    ])
+        mirror.style.setProperty(property, style.getPropertyValue(property));
+    Object.assign(mirror.style, {
+        position: 'fixed',
+        visibility: 'hidden',
+        left: '-10000px',
+        top: '0',
+        width: `${plain.clientWidth}px`,
+        boxSizing: 'border-box',
+        whiteSpace: plain.wrap === 'off' ? 'pre' : 'pre-wrap',
+        overflowWrap: plain.wrap === 'off' ? 'normal' : 'break-word',
+    });
+    mirror.setAttribute('aria-hidden', 'true');
+    const caret = document.createElement('span');
+    caret.setAttribute('data-inkkit-source-caret', '');
+    caret.textContent = plain.value.slice(plain.selectionStart) || '\u200b';
+    mirror.append(document.createTextNode(plain.value.slice(0, plain.selectionStart)), caret);
+    document.body.append(mirror);
+    try {
+        // Textareas expose selection offsets but no caret geometry; matching their layout also accounts for wrapped lines.
+        const rect = caret.getClientRects()[0] ?? caret.getBoundingClientRect();
+        const top = rect.top - mirror.getBoundingClientRect().top;
+        const lineHeight = Math.max(rect.height, Number.parseFloat(style.lineHeight) || rect.height);
+        const insetTop = Number.parseFloat(style.paddingTop) || 0;
+        const insetBottom = Number.parseFloat(style.paddingBottom) || 0;
+        if (plain.selectionStart === 0)
+            plain.scrollTop = 0;
+        else if (top < plain.scrollTop + insetTop)
+            plain.scrollTop = Math.max(0, top - insetTop);
+        else if (top + lineHeight >
+            plain.scrollTop + plain.clientHeight - insetBottom)
+            plain.scrollTop = Math.max(0, top + lineHeight - plain.clientHeight + insetBottom);
+    }
+    finally {
+        mirror.remove();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicayzer/inkkit",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "A preserving Markdown editor for offline web views and the web",
   "license": "MIT",
   "type": "module",