@quillmark/svelte 0.24.0 → 0.26.0

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

@@ -0,0 +1,36 @@
+// A one-line leaf holds one paragraph, so a paste of several lines lands as that one line:
+// the lines joined by a space, as a browser's single-line input joins them, where the
+// schema would keep the first and drop the rest. An element of an array of them is the
+// exception the array asks for (`visual/ProseValue.svelte`): there each line is a row.
+import { Fragment, Slice } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+/** The lines a slice holds that hold anything, in order. */
+export function pastedLines(slice) {
+    const lines = [];
+    slice.content.descendants((node) => {
+        if (node.isTextblock && node.content.size)
+            lines.push(node);
+        return !node.isTextblock;
+    });
+    return lines;
+}
+/** `lines` as the content of one line, a space between each two. */
+export function joinLines(lines, schema) {
+    const parts = [];
+    for (const line of lines) {
+        if (parts.length)
+            parts.push(schema.text(' '));
+        line.content.forEach((node) => parts.push(node));
+    }
+    return Fragment.from(parts);
+}
+export function linePastePlugin() {
+    return new Plugin({
+        props: {
+            transformPasted(slice, view) {
+                const lines = pastedLines(slice);
+                return lines.length > 1 ? new Slice(joinLines(lines, view.state.schema), 0, 0) : slice;
+            }
+        }
+    });
+}

package/dist/core/codec/list-move.d.ts

@@ -0,0 +1,6 @@
+import type { Schema } from 'prosemirror-model';
+import type { Command } from 'prosemirror-state';
+/** The items the selection stands in, in the innermost list holding all of them, moved
+ *  one place up (`-1`) or down (`1`). */
+export declare function moveItems(dir: -1 | 1): Command;
+export declare function listMoveKeymap(schema: Schema): Record<string, Command>;

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

@@ -0,0 +1,30 @@
+const isList = (node) => node.type.name === 'ordered_list' || node.type.name === 'bullet_list';
+/** The items the selection stands in, in the innermost list holding all of them, moved
+ *  one place up (`-1`) or down (`1`). */
+export function moveItems(dir) {
+    return (state, dispatch) => {
+        const { $from, $to } = state.selection;
+        const range = $from.blockRange($to, isList);
+        if (!range)
+            return false;
+        const index = dir < 0 ? range.startIndex - 1 : range.endIndex;
+        if (index < 0 || index >= range.parent.childCount)
+            return false;
+        if (!dispatch)
+            return true;
+        const sibling = range.parent.child(index);
+        const size = sibling.nodeSize;
+        const tr = state.tr;
+        if (dir < 0)
+            tr.delete(range.start - size, range.start).insert(range.end - size, sibling);
+        else
+            tr.delete(range.end, range.end + size).insert(range.start, sibling);
+        dispatch(tr.scrollIntoView());
+        return true;
+    };
+}
+export function listMoveKeymap(schema) {
+    if (!schema.nodes.list_item)
+        return {};
+    return { 'Alt-ArrowUp': moveItems(-1), 'Alt-ArrowDown': moveItems(1) };
+}

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

@@ -0,0 +1,2 @@
+import { Plugin } from 'prosemirror-state';
+export declare function listPastePlugin(): Plugin;

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

