@quillmark/svelte 0.25.0 → 0.26.0

package/dist/core/codec/field.js

@@ -36,6 +36,7 @@ import { linkPastePlugin } from './link-paste.js';
 import { linePastePlugin } from './line-paste.js';
 import { listPastePlugin } from './list-paste.js';
 import { markdownPastePlugin } from './markdown-paste.js';
+import { wordPastePlugin } from './word-paste.js';
 import { nestingPlugin } from './nesting.js';
 import { undoStepPlugin } from './undo.js';
 import { tablePastePlugin } from './table-paste.js';
@@ -572,7 +573,7 @@ export function proseLeafPlugins(schema, opts) {
     // Each answers to something only the block schema holds: any other leaf is
     // textblocks alone, with no island and no gap to put a cursor in.
     if (isBlockSchema(schema))
-        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), tableCopyPlugin(), markdownPastePlugin(), listPastePlugin(), taskPlugin(), nestingPlugin());
+        list.push(gapCursor(), pastAtomPlugin(), islandPastePlugin(), tablePastePlugin(), tableCopyPlugin(), markdownPastePlugin(), wordPastePlugin(), listPastePlugin(), taskPlugin(), nestingPlugin());
     if (schema === plainSchema)
         list.push(plainClipboardPlugin());
     if (isInlineSchema(schema))

package/dist/core/codec/list-toggle.js

@@ -10,10 +10,11 @@
 // Otherwise each line becomes the kind: a run of plain lines is wrapped, one item a
 // line, and a run of continuation lines the same way where it stands, the first items
 // of a sub-list under their item, as `- ` or `1. ` at a continuation's head opens one
-// (`blocks.ts` §`openingAnItem`); a list of the other kind is retyped whole, a list
-// being one kind (`blocks.ts` §`listAtItem`); a line already in the kind stays. What it
-// wraps or retypes joins the lists of its kind it leaves touching (`touching.ts`), so
-// the lines of one selection count as one list.
+// (`blocks.ts` §`openingAnItem`); the selected items of a list of the other kind split
+// out of it as a list of the kind, a list being one kind (`blocks.ts` §`listAtItem`),
+// its tail counting from 1 as `unlist` leaves one; a line already in the kind stays.
+// What it wraps or retypes joins the lists of its kind it leaves touching
+// (`touching.ts`), so the lines of one selection count as one list.
 import { Fragment, NodeRange, Slice } from 'prosemirror-model';
 import { wrapRangeInList } from 'prosemirror-schema-list';
 import { ReplaceAroundStep } from 'prosemirror-transform';
@@ -108,20 +109,41 @@ function unlist(tr, type, itemType) {
             tr.setNodeMarkup(tail, null, { ...rest.attrs, start: 1 });
     }
 }
