@vc-shell/framework 1.1.43 → 1.1.45

package/dist/vendor-prosemirror-commands-BH9lWGpW.js

@@ -0,0 +1,561 @@
+import { f as findWrapping, c as canSplit, l as liftTarget, a as canJoin, j as joinPoint, r as replaceStep, R as ReplaceStep, b as ReplaceAroundStep } from './vendor-prosemirror-transform-CE9VV3qg.js';
+import { S as Slice, F as Fragment } from './vendor-prosemirror-model-BZu3WVcD.js';
+import { T as TextSelection, N as NodeSelection, S as Selection, A as AllSelection } from './vendor-prosemirror-state-BvL9Pxph.js';
+
+/**
+Delete the selection, if there is one.
+*/
+const deleteSelection = (state, dispatch) => {
+    if (state.selection.empty)
+        return false;
+    if (dispatch)
+        dispatch(state.tr.deleteSelection().scrollIntoView());
+    return true;
+};
+function atBlockStart(state, view) {
+    let { $cursor } = state.selection;
+    if (!$cursor || (view ? !view.endOfTextblock("backward", state)
+        : $cursor.parentOffset > 0))
+        return null;
+    return $cursor;
+}
+/**
+If the selection is empty and at the start of a textblock, try to
+reduce the distance between that block and the one before it—if
+there's a block directly before it that can be joined, join them.
+If not, try to move the selected block closer to the next one in
+the document structure by lifting it out of its parent or moving it
+into a parent of the previous block. Will use the view for accurate
+(bidi-aware) start-of-textblock detection if given.
+*/
+const joinBackward = (state, dispatch, view) => {
+    let $cursor = atBlockStart(state, view);
+    if (!$cursor)
+        return false;
+    let $cut = findCutBefore($cursor);
+    // If there is no node before this, try to lift
+    if (!$cut) {
+        let range = $cursor.blockRange(), target = range && liftTarget(range);
+        if (target == null)
+            return false;
+        if (dispatch)
+            dispatch(state.tr.lift(range, target).scrollIntoView());
+        return true;
+    }
+    let before = $cut.nodeBefore;
+    // Apply the joining algorithm
+    if (deleteBarrier(state, $cut, dispatch, -1))
+        return true;
+    // If the node below has no content and the node above is
+    // selectable, delete the node below and select the one above.
+    if ($cursor.parent.content.size == 0 &&
+        (textblockAt(before, "end") || NodeSelection.isSelectable(before))) {
+        for (let depth = $cursor.depth;; depth--) {
+            let delStep = replaceStep(state.doc, $cursor.before(depth), $cursor.after(depth), Slice.empty);
+            if (delStep && delStep.slice.size < delStep.to - delStep.from) {
+                if (dispatch) {
+                    let tr = state.tr.step(delStep);
+                    tr.setSelection(textblockAt(before, "end")
+                        ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos, -1)), -1)
+                        : NodeSelection.create(tr.doc, $cut.pos - before.nodeSize));
+                    dispatch(tr.scrollIntoView());
+                }
+                return true;
+            }
+            if (depth == 1 || $cursor.node(depth - 1).childCount > 1)
+                break;
+        }
+    }
+    // If the node before is an atom, delete it
+    if (before.isAtom && $cut.depth == $cursor.depth - 1) {
+        if (dispatch)
+            dispatch(state.tr.delete($cut.pos - before.nodeSize, $cut.pos).scrollIntoView());
+        return true;
+    }
+    return false;
+};
+/**
+A more limited form of [`joinBackward`](https://prosemirror.net/docs/ref/#commands.joinBackward)
+that only tries to join the current textblock to the one before
+it, if the cursor is at the start of a textblock.
+*/
+const joinTextblockBackward = (state, dispatch, view) => {
+    let $cursor = atBlockStart(state, view);
+    if (!$cursor)
+        return false;
+    let $cut = findCutBefore($cursor);
+    return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;
+};
+/**
+A more limited form of [`joinForward`](https://prosemirror.net/docs/ref/#commands.joinForward)
+that only tries to join the current textblock to the one after
+it, if the cursor is at the end of a textblock.
+*/
+const joinTextblockForward = (state, dispatch, view) => {
+    let $cursor = atBlockEnd(state, view);
+    if (!$cursor)
+        return false;
+    let $cut = findCutAfter($cursor);
+    return $cut ? joinTextblocksAround(state, $cut, dispatch) : false;
+};
+function joinTextblocksAround(state, $cut, dispatch) {
+    let before = $cut.nodeBefore, beforeText = before, beforePos = $cut.pos - 1;
+    for (; !beforeText.isTextblock; beforePos--) {
+        if (beforeText.type.spec.isolating)
+            return false;
+        let child = beforeText.lastChild;
+        if (!child)
+            return false;
+        beforeText = child;
+    }
+    let after = $cut.nodeAfter, afterText = after, afterPos = $cut.pos + 1;
+    for (; !afterText.isTextblock; afterPos++) {
+        if (afterText.type.spec.isolating)
+            return false;
+        let child = afterText.firstChild;
+        if (!child)
+            return false;
+        afterText = child;
+    }
+    let step = replaceStep(state.doc, beforePos, afterPos, Slice.empty);
+    if (!step || step.from != beforePos ||
+        step instanceof ReplaceStep && step.slice.size >= afterPos - beforePos)
+        return false;
+    if (dispatch) {
+        let tr = state.tr.step(step);
+        tr.setSelection(TextSelection.create(tr.doc, beforePos));
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+}
+function textblockAt(node, side, only = false) {
+    for (let scan = node; scan; scan = (side == "start" ? scan.firstChild : scan.lastChild)) {
+        if (scan.isTextblock)
+            return true;
+        if (only && scan.childCount != 1)
+            return false;
+    }
+    return false;
+}
+/**
+When the selection is empty and at the start of a textblock, select
+the node before that textblock, if possible. This is intended to be
+bound to keys like backspace, after
+[`joinBackward`](https://prosemirror.net/docs/ref/#commands.joinBackward) or other deleting
+commands, as a fall-back behavior when the schema doesn't allow
+deletion at the selected point.
+*/
+const selectNodeBackward = (state, dispatch, view) => {
+    let { $head, empty } = state.selection, $cut = $head;
+    if (!empty)
+        return false;
+    if ($head.parent.isTextblock) {
+        if (view ? !view.endOfTextblock("backward", state) : $head.parentOffset > 0)
+            return false;
+        $cut = findCutBefore($head);
+    }
+    let node = $cut && $cut.nodeBefore;
+    if (!node || !NodeSelection.isSelectable(node))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos - node.nodeSize)).scrollIntoView());
+    return true;
+};
+function findCutBefore($pos) {
+    if (!$pos.parent.type.spec.isolating)
+        for (let i = $pos.depth - 1; i >= 0; i--) {
+            if ($pos.index(i) > 0)
+                return $pos.doc.resolve($pos.before(i + 1));
+            if ($pos.node(i).type.spec.isolating)
+                break;
+        }
+    return null;
+}
+function atBlockEnd(state, view) {
+    let { $cursor } = state.selection;
+    if (!$cursor || (view ? !view.endOfTextblock("forward", state)
+        : $cursor.parentOffset < $cursor.parent.content.size))
+        return null;
+    return $cursor;
+}
+/**
+If the selection is empty and the cursor is at the end of a
+textblock, try to reduce or remove the boundary between that block
+and the one after it, either by joining them or by moving the other
+block closer to this one in the tree structure. Will use the view
+for accurate start-of-textblock detection if given.
+*/
+const joinForward = (state, dispatch, view) => {
+    let $cursor = atBlockEnd(state, view);
+    if (!$cursor)
+        return false;
+    let $cut = findCutAfter($cursor);
+    // If there is no node after this, there's nothing to do
+    if (!$cut)
+        return false;
+    let after = $cut.nodeAfter;
+    // Try the joining algorithm
+    if (deleteBarrier(state, $cut, dispatch, 1))
+        return true;
+    // If the node above has no content and the node below is
+    // selectable, delete the node above and select the one below.
+    if ($cursor.parent.content.size == 0 &&
+        (textblockAt(after, "start") || NodeSelection.isSelectable(after))) {
+        let delStep = replaceStep(state.doc, $cursor.before(), $cursor.after(), Slice.empty);
+        if (delStep && delStep.slice.size < delStep.to - delStep.from) {
+            if (dispatch) {
+                let tr = state.tr.step(delStep);
+                tr.setSelection(textblockAt(after, "start") ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos)), 1)
+                    : NodeSelection.create(tr.doc, tr.mapping.map($cut.pos)));
+                dispatch(tr.scrollIntoView());
+            }
+            return true;
+        }
+    }
+    // If the next node is an atom, delete it
+    if (after.isAtom && $cut.depth == $cursor.depth - 1) {
+        if (dispatch)
+            dispatch(state.tr.delete($cut.pos, $cut.pos + after.nodeSize).scrollIntoView());
+        return true;
+    }
+    return false;
+};
+/**
+When the selection is empty and at the end of a textblock, select
+the node coming after that textblock, if possible. This is intended
+to be bound to keys like delete, after
+[`joinForward`](https://prosemirror.net/docs/ref/#commands.joinForward) and similar deleting
+commands, to provide a fall-back behavior when the schema doesn't
+allow deletion at the selected point.
+*/
+const selectNodeForward = (state, dispatch, view) => {
+    let { $head, empty } = state.selection, $cut = $head;
+    if (!empty)
+        return false;
+    if ($head.parent.isTextblock) {
+        if (view ? !view.endOfTextblock("forward", state) : $head.parentOffset < $head.parent.content.size)
+            return false;
+        $cut = findCutAfter($head);
+    }
+    let node = $cut && $cut.nodeAfter;
+    if (!node || !NodeSelection.isSelectable(node))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos)).scrollIntoView());
+    return true;
+};
+function findCutAfter($pos) {
+    if (!$pos.parent.type.spec.isolating)
+        for (let i = $pos.depth - 1; i >= 0; i--) {
+            let parent = $pos.node(i);
+            if ($pos.index(i) + 1 < parent.childCount)
+                return $pos.doc.resolve($pos.after(i + 1));
+            if (parent.type.spec.isolating)
+                break;
+        }
+    return null;
+}
+/**
+Join the selected block or, if there is a text selection, the
+closest ancestor block of the selection that can be joined, with
+the sibling above it.
+*/
+const joinUp = (state, dispatch) => {
+    let sel = state.selection, nodeSel = sel instanceof NodeSelection, point;
+    if (nodeSel) {
+        if (sel.node.isTextblock || !canJoin(state.doc, sel.from))
+            return false;
+        point = sel.from;
+    }
+    else {
+        point = joinPoint(state.doc, sel.from, -1);
+        if (point == null)
+            return false;
+    }
+    if (dispatch) {
+        let tr = state.tr.join(point);
+        if (nodeSel)
+            tr.setSelection(NodeSelection.create(tr.doc, point - state.doc.resolve(point).nodeBefore.nodeSize));
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};
+/**
+Join the selected block, or the closest ancestor of the selection
+that can be joined, with the sibling after it.
+*/
+const joinDown = (state, dispatch) => {
+    let sel = state.selection, point;
+    if (sel instanceof NodeSelection) {
+        if (sel.node.isTextblock || !canJoin(state.doc, sel.to))
+            return false;
+        point = sel.to;
+    }
+    else {
+        point = joinPoint(state.doc, sel.to, 1);
+        if (point == null)
+            return false;
+    }
+    if (dispatch)
+        dispatch(state.tr.join(point).scrollIntoView());
+    return true;
+};
+/**
+Lift the selected block, or the closest ancestor block of the
+selection that can be lifted, out of its parent node.
+*/
+const lift = (state, dispatch) => {
+    let { $from, $to } = state.selection;
+    let range = $from.blockRange($to), target = range && liftTarget(range);
+    if (target == null)
+        return false;
+    if (dispatch)
+        dispatch(state.tr.lift(range, target).scrollIntoView());
+    return true;
+};
+/**
+If the selection is in a node whose type has a truthy
+[`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) property in its spec, replace the
+selection with a newline character.
+*/
+const newlineInCode = (state, dispatch) => {
+    let { $head, $anchor } = state.selection;
+    if (!$head.parent.type.spec.code || !$head.sameParent($anchor))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.insertText("\n").scrollIntoView());
+    return true;
+};
+function defaultBlockAt(match) {
+    for (let i = 0; i < match.edgeCount; i++) {
+        let { type } = match.edge(i);
+        if (type.isTextblock && !type.hasRequiredAttrs())
+            return type;
+    }
+    return null;
+}
+/**
+When the selection is in a node with a truthy
+[`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) property in its spec, create a
+default block after the code block, and move the cursor there.
+*/
+const exitCode = (state, dispatch) => {
+    let { $head, $anchor } = state.selection;
+    if (!$head.parent.type.spec.code || !$head.sameParent($anchor))
+        return false;
+    let above = $head.node(-1), after = $head.indexAfter(-1), type = defaultBlockAt(above.contentMatchAt(after));
+    if (!type || !above.canReplaceWith(after, after, type))
+        return false;
+    if (dispatch) {
+        let pos = $head.after(), tr = state.tr.replaceWith(pos, pos, type.createAndFill());
+        tr.setSelection(Selection.near(tr.doc.resolve(pos), 1));
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};
+/**
+If a block node is selected, create an empty paragraph before (if
+it is its parent's first child) or after it.
+*/
+const createParagraphNear = (state, dispatch) => {
+    let sel = state.selection, { $from, $to } = sel;
+    if (sel instanceof AllSelection || $from.parent.inlineContent || $to.parent.inlineContent)
+        return false;
+    let type = defaultBlockAt($to.parent.contentMatchAt($to.indexAfter()));
+    if (!type || !type.isTextblock)
+        return false;
+    if (dispatch) {
+        let side = (!$from.parentOffset && $to.index() < $to.parent.childCount ? $from : $to).pos;
+        let tr = state.tr.insert(side, type.createAndFill());
+        tr.setSelection(TextSelection.create(tr.doc, side + 1));
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};
+/**
+If the cursor is in an empty textblock that can be lifted, lift the
+block.
+*/
+const liftEmptyBlock = (state, dispatch) => {
+    let { $cursor } = state.selection;
+    if (!$cursor || $cursor.parent.content.size)
+        return false;
+    if ($cursor.depth > 1 && $cursor.after() != $cursor.end(-1)) {
+        let before = $cursor.before();
+        if (canSplit(state.doc, before)) {
+            if (dispatch)
+                dispatch(state.tr.split(before).scrollIntoView());
+            return true;
+        }
+    }
+    let range = $cursor.blockRange(), target = range && liftTarget(range);
+    if (target == null)
+        return false;
+    if (dispatch)
+        dispatch(state.tr.lift(range, target).scrollIntoView());
+    return true;
+};
+/**
+Move the selection to the node wrapping the current selection, if
+any. (Will not select the document node.)
+*/
+const selectParentNode = (state, dispatch) => {
+    let { $from, to } = state.selection, pos;
+    let same = $from.sharedDepth(to);
+    if (same == 0)
+        return false;
+    pos = $from.before(same);
+    if (dispatch)
+        dispatch(state.tr.setSelection(NodeSelection.create(state.doc, pos)));
+    return true;
+};
+function joinMaybeClear(state, $pos, dispatch) {
+    let before = $pos.nodeBefore, after = $pos.nodeAfter, index = $pos.index();
+    if (!before || !after || !before.type.compatibleContent(after.type))
+        return false;
+    if (!before.content.size && $pos.parent.canReplace(index - 1, index)) {
+        if (dispatch)
+            dispatch(state.tr.delete($pos.pos - before.nodeSize, $pos.pos).scrollIntoView());
+        return true;
+    }
+    if (!$pos.parent.canReplace(index, index + 1) || !(after.isTextblock || canJoin(state.doc, $pos.pos)))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.join($pos.pos).scrollIntoView());
+    return true;
+}
+function deleteBarrier(state, $cut, dispatch, dir) {
+    let before = $cut.nodeBefore, after = $cut.nodeAfter, conn, match;
+    let isolated = before.type.spec.isolating || after.type.spec.isolating;
+    if (!isolated && joinMaybeClear(state, $cut, dispatch))
+        return true;
+    let canDelAfter = !isolated && $cut.parent.canReplace($cut.index(), $cut.index() + 1);
+    if (canDelAfter &&
+        (conn = (match = before.contentMatchAt(before.childCount)).findWrapping(after.type)) &&
+        match.matchType(conn[0] || after.type).validEnd) {
+        if (dispatch) {
+            let end = $cut.pos + after.nodeSize, wrap = Fragment.empty;
+            for (let i = conn.length - 1; i >= 0; i--)
+                wrap = Fragment.from(conn[i].create(null, wrap));
+            wrap = Fragment.from(before.copy(wrap));
+            let tr = state.tr.step(new ReplaceAroundStep($cut.pos - 1, end, $cut.pos, end, new Slice(wrap, 1, 0), conn.length, true));
+            let $joinAt = tr.doc.resolve(end + 2 * conn.length);
+            if ($joinAt.nodeAfter && $joinAt.nodeAfter.type == before.type &&
+                canJoin(tr.doc, $joinAt.pos))
+                tr.join($joinAt.pos);
+            dispatch(tr.scrollIntoView());
+        }
+        return true;
+    }
+    let selAfter = after.type.spec.isolating || (dir > 0 && isolated) ? null : Selection.findFrom($cut, 1);
+    let range = selAfter && selAfter.$from.blockRange(selAfter.$to), target = range && liftTarget(range);
+    if (target != null && target >= $cut.depth) {
+        if (dispatch)
+            dispatch(state.tr.lift(range, target).scrollIntoView());
+        return true;
+    }
+    if (canDelAfter && textblockAt(after, "start", true) && textblockAt(before, "end")) {
+        let at = before, wrap = [];
+        for (;;) {
+            wrap.push(at);
+            if (at.isTextblock)
+                break;
+            at = at.lastChild;
+        }
+        let afterText = after, afterDepth = 1;
+        for (; !afterText.isTextblock; afterText = afterText.firstChild)
+            afterDepth++;
+        if (at.canReplace(at.childCount, at.childCount, afterText.content)) {
+            if (dispatch) {
+                let end = Fragment.empty;
+                for (let i = wrap.length - 1; i >= 0; i--)
+                    end = Fragment.from(wrap[i].copy(end));
+                let tr = state.tr.step(new ReplaceAroundStep($cut.pos - wrap.length, $cut.pos + after.nodeSize, $cut.pos + afterDepth, $cut.pos + after.nodeSize - afterDepth, new Slice(end, wrap.length, 0), 0, true));
+                dispatch(tr.scrollIntoView());
+            }
+            return true;
+        }
+    }
+    return false;
+}
+function selectTextblockSide(side) {
+    return function (state, dispatch) {
+        let sel = state.selection, $pos = side < 0 ? sel.$from : sel.$to;
+        let depth = $pos.depth;
+        while ($pos.node(depth).isInline) {
+            if (!depth)
+                return false;
+            depth--;
+        }
+        if (!$pos.node(depth).isTextblock)
+            return false;
+        if (dispatch)
+            dispatch(state.tr.setSelection(TextSelection.create(state.doc, side < 0 ? $pos.start(depth) : $pos.end(depth))));
+        return true;
+    };
+}
+/**
+Moves the cursor to the start of current text block.
+*/
+const selectTextblockStart = selectTextblockSide(-1);
+/**
+Moves the cursor to the end of current text block.
+*/
+const selectTextblockEnd = selectTextblockSide(1);
+// Parameterized commands
+/**
+Wrap the selection in a node of the given type with the given
+attributes.
+*/
+function wrapIn(nodeType, attrs = null) {
+    return function (state, dispatch) {
+        let { $from, $to } = state.selection;
+        let range = $from.blockRange($to), wrapping = range && findWrapping(range, nodeType, attrs);
+        if (!wrapping)
+            return false;
+        if (dispatch)
+            dispatch(state.tr.wrap(range, wrapping).scrollIntoView());
+        return true;
+    };
+}
+/**
+Returns a command that tries to set the selected textblocks to the
+given node type with the given attributes.
+*/
+function setBlockType(nodeType, attrs = null) {
+    return function (state, dispatch) {
+        let applicable = false;
+        for (let i = 0; i < state.selection.ranges.length && !applicable; i++) {
+            let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];
+            state.doc.nodesBetween(from, to, (node, pos) => {
+                if (applicable)
+                    return false;
+                if (!node.isTextblock || node.hasMarkup(nodeType, attrs))
+                    return;
+                if (node.type == nodeType) {
+                    applicable = true;
+                }
+                else {
+                    let $pos = state.doc.resolve(pos), index = $pos.index();
+                    applicable = $pos.parent.canReplaceWith(index, index + 1, nodeType);
+                }
+            });
+        }
+        if (!applicable)
+            return false;
+        if (dispatch) {
+            let tr = state.tr;
+            for (let i = 0; i < state.selection.ranges.length; i++) {
+                let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];
+                tr.setBlockType(from, to, nodeType, attrs);
+            }
+            dispatch(tr.scrollIntoView());
+        }
+        return true;
+    };
+}
+typeof navigator != "undefined" ? /Mac|iP(hone|[oa]d)/.test(navigator.platform)
+    // @ts-ignore
+    : typeof os != "undefined" && os.platform ? os.platform() == "darwin" : false;
+
+export { selectTextblockStart as a, selectTextblockEnd as b, selectParentNode as c, selectNodeForward as d, selectNodeBackward as e, lift as f, joinTextblockForward as g, joinTextblockBackward as h, joinForward as i, joinUp as j, joinDown as k, liftEmptyBlock as l, joinBackward as m, newlineInCode as n, exitCode as o, deleteSelection as p, createParagraphNear as q, setBlockType as s, wrapIn as w };