@@ -0,0 +1,142 @@
+// A pasted list takes the numbering of where it lands (CODEC §"Markdown at the edges").
+// An item's number is its position, so a paste counts where it stands: items pasted into
+// a list are that list's next items, of its kind and in its count, and items pasted on
+// the empty line a list was just left by are the same list's. A list pasted on a line of
+// its own keeps the `start` it was copied with, which a writer typed (`lists.ts` writes
+// none) — but a run of items copied from inside a list is copied counting from 1: their
+// numbers were positions in the list they came out of.
+//
+// A line's shape travels with its end, as a word processor's paragraph mark carries its
+// style: text copied from inside one line pastes as text, whatever block it was copied
+// out of, and paragraphs pasted into a numbered line are numbered lines.
+import { Fragment, Slice } from 'prosemirror-model';
+import { Plugin, Selection } from 'prosemirror-state';
+const isList = (node) => !!node && (node.type.name === 'ordered_list' || node.type.name === 'bullet_list');
+/** The one list a slice is, if it is one: whole, or open where a run of its items was
+ *  copied. */
+function soleList(slice) {
+    return slice.content.childCount === 1 && isList(slice.content.firstChild)
+        ? slice.content.firstChild
+        : null;
+}
+/** The textblock a slice is the inside of: text copied from within one line, the slice
+ *  open to that line at both ends down a chain of only children. */
+function lineInside(slice) {
+    if (slice.openStart === 0 || slice.openStart !== slice.openEnd)
+        return null;
+    let node = null;
+    for (let d = 0, content = slice.content; d < slice.openStart; d++, content = node.content) {
+        if (content.childCount !== 1)
+            return null;
+        node = content.firstChild;
+    }
+    return node.isTextblock ? node : null;
+}
+/** `content` with the node `depth` levels down its leading edge counting from 1. */
+function fromOne(content, depth) {
+    const first = content.firstChild;
+    const node = depth === 1
+        ? first.type.create({ ...first.attrs, start: 1 }, first.content, first.marks)
+        : first.copy(fromOne(first.content, depth - 1));
+    return content.replaceChild(0, node);
+}
+/** A new item beside `item`: a task's sibling is a task, and unchecked. */
+const itemAttrs = (item) => ({ checked: item.attrs.checked === null ? null : false });
+/** HTML a ProseMirror view wrote, which states how deep the copy was open at each end. */
+const PM_SLICE = /\sdata-pm-slice="\d+ \d+/;
+export function listPastePlugin() {
+    // Whether the paste in flight states its own open depths: a ProseMirror copy does, and
+    // a drag inside the view carries its slice whole. Any other source is parsed open as
+    // deep as it goes, so a whole item copied off a web page reads as the inside of one
+    // line, and only a slice that says so is taken for one. Read once, by the transform.
+    let exact = false;
+    return new Plugin({
+        props: {
+            handleDOMEvents: {
+                drop: (view) => {
+                    exact = !!view.dragging;
+                    return false;
+                }
+            },
+            transformPastedHTML(html) {
+                exact = PM_SLICE.test(html);
+                return html;
+            },
+            // A copy whose leading edge stands past an ordered list's first item is a run
+            // out of it, and goes out counting from 1; one from the first item keeps the
+            // list's `start`, however the selection ends. The copy is the selection's own
+            // slice, its leading edge the caret's ancestors from the top, so the list at
+            // depth `d` stands `d` levels down it.
+            transformCopied(slice, view) {
+                const { $from } = view.state.selection;
+                let content = slice.content;
+                for (let d = 1; d < $from.depth; d++) {
+                    const list = $from.node(d);
+                    if (list.type.name === 'ordered_list' && $from.index(d) > 0 && list.attrs.start !== 1)
+                        content = fromOne(content, d);
+                }
+                return content === slice.content
+                    ? slice
+                    : new Slice(content, slice.openStart, slice.openEnd);
+            },
+            // The caret's line keeps its shape under text from inside another line: no
+            // list, heading or fence comes along to wrap it. Into a line of an item, a list
+            // is its items, which join the list the caret is in where a whole list would
+            // nest under that line's item. Paragraphs into an item's first line are items
+            // beside it, as a word processor numbers each pasted paragraph; a later line of
+            // an item is unnumbered, and so are the paragraphs pasted into it.
+            transformPasted(slice, view) {
+                const line = exact && lineInside(slice);
+                exact = false;
+                if (line)
+                    return new Slice(line.content, 0, 0);
+                const { $from, $to } = view.state.selection;
+                if (!$from.sameParent($to) || !$from.parent.isTextblock || $from.depth < 2)
+                    return slice;
+                if ($from.parent.type.spec.code)
+                    return slice;
+                const item = $from.node(-1);
+                if (item.type.name !== 'list_item')
+                    return slice;
+                const list = soleList(slice);
+                if (list)
+                    return new Slice(list.content, Math.max(slice.openStart - 1, 0), Math.max(slice.openEnd - 1, 0));
+                const { content } = slice;
+                if ($from.index(-1) !== 0 || content.childCount < 2)
+                    return slice;
+                const items = [];
+                for (let i = 0; i < content.childCount; i++) {
+                    const block = content.child(i);
+                    if (block.type.name !== 'paragraph')
+                        return slice;
+                    items.push(item.type.create(itemAttrs(item), block));
+                }
+                return new Slice(Fragment.from(items), slice.openStart && slice.openStart + 1, slice.openEnd && slice.openEnd + 1);
+            },
+            // On the empty line right under a list of the same kind, the line Enter on an
+            // empty last item leaves, the items are that list's next ones.
+            handlePaste(view, _event, slice) {
+                const list = soleList(slice);
+                const { $from, empty } = view.state.selection;
+                if (!list || !empty || !$from.parent.isTextblock || $from.parent.content.size !== 0)
+                    return false;
+                if ($from.parent.type.spec.code)
+                    return false;
+                const above = view.state.doc.resolve($from.before()).nodeBefore;
+                if (!isList(above) || above.type !== list.type)
+                    return false;
+                const end = $from.before() - 1;
+                const tr = view.state.tr.delete($from.before(), $from.after()).insert(end, list.content);
+                try {
+                    tr.doc.check();
+                }
+                catch {
+                    return false;
+                }
+                tr.setSelection(Selection.near(tr.doc.resolve(end + list.content.size), -1));
+                view.dispatch(tr.scrollIntoView().setMeta('paste', true).setMeta('uiEvent', 'paste'));
+                return true;
+            }
+        }
+    });
+}

