@aicayzer/inkkit 0.0.5 → 0.0.7

package/README.md

@@ -35,6 +35,8 @@ const snapshot = editor.snapshot(1)
 
 Markdown includes CommonMark, task lists, strikethrough, autolinks, GFM tables, editable footnotes and reference-style links, bounded callouts, highlights, author comments and offline Mermaid diagrams. Unsupported constructs remain literal Markdown. TXT mode treats all text literally. Images require a host adapter. RTF files remain outside the package scope.
 
+Table controls include complete row/column movement and explicit stable text or numeric sorting. Ordinary spreadsheet paste preserves cell boundaries, replaces selected cells and grows supported tables. Hosts call these operations through the public facade; each is undoable.
+
 `await editor.printableSnapshot(1)` returns a complete printable HTML document, print styles and portable image bytes. It excludes author comments, includes folded content and reports unavailable assets or a changed document. Client apps own Print/PDF commands, dialogs and file generation.
 
 See [supported syntax](docs/supported-syntax.md), [the host API](docs/api.md), [preservation and clipboard behavior](docs/preservation.md), [development](docs/development.md), and [releases](docs/releasing.md).
@@ -42,3 +44,5 @@ See [supported syntax](docs/supported-syntax.md), [the host API](docs/api.md), [
 Delivery scope and release status are tracked in the [InkKit Project](https://github.com/users/aicayzer/projects/3) and [milestones](https://github.com/aicayzer/inkkit/milestones).
 
 MIT licensed. InkKit builds on the public PadPad and Memos editors; see [NOTICE](NOTICE).
+
+Complete source/formatted editing, literal find/replace and replace-all, and current ordered headings/navigation are available through the public facade. Mode switching keeps document identity and history; unsupported or incomplete source and TXT remain saveable. Hosts own the editing controls and outline presentation. See the [API contracts](docs/api.md).

package/dist/callouts.d.ts

@@ -1,3 +1,4 @@
+import type { EditorView } from '@milkdown/kit/prose/view';
 import type { Parent, RootContent } from 'mdast';
 interface Callout extends Parent {
     type: 'inkkitCallout';
@@ -17,6 +18,7 @@ declare module 'mdast' {
         inkkitCallout: Callout;
     }
 }
+export declare function revealCalloutAncestors(view: EditorView, position: number): void;
 export declare const remarkCalloutsPlugin: import("@milkdown/kit/utils").$Remark<"inkkitCallouts", unknown>;
 export declare const calloutSchema: import("@milkdown/kit/utils").$Node;
 export declare const calloutView: import("@milkdown/kit/utils").$Prose;

package/dist/callouts.js

@@ -3,6 +3,17 @@ import { remarkCtx } from '@milkdown/kit/core';
 import { Plugin, PluginKey } from '@milkdown/kit/prose/state';
 import { defaultHandlers } from 'mdast-util-to-markdown';
 const kinds = new Set(['NOTE', 'TIP', 'IMPORTANT', 'WARNING', 'CAUTION']);
+export function revealCalloutAncestors(view, position) {
+    const node = view.domAtPos(position).node;
+    let element = node instanceof HTMLElement ? node : node.parentElement;
+    while (element && element !== view.dom) {
+        if (element.getAttribute('data-inkkit-folded') === 'true')
+            element
+                .querySelector(':scope > .inkkit-callout-header > [data-inkkit-callout-toggle]')
+                ?.click();
+        element = element.parentElement;
+    }
+}
 function plainHeader(processor, source) {
     const node = processor.parse(source).children[0];
     return node?.type === 'paragraph' &&

package/dist/dialect.js

@@ -1,8 +1,10 @@
 import { editorViewCtx, serializerCtx } from '@milkdown/kit/core';
-import { commonmark, hardbreakSchema, imageSchema, paragraphSchema, remarkInlineLinkPlugin, } from '@milkdown/kit/preset/commonmark';
+import { commonmark, docSchema, hardbreakSchema, imageSchema, paragraphSchema, remarkInlineLinkPlugin, } from '@milkdown/kit/preset/commonmark';
 import { extendListItemSchemaForTask, strikethroughAttr, strikethroughInputRule, strikethroughKeymap, strikethroughSchema, toggleStrikethroughCommand, wrapInTaskListInputRule, tableSchema, tableHeaderRowSchema, tableHeaderSchema, tableRowSchema, tableCellSchema, tableEditingPlugin, tableKeymap, goToNextTableCellCommand, goToPrevTableCellCommand, insertTableCommand, addRowBeforeCommand, addRowAfterCommand, addColBeforeCommand, addColAfterCommand, selectRowCommand, selectColCommand, deleteSelectedCellsCommand, setAlignCommand, exitTable, } from '@milkdown/kit/preset/gfm';
-import { $remark } from '@milkdown/kit/utils';
+import { $node, $remark } from '@milkdown/kit/utils';
 import { autolinkInputRule } from './autolink.js';
+import { sourceAttribute } from './source.js';
+import { normalizeTableAlignment, normalizeTableColumnAlignment, } from './table-alignment.js';
 import { preservingCodeBlocks, remarkCodeFences, fencedCodeHandler, } from './code-fences.js';
 import { literalBlock, createLiteralPreservation } from './literals.js';
 import { references, remarkReferencesPlugin } from './references.js';
@@ -86,6 +88,17 @@ function remarkDialect() {
     add('toMarkdownExtensions', gfmTaskListItemToMarkdown());
     add('toMarkdownExtensions', gfmAutolinkLiteralToMarkdown());
     add('toMarkdownExtensions', gfmTableToMarkdown());
+    add('toMarkdownExtensions', {
+        handlers: {
+            text(node, parent, state, info) {
+                const value = defaultHandlers.text(node, parent, state, info);
+                // GFM trims literal whitespace at cell edges on reopening.
+                return state.stack.includes('tableCell')
+                    ? value.replace(/^[ \t]+|[ \t]+$/g, (spaces) => spaces.replaceAll(' ', ' ').replaceAll('\t', '	'))
+                    : value;
+            },
+        },
+    });
     add('toMarkdownExtensions', { handlers: { link, code: fencedCodeHandler } });
 }
 export const remarkDialectPlugin = $remark('remarkDialect', () => remarkDialect);
@@ -209,7 +222,7 @@ export const tables = [
                             return false;
                         return {
                             ...attrs,
-                            alignment: dom.style.textAlign || dom.getAttribute('align') || null,
+                            alignment: normalizeTableAlignment(dom),
                         };
                     },
                 }
@@ -231,7 +244,7 @@ export const tables = [
                             return false;
                         return {
                             ...attrs,
-                            alignment: dom.style.textAlign || dom.getAttribute('align') || null,
+                            alignment: normalizeTableColumnAlignment(dom),
                         };
                     },
                 }
@@ -262,6 +275,13 @@ export function createDialect(images) {
         // Protect unsupported inline HTML before the empty-line plugin consumes break nodes.
         createLiteralPreservation(images),
         commonmarkWithLiteralReferences,
+        $node('doc', () => ({
+            ...docSchema.schema,
+            attrs: {
+                ...docSchema.schema.attrs,
+                [sourceAttribute]: { default: null },
+            },
+        })),
         references,
         callouts,
         comments,

package/dist/editor.d.ts

@@ -1,5 +1,6 @@
-import { type TableCommand } from './tables.js';
+import { type TableCommand, type TableOptions } from './tables.js';
 import { type DocumentInput, type DocumentSnapshot, type ImageAdapter, type ClipboardInput, type ClipboardOutput, type PrintableDocument } from './types.js';
+import { type Heading } from './outline.js';
 export type Mark = 'bold' | 'italic' | 'strikethrough' | 'highlight' | 'code' | 'link';
 export type Block = {
     type: 'paragraph';
@@ -15,6 +16,7 @@ export type Block = {
 } | {
     type: 'taskList';
 };
+export type EditingMode = 'source' | 'formatted';
 export interface CaretState {
     marks: Mark[];
     block: Block;
@@ -37,7 +39,6 @@ export declare class InkKitEditor {
     private readonly options;
     private editor;
     private lastMarkdown;
-    private baseline;
     private documentId;
     private formatType;
     private revision;
@@ -45,6 +46,11 @@ export declare class InkKitEditor {
     private operationSequence;
     private plainComposing;
     private plainSearch;
+    private literalMatch?;
+    private beforePlainInput?;
+    private mode;
+    private sourcePreservations;
+    private outlineEpoch;
     private ready;
     private destroyed;
     private preservation?;
@@ -63,26 +69,39 @@ export declare class InkKitEditor {
     private context;
     private assertAlive;
     private assertCurrent;
-    private plainSource;
+    private get literalSurface();
+    get editingMode(): EditingMode;
+    private currentText;
+    setEditingMode(mode: EditingMode, expectedGeneration?: number): boolean;
+    private updateSurface;
+    replaceSource(text: string, expectedGeneration?: number): boolean;
+    private applySource;
+    undo(expectedGeneration?: number): boolean;
+    redo(expectedGeneration?: number): boolean;
+    private replaceLiteralSelection;
     snapshot(expectedGeneration?: number): DocumentSnapshot;
     printableSnapshot(expectedGeneration?: number): Promise<PrintableDocument>;
     clipboardSnapshot(all?: boolean): Promise<ClipboardOutput>;
     paste(input: ClipboardInput): Promise<void>;
     setCommentsVisible(visible: boolean): void;
     pasteAsPlainText(text: string): void;
-    table(command: TableCommand, options?: {
-        rows?: number;
-        columns?: number;
-    }): boolean;
+    table(command: TableCommand, options?: TableOptions): boolean;
     destroy(): Promise<void>;
     private keymapPlugin;
+    private copySourceSelection;
     static mount(root: HTMLElement, events: EditorEvents, options?: {
         images?: ImageAdapter;
     }): Promise<InkKitEditor>;
     loadDocument(input: DocumentInput): void;
     reloadDocument(input: DocumentInput): void;
     private load;
-    find(text: string): void;
+    find(text: string, expectedGeneration?: number): void;
+    replace(search: string, replacement: string, expectedGeneration?: number): boolean;
+    replaceAll(search: string, replacement: string, expectedGeneration?: number): number;
+    private replaceMatches;
+    private outlineContext;
+    headings(expectedGeneration?: number): readonly Heading[];
+    navigateHeading(heading: Heading): boolean;
     /** Buffered native typing follows the same input rules as direct typing. */
     insertText(text: string, generation: number): boolean;
     /** Let existing keymaps handle buffered editing commands before native fallback. */