@quillmark/svelte 0.19.0 → 0.20.0

package/dist/core/codec/schema.js

@@ -6,14 +6,16 @@
 // single-textblock form for `richtext(inline)` (one paragraph, no block split, no
 // containers, no islands) and `plaintextSchema` is that one without marks, for
 // `plaintext(inline)`; `plainSchema` is a `plaintext` field without `inline`,
-// paragraphs and hard breaks and nothing else. Same decode/lower/position machinery,
+// paragraphs and hard breaks and nothing else; `cellSchema` is the inline form with
+// hard breaks, for a table cell. Same decode/lower/position machinery,
 // narrower shapes. Anchors are not marks here (decorations).
 //
 // `toDOM` and `parseDOM` are one tier, not two halves of a rendering: a copy and a
 // paste inside one body run the whole document through them (CODEC §"Markdown at the
 // edges"), so every attribute written here is read back here. Foreign HTML spells none
 // of this package's `data-qm-*` names, so what a paste takes off the web is unchanged;
-// the one rule that widens that door on purpose is the fence's.
+// the one rule here that widens that door on purpose is the fence's, a `<table>` being
+// the block leaf's clipboard parser's (`table-paste.ts`).
 import { Schema } from 'prosemirror-model';
 import { islandBlockSpec, islandInlineSpec } from './islands.js';
 import { rendersHref, storableUrl } from './urls.js';
@@ -176,7 +178,7 @@ export const blockSchema = new Schema({
     nodes: { ...blockNodes, ...inlineLeafNodes },
     marks
 });
-// ── The constrained inline nodes (both inline schemas) ──────────────────────
+// ── The constrained inline nodes (the inline schemas and the cell's) ────
 // `doc: "paragraph"` (exactly one child) is what makes an Enter a no-op at the
 // model level: there is no second block for a split to land.
 const inlineNodes = {
@@ -185,8 +187,7 @@ const inlineNodes = {
     text: { group: 'inline' }
 };
 /** The constrained inline schema: one paragraph, no block splitting, no
- *  containers, no islands, and the full mark set (a `richtext(inline)` field, and
- *  a table cell, which is the same content unit). */
+ *  containers, no islands, and the full mark set (a `richtext(inline)` field). */
 export const inlineSchema = new Schema({ nodes: inlineNodes, marks });
 /**
  * The inline schema with no mark types at all: a `plaintext(inline)` field, whose
@@ -198,6 +199,16 @@ export const inlineSchema = new Schema({ nodes: inlineNodes, marks });
  * carrying (CODEC §Inline mode).
  */
 export const plaintextSchema = new Schema({ nodes: inlineNodes, marks: {} });
+/**
+ * A table cell: the inline schema plus `hard_break`, which a `TableCell` stores as a
+ * `\n` in its `text`. Still one paragraph, so Enter has no block to split; a break is
+ * Shift-Enter's (`breaks.ts`). Declaring the break routes `decode` through the plain
+ * path, which folds a cell's `continues` lines into that one paragraph.
+ */
+export const cellSchema = new Schema({
+    nodes: { ...inlineNodes, hard_break: inlineLeafNodes.hard_break },
+    marks
+});
 /**
  * A `plaintext` field without `inline`: paragraphs and hard breaks, no marks, no
  * islands, no containers, which is the shape `Content::is_plain` admits. Mark-free

package/dist/core/codec/slash.d.ts

@@ -1,5 +1,5 @@
 import { EditorState, Plugin, type Command } from 'prosemirror-state';
-import type { EditorView } from 'prosemirror-view';
+import { type EditorView } from 'prosemirror-view';
 import { type RangeAnchor } from './anchor.js';
 /** The menu as the chrome sees it: the command names the query matched, the keyboard's
  *  cursor, and the trigger's anchor to hang off. `undefined` is a closed menu.
@@ -16,10 +16,13 @@ export interface SlashState {
      *  open menu outlives any one scroll position of the leaf. */
     anchor: RangeAnchor;
 }
-/** The menu's wording, which is its accessible name and nothing else: the offers are
- *  command names, and a name is not translated. */
+/** The menu's wording, which is its accessible name and the empty line's hint: the
+ *  offers are command names, and a name is not translated. */
 export interface SlashStrings {
     slashLabel: string;
+    /** Drawn on the empty line a focused caret holds, naming the key that opens the
+     *  menu there. */
+    slashHint: string;
 }
 /** The package's English, beside the surface that draws it: the same rule the island
  *  chrome's wording follows, and the visual `strings` set extends both. */