package/dist/core/codec/list-toggle.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from 'prosemirror-state';
+/** Number (`ordered`) or bullet every line of the selection, or, where every one already
+ *  carries the kind, take those markers off. Declines where the selection holds no line. */
+export declare function toggleList(ordered: boolean): Command;

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

@@ -0,0 +1,197 @@
+// The list toggle: every line of a selection numbered or bulleted as one gesture, or
+// every one's marker taken off. Mod-Shift-7 and Mod-Shift-8 bind it, the Docs chords
+// (`lists.ts`), and the selection toolbar offers it (`visual/FormatPopover.svelte`).
+//
+// A line is a textblock the selection touches; a fence is no line here, a list item
+// being no place for one to land unasked. A line carries a marker where it opens its
+// item. An item's later line, a continuation, goes with its item where the item's
+// opening line is selected too, and otherwise carries no marker of its own. Where every
+// line carries one of the kind, the toggle takes those markers off, and only those.
+// 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`); 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';
+import { withinNesting } from './nesting.js';
+import { joinAll } from './touching.js';
+/** The textblocks `[from, to]` touches, by position, fences left out. A selection that
+ *  ends at the very head of a block has selected nothing in it. */
+function linesIn(doc, from, to) {
+    const lines = [];
+    doc.nodesBetween(from, to, (node, pos) => {
+        if (!node.isTextblock)
+            return true;
+        if (!node.type.spec.code && (from === to || pos + 1 < to))
+            lines.push(pos);
+        return false;
+    });
+    return lines;
+}
+function lineAt(doc, pos, itemType) {
+    const $at = doc.resolve(pos + 1);
+    let item = -1;
+    for (let depth = $at.depth - 1; depth > 0 && item < 0; depth--)
+        if ($at.node(depth).type === itemType)
+            item = depth;
+    let opens = item > 0;
+    for (let depth = item; opens && depth < $at.depth; depth++)
+        opens = $at.index(depth) === 0;
+    return { pos, $at, item, opens };
+}
+/** The selection's lines, each with whether its item's opening line is among them. */
+function linesOf(doc, from, to, itemType) {
+    const lines = linesIn(doc, from, to).map((pos) => lineAt(doc, pos, itemType));
+    const opened = new Set(lines.filter((l) => l.opens).map((l) => l.$at.before(l.item)));
+    return lines.map((line) => ({
+        ...line,
+        covered: line.item > 0 && !line.opens && opened.has(line.$at.before(line.item))
+    }));
+}
+/**
+ * `prosemirror-schema-list`'s `liftOutOfList`, over a transaction, which upstream does
+ * not export: the items of `range` out of their list, their blocks standing where the
+ * list stood, the list closed around them. In a sub-list the blocks land in the parent
+ * item, the continuation lines a marker coming off leaves (`lists.ts` §`markerOff`).
+ * Returns where the list's tail stands, `null` where the items were its last, and
+ * `false` where the parent cannot hold the items' blocks.
+ */
+function liftOut(tr, range) {
+    const list = range.parent;
+    for (let pos = range.end, i = range.endIndex - 1; i > range.startIndex; i--) {
+        pos -= list.child(i).nodeSize;
+        tr.delete(pos - 1, pos + 1);
+    }
+    const $start = tr.doc.resolve(range.start);
+    const item = $start.nodeAfter;
+    const atStart = range.startIndex === 0;
+    const atEnd = range.endIndex === list.childCount;
+    const start = $start.pos;
+    const end = start + item.nodeSize;
+    const shell = Fragment.from(list.copy(Fragment.empty));
+    const step = new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new Slice((atStart ? Fragment.empty : shell).append(atEnd ? Fragment.empty : shell), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1);
+    if (tr.maybeStep(step).failed)
+        return false;
+    if (atEnd)
+        return null;
+    const $list = tr.doc.resolve(range.$from.before(range.depth));
+    return $list.posAtIndex($list.index() + (atStart ? 0 : 1) + item.childCount);
+}
+/** Take every marker the selection's lines carry off, the shallowest list first:
+ *  lifting an item brings its sub-lists up a level, where the next pass reaches them. A
+ *  list's tail counts from 1 again, a number that names its position in the list it now
+ *  is (`lists.ts` §`lineOut`). */
+function unlist(tr, type, itemType) {
+    for (;;) {
+        const { from, to } = tr.selection;
+        const marked = linesIn(tr.doc, from, to)
+            .map((pos) => lineAt(tr.doc, pos, itemType))
+            .filter((l) => l.opens && l.$at.node(l.item - 1).type === type);
+        if (!marked.length)
+            return true;
+        const depth = Math.min(...marked.map((l) => l.item - 1));
+        const listPos = marked.find((l) => l.item - 1 === depth).$at.before(depth);
+        const indices = marked
+            .filter((l) => l.item - 1 === depth && l.$at.before(depth) === listPos)
+            .map((l) => l.$at.index(depth));
+        const $list = tr.doc.resolve(listPos + 1);
+        const range = new NodeRange(tr.doc.resolve($list.posAtIndex(Math.min(...indices))), tr.doc.resolve($list.posAtIndex(Math.max(...indices) + 1)), depth);
+        const tail = liftOut(tr, range);
+        if (tail === false)
+            return false;
+        const rest = tail === null ? null : tr.doc.nodeAt(tail);
+        if (tail !== null && rest?.attrs.start != null && rest.attrs.start !== 1)
+            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);
+            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;
+        const run = runs[runs.length - 1];
+        if (run && run.to === line.pos && run.depth === $at.depth - 1)
+            run.to = end;
+        else
+            runs.push({ from: line.pos, to: end, depth: $at.depth - 1 });
+    }
+    for (const run of runs.reverse()) {
+        tr.setBlockType(run.from, run.to, paragraph);
+        const range = new NodeRange(tr.doc.resolve(run.from), tr.doc.resolve(run.to), run.depth);
+        if (!wrapRangeInList(tr, range, type))
+            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);
+        const node = tr.doc.nodeAt(at);
+        if (node)
+            seams.push(at, at + node.nodeSize);
+    }
+    joinAll(tr, seams);
+    return withinNesting(tr.doc);
+}
+/** Number (`ordered`) or bullet every line of the selection, or, where every one already
+ *  carries the kind, take those markers off. Declines where the selection holds no line. */
+export function toggleList(ordered) {
+    return (state, dispatch) => {
+        const { list_item: item, paragraph } = state.schema.nodes;
+        const type = state.schema.nodes[ordered ? 'ordered_list' : 'bullet_list'];
+        if (!item || !paragraph || !type)
+            return false;
+        const { from, to } = state.selection;
+        const lines = linesOf(state.doc, from, to, item);
+        if (!lines.length)
+            return false;
+        const tr = state.tr;
+        const off = lines.every((l) => l.covered || (l.opens && l.$at.node(l.item - 1).type === type));
+        if (!(off ? unlist(tr, type, item) : relist(tr, lines, type, paragraph)))
+            return false;
+        dispatch?.(tr.scrollIntoView());
+        return true;
+    };
+}

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