+/** Items `first` to `last` of the list at `pos` split out as a list of their own,
+ *  the tail after them counting from 1. Returns where that list stands. */
+function splitOut(tr, pos, first, last) {
+    const list = tr.doc.nodeAt(pos);
+    const $inside = tr.doc.resolve(pos + 1);
+    if (last + 1 < list.childCount) {
+        tr.split($inside.posAtIndex(last + 1));
+        const tail = tr.doc.resolve(pos + 1).posAtIndex(last + 1) + 1;
+        if (list.attrs.start != null && list.attrs.start !== 1)
+            tr.setNodeMarkup(tail, null, { ...list.attrs, start: 1 });
+    }
+    if (first === 0)
+        return pos;
+    tr.split($inside.posAtIndex(first));
+    return $inside.posAtIndex(first) + 1;
+}
 /** Make every line the kind, and join what that leaves touching. */
 function relist(tr, lines, type, paragraph) {
     const changed = [];
     const runs = [];
+    const others = new Map();
     for (const line of lines) {
         const { $at, item } = line;
         if (line.covered)
             continue;
         if (line.opens) {
+            if ($at.node(item - 1).type === type)
+                continue;
             const pos = $at.before(item - 1);
-            if ($at.node(item - 1).type !== type && !changed.some((c) => c.pos === pos)) {
-                tr.setNodeMarkup(pos, type, type.name === 'ordered_list' ? { start: 1 } : null);
-                changed.push({ pos, step: tr.steps.length });
-            }
+            const index = $at.index(item - 1);
+            const span = others.get(pos);
+            if (span)
+                span.last = index;
+            else
+                others.set(pos, { first: index, last: index });
             continue;
         }
         const end = line.pos + $at.parent.nodeSize;
@@ -138,6 +160,11 @@ function relist(tr, lines, type, paragraph) {
             return false;
         changed.push({ pos: run.from, step: tr.steps.length });
     }
+    for (const [pos, span] of [...others].reverse()) {
+        const at = splitOut(tr, tr.mapping.map(pos), span.first, span.last);
+        tr.setNodeMarkup(at, type, type.name === 'ordered_list' ? { start: 1 } : null);
+        changed.push({ pos: at, step: tr.steps.length });
+    }
     const seams = [];
     for (const { pos, step } of changed) {
         const at = tr.mapping.slice(step).map(pos);

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

@@ -0,0 +1,5 @@
+import { Plugin } from 'prosemirror-state';
+/** `html` with every run of Word list paragraphs made a list; `html` itself where there
+ *  are none. */
+export declare function wordLists(html: string): string;
+export declare function wordPastePlugin(): Plugin;

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

@@ -0,0 +1,87 @@
+// A list copied out of Word or Outlook lands as a list. Desktop Word writes no `<ol>` or
+// `<li>`: each item is a paragraph styled `mso-list:l0 level2 lfo1`, its marker drawn by a
+// `mso-list:Ignore` span ahead of the text. Each run of those paragraphs is rebuilt here as
+// the nested lists it draws, the marker span dropped, so the paste rules after this one
+// (`list-paste.ts`) see a list as any other source writes one.
+import { Plugin } from 'prosemirror-state';
+/** A Word list paragraph's style: the list it is in, and its level from 1. */
+const MSO_LIST = /mso-list:\s*(l\d+)\s+level(\d+)\s+(lfo\d+)/i;
+/** A numbered marker: digits, or letters, closed by `.` or `)`, or in parentheses, and a
+ *  legal outline's `1.2.` whose last part is the item's own. Every other marker is a
+ *  bullet, Word's `·`, `o` and `§` among them. */
+const ORDINAL = /^\(?(?:\d+\.)*(\d+|[a-z]+)[.)]$/i;
+/** The marker text of a list paragraph, its span taken out. */
+function takeMarker(p) {
+    const span = [...p.querySelectorAll('span')].find((s) => /mso-list:\s*Ignore/i.test(s.getAttribute('style') ?? ''));
+    if (!span)
+        return '';
+    const marker = (span.textContent ?? '').replace(/\s+/g, '');
+    span.remove();
+    return marker;
+}
+/** `run`'s paragraphs as nested lists, one level of the stack a level of Word's. */
+function rebuild(doc, run) {
+    const stack = [];
+    let root = null;
+    for (const { p, level } of run) {
+        const marker = takeMarker(p);
+        while (stack.length && stack[stack.length - 1].level > level)
+            stack.pop();
+        const top = stack[stack.length - 1];
+        if (!top || top.level < level) {
+            const ordinal = ORDINAL.exec(marker);
+            const list = doc.createElement(ordinal ? 'ol' : 'ul');
+            if (ordinal && /^\d+$/.test(ordinal[1]) && ordinal[1] !== '1')
+                list.setAttribute('start', ordinal[1]);
+            if (top)
+                top.list.lastElementChild.append(list);
+            else
+                root = list;
+            stack.push({ level, list });
+        }
+        const item = doc.createElement('li');
+        p.removeAttribute('style');
+        p.removeAttribute('class');
+        item.append(p);
+        stack[stack.length - 1].list.append(item);
+    }
+    return root;
+}
+/** `html` with every run of Word list paragraphs made a list; `html` itself where there
+ *  are none. */
+export function wordLists(html) {
+    if (!/mso-list/i.test(html))
+        return html;
+    const doc = new DOMParser().parseFromString(html, 'text/html');
+    const runs = [];
+    let id = null;
+    for (const p of doc.body.querySelectorAll('p')) {
+        const match = MSO_LIST.exec(p.getAttribute('style') ?? '');
+        if (!match)
+            continue;
+        const prev = runs[runs.length - 1]?.at(-1)?.p;
+        let sibling = p.previousSibling;
+        while (sibling &&
+            sibling.nodeType !== 1 &&
+            !(sibling.nodeType === 3 && sibling.textContent.trim()))
+            sibling = sibling.previousSibling;
+        const list = match[1] + match[3];
+        const entry = { p, level: Number(match[2]) };
+        if (prev && sibling === prev && list === id)
+            runs[runs.length - 1].push(entry);
+        else
+            runs.push([entry]);
+        id = list;
+    }
+    if (!runs.length)
+        return html;
+    for (const run of runs) {
+        const anchor = doc.createComment('');
+        run[0].p.before(anchor);
+        anchor.replaceWith(rebuild(doc, run));
+    }
+    return doc.body.innerHTML;
+}
+export function wordPastePlugin() {
+    return new Plugin({ props: { transformPastedHTML: (html) => wordLists(html) } });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.25.0",
+	"version": "0.26.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",