@@ -28,8 +31,8 @@ export declare const DEFAULT_SLASH_STRINGS: SlashStrings;
  * The vocabulary a caret can run, in menu order: the names `SLASH_COMMANDS` is keyed
  * by, each asked whether it would fire here. A row that declines when picked is worse
  * than an absent one, and asking the command rather than restating its guards is what
- * keeps the menu from drifting off what the shorthand does. So the offers narrow as the
- * caret moves: the island alone mid-paragraph, no list at an item's head.
+ * keeps the menu from drifting off what a pick does. So the offers narrow as the caret
+ * moves: the lists and the island alone mid-paragraph, no list at an item's head.
  *
  * `state` is the state a pick leaves behind — the run already consumed — since that is
  * the caret every command answers for (`blocks.ts`).
@@ -54,7 +57,7 @@ interface SlashRun {
  * below and close the menu without a listener of their own. A dismissal edits no
  * text; only a pick does, and it consumes exactly the run.
  */
-export declare function slashPlugin(onState: (state: SlashState | undefined) => void): Plugin<SlashRun | null>;
+export declare function slashPlugin(onState: (state: SlashState | undefined) => void, hint?: () => string | undefined): Plugin<SlashRun | null>;
 /**
  * The menu's keys, the innermost link of the leaf's chain (`keymap.ts`). Every one
  * declines on an empty offer list rather than on a dead run (§`SlashState`): a key an

package/dist/core/codec/table-paste.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from 'prosemirror-state';
+/**
+ * A block leaf's table paste: the clipboard's parse for HTML, and for text that is
+ * tab-separated. A paste as plain text keeps the text, tabs and all. A cell's own view
+ * mounts none of this, so a paste inside a cell is inline.
+ */
+export declare function tablePastePlugin(): Plugin;

package/dist/core/codec/table-paste.js

@@ -0,0 +1,132 @@
+// A table on the clipboard lands as a table island (CODEC §"Markdown at the edges"). Two
+// spellings carry one: an HTML `<table>`, and the tab-separated text a spreadsheet writes
+// beside it, which ProseMirror hands over only where the clipboard holds no HTML. Either
+// builds its props through `normalizeTable` and arrives with no id, which the paste's
+// island pass mints (`islands.ts`). Nothing the source styled a table with has a reader
+// here, so a pasted table takes the document's face.
+import { DOMParser, Fragment, Slice } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { usvLength } from './decode.js';
+import { pmToContent } from './encode.js';
+import { blockSchema } from './schema.js';
+import { emptyCell, normalizeTable } from './table.js';
+const schemaRules = DOMParser.fromSchema(blockSchema).rules;
+/** What a cell's markup is read with: the schema's rules less the islands', so an island
+ *  element inside a cell is the text it holds. */
+const cellParser = new DOMParser(blockSchema, schemaRules.filter((rule) => !('node' in rule && rule.node?.startsWith('island_'))));
+/** A `<td>` or `<th>` as a cell: its blocks are lines and a `<br>` a break, each one `\n`
+ *  in the text (`cellContent`), and its marks the ones the schema's rules read. Whitespace
+ *  at the cell's edges is dropped, which is where a source's empty paragraph lands. */
+function cellFromDOM(el) {
+    const { text, marks } = pmToContent(cellParser.parse(el));
+    // Every whitespace character is in the BMP, so `lead` counts USVs as well.
+    const lead = text.length - text.trimStart().length;
+    const kept = text.trim();
+    const end = usvLength(kept);
+    return {
+        text: kept,
+        marks: marks.flatMap((m) => {
+            const start = Math.max(0, m.start - lead);
+            const stop = Math.min(end, m.end - lead);
+            return start < stop ? [{ ...m, start, end: stop }] : [];
+        })
+    };
+}
+/**
+ * A `<table>` as table props, or `null` where it holds no cell. Rows run in the order the
+ * DOM's `rows` gives them, a `<thead>`'s first, and the first is the header. A merged
+ * cell splits: its content in the first slot it covers and an empty cell in each other,
+ * so the cells beside and under it keep their columns.
+ */
+function tableFromDOM(table) {
+    const rows = Array.from(table.rows);
+    const grid = rows.map(() => []);
+    rows.forEach((tr, r) => {
+        let c = 0;
+        for (const td of Array.from(tr.cells)) {
+            while (grid[r][c])
+                c++;
+            const across = Math.max(1, td.colSpan);
+            const down = Math.min(td.rowSpan || rows.length, rows.length - r);
+            for (let dr = 0; dr < down; dr++)
+                for (let dc = 0; dc < across; dc++)
+                    grid[r + dr][c + dc] = dr || dc ? emptyCell() : cellFromDOM(td);
+            c += across;
+        }
+    });
+    if (!grid.some((row) => row.length))
+        return null;
+    // A row a merge reached into past its own cells has holes.
+    const [header = [], ...body] = grid.map((row) => Array.from(row, (cell) => cell ?? emptyCell()));
+    return normalizeTable({ header, rows: body, aligns: [] });
+}
+const QUOTED = /"((?:[^"]|"")*)"(?=[\t\r\n]|$)/y;
+const BARE = /[^\t\r\n]*/y;
+/**
+ * Tab-separated text as table props, the first line the header, or `null` unless every
+ * line holds a tab and some cell holds more than whitespace. A cell in double quotes is
+ * one cell whose tabs, line ends and doubled quotes are its text, which is how Excel and
+ * Sheets write a cell holding any of the three; a quote not closed that way is literal.
+ * The line ends closing the text are the spreadsheet's terminator, not an empty row.
+ */
+function tableFromText(text) {
+    const body = text.replace(/[\r\n]+$/, '');
+    const lines = [[]];
+    let at = 0;
+    for (;;) {
+        QUOTED.lastIndex = BARE.lastIndex = at;
+        const quoted = QUOTED.exec(body);
+        const cell = quoted
+            ? quoted[1].replace(/""/g, '"').replace(/\r\n?/g, '\n')
+            : BARE.exec(body)[0];
+        lines.at(-1).push(cell);
+        at = quoted ? QUOTED.lastIndex : BARE.lastIndex;
+        if (at >= body.length)
+            break;
+        if (body[at] === '\t')
+            at += 1;
+        else {
+            at += body.startsWith('\r\n', at) ? 2 : 1;
+            lines.push([]);
+        }
+    }
+    if (!lines.every((cells) => cells.length > 1))
+        return null;
+    if (!lines.some((cells) => cells.some((cell) => cell.trim())))
+        return null;
+    const [header = [], ...rows] = lines.map((cells) => cells.map((t) => ({ text: t, marks: [] })));
+    return normalizeTable({ header, rows, aligns: [] });
+}
+/** The schema's parse with a `<table>` read as an island rather than as its cells' text. */
+const clipboardParser = new DOMParser(blockSchema, [
+    {
+        tag: 'table',
+        node: 'island_block',
+        getAttrs: (el) => {
+            const props = tableFromDOM(el);
+            return props ? { islandType: 'table', props } : false;
+        }
+    },
+    ...schemaRules
+]);
+/**
+ * A block leaf's table paste: the clipboard's parse for HTML, and for text that is
+ * tab-separated. A paste as plain text keeps the text, tabs and all. A cell's own view
+ * mounts none of this, so a paste inside a cell is inline.
+ */
+export function tablePastePlugin() {
+    return new Plugin({
+        props: {
+            clipboardParser,
+            // A falsy return declines, handing the text to ProseMirror's own split into
+            // paragraphs; the prop's type has no spelling for it.
+            clipboardTextParser: ((text, _context, plain) => {
+                const props = plain ? null : tableFromText(text);
+                if (!props)
+                    return null;
+                const island = blockSchema.nodes.island_block.create({ islandType: 'table', props });
+                return new Slice(Fragment.from(island), 0, 0);
+            })
+        }
+    });
+}

package/dist/core/codec/table-view.d.ts

@@ -21,6 +21,18 @@ export interface TableChromeStrings {
     /** The two trailing bars, each of which grows the table along its own axis. */
     tableAddRow: string;
     tableAddColumn: string;
+    /** The held column's alignment cluster, a name per toggle, and the held cells'
+     *  cluster, which takes these three and the vertical three beside them. */
+    tableAlignLeft: string;
+    tableAlignCenter: string;
+    tableAlignRight: string;
+    /** The held first row's toggle, pressed while the row draws as the header. */
+    tableHeaderToggle: string;
+    tableAlignTop: string;
+    tableAlignMiddle: string;
+    tableAlignBottom: string;
+    /** The held cells' cluster's own name. */
+    tableCellAlignment: string;
 }
 /**
  * The package's English for the island chrome. It lives here, beside the surface