@@ -7,21 +7,28 @@ import type { Command } from 'prosemirror-state';
  * `Tab` / `Shift-Tab` hold the list link of the body's Tab chain. Surfaces that own
  * Tab more locally under the same rule (`prose/canon/VISUAL_EDITOR.md` §Chrome)
  * prepend a link ahead of these in `keymap.ts`: a `code_block` takes literal
- * indentation (`code.ts`), an island takes cell traversal once added. Outside all
- * of them every link returns false and the key is not swallowed: Tab keeps its
- * default meaning, which is the body's only keyboard exit and the open seam for a
- * shell structural keymap (VISUAL_EDITOR §Settled and open).
+ * indentation (`code.ts`). Where every link declines, the body holds the key
+ * (`keymap.ts`).
  *
- * `Enter` is a chain in precedence order: the escape-above gesture, then
- * `splitListItem` (`splitTaskItem`, which leaves a task item's new half an open task),
- * then `liftListItem`. The middle link carries two behaviors of
- * its own: it splits a non-empty item, and on an empty item it either splits the
- * wrapping item (a nested empty item, so Enter lifts exactly one level) or bails
- * so the third link lifts a top-level empty item out to a paragraph. `Backspace` lifts
- * an item at its start, and joins a block onto the list it stands after. `Delete` is
- * that same chain at the seam below rather than a second table of cases beside it, so
- * the two keys cannot come to differ over a seam this link reaches. An empty line is
- * not one: the block link takes it ahead of this chain (`blocks.ts`), the caret's own
- * line being a nearer fact than the boundary under it.
+ * `Mod-Shift-7` / `Mod-Shift-8` are the list toggle (`list-toggle.ts`), numbering or
+ * bulleting the selection's lines or taking their markers off.
+ *
+ * `Tab` sinks an unnumbered line alone into a sub-list, any other line its whole item,
+ * and a block right after a list into the list's last item.
+ *
+ * `Enter` is a chain in precedence order: the empty line above an unnumbered one, the
+ * marker off an empty middle item and back on an empty continuation line, then `splitListItem`
+ * (`splitTaskItem`, which leaves a task item's new half an open task), then
+ * `liftListItem`. The split link carries two behaviors of its own: it splits a
+ * non-empty item, and on an empty last item it either splits the wrapping item (a
+ * nested one, so Enter lifts exactly one level) or bails so the last link lifts a
+ * top-level one out to a paragraph. `Backspace` takes an item's marker off at its
+ * start, a top-level continuation line out to full width, and joins a block onto the
+ * list it stands after, and both keys over a selection spanning blocks join the lists
+ * the delete leaves touching. `Delete` is the marker off at the seam below with the two lines
+ * joined, never the line out: a forward delete edits the line after the caret, not its
+ * indent. An empty line is neither key's here:
+ * the block link takes it ahead of this chain (`blocks.ts`), the caret's own line
+ * being a nearer fact than the boundary under it.
  */
 export declare function listKeymap(schema: Schema): Record<string, Command>;