@limetech/lime-elements 39.44.5 → 39.45.0

package/dist/collection/components/text-editor/prosemirror-adapter/menu/menu-command-utils/list-utils.js

@@ -0,0 +1,270 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { NodeRange, } from "prosemirror-model";
+import { canSplit, findWrapping } from "prosemirror-transform";
+/**
+ * Whether the selection touches top-level blocks that cannot become list
+ * items (list_item requires a leading paragraph, so headings, blockquotes,
+ * code blocks and tables are not listable).
+ *
+ * @param state - the current editor state
+ * @returns true when a non-listable block intersects the selection
+ */
+export const selectionHasNonListableBlock = (state) => {
+    const { from, to } = state.selection;
+    const { schema } = state;
+    let found = false;
+    state.doc.nodesBetween(from, to, (node, _pos, parent) => {
+        if (found) {
+            return false;
+        }
+        const isTopLevelBlock = (parent === null || parent === void 0 ? void 0 : parent.type) === schema.topNodeType;
+        const listable = node.type === schema.nodes.paragraph ||
+            node.type === schema.nodes.list_item ||
+            isListNode(node, schema);
+        if (isTopLevelBlock && !listable) {
+            found = true;
+            return false;
+        }
+        return !isTopLevelBlock || isListNode(node, schema);
+    });
+    return found;
+};
+/**
+ * Classifies the selection for the list command ladder.
+ *
+ * @param state - the current editor state
+ * @param listType - the list type the command targets
+ * @returns the ladder branch to take, plus the innermost list depth when
+ * the selection sits inside a list
+ */
+export const resolveListContext = (state, listType) => {
+    const { $from, $to } = state.selection;
+    const fromDepth = innermostListDepth(state);
+    const sameTopLevelBlock = state.selection.empty ||
+        $from.sameParent($to) ||
+        $from.node(1) === $to.node(1);
+    if (fromDepth !== null && sameTopLevelBlock) {
+        return listContextAt($from, fromDepth, listType);
+    }
+    if (fromDepth === null && sameTopLevelBlock) {
+        return { kind: 'no-list', listDepth: null, singleBlock: true };
+    }
+    // The range spans multiple top-level blocks: uniform paragraphs mean a
+    // plain wrap; lists that are all of the target type mean a toggle;
+    // any other list in the mix means unification.
+    const listTypes = new Set();
+    let sawParagraph = false;
+    const startIndex = $from.index(0);
+    const endIndex = Math.min($to.index(0), state.doc.childCount - 1);
+    for (let i = startIndex; i <= endIndex; i++) {
+        const child = state.doc.child(i);
+        if (isListNode(child, state.schema)) {
+            listTypes.add(child.type);
+        }
+        else if (child.type === state.schema.nodes.paragraph) {
+            sawParagraph = true;
+        }
+    }
+    const uniformTargetLists = !sawParagraph && listTypes.size === 1 && listTypes.has(listType);
+    if (uniformTargetLists && fromDepth !== null) {
+        return listContextAt($from, fromDepth, listType);
+    }
+    if (listTypes.size > 0) {
+        return { kind: 'mixed', listDepth: null };
+    }
+    return { kind: 'no-list', listDepth: null, singleBlock: false };
+};
+/**
+ * Converts the innermost list around the selection to the target list type.
+ * bullet_list and ordered_list share the list_item+ content model, so the
+ * node can change type in place.
+ *
+ * @param state - the current editor state
+ * @param listDepth - depth of the list node, from resolveListContext
+ * @param targetType - the list type to convert to
+ * @param dispatch - the dispatch function; omit for a dry-run capability check
+ * @returns true when the conversion applies
+ */
+export const convertInnermostList = (state, listDepth, targetType, dispatch) => {
+    const { $from } = state.selection;
+    const pos = $from.before(listDepth);
+    const node = state.doc.nodeAt(pos);
+    if (!node) {
+        return false;
+    }
+    if (dispatch) {
+        dispatch(state.tr
+            .setNodeMarkup(pos, targetType, listAttrsFor(targetType, node.attrs, state.schema))
+            .scrollIntoView());
+    }
+    return true;
+};
+/**
+ * Turns a mixed top-level selection (paragraphs and lists) into a single
+ * list of the target type: paragraph runs are wrapped, lists are converted
+ * in place, and adjacent same-type lists are joined. Nesting inside
+ * converted lists is preserved.
+ *
+ * @param state - the current editor state
+ * @param targetType - the list type to unify into
+ * @param dispatch - the dispatch function; omit for a dry-run capability check
+ * @returns true when the unification applies
+ */
+export const unifyToList = (state, targetType, dispatch) => {
+    const { $from, $to } = state.selection;
+    if ($from.depth === 0 || $to.depth === 0) {
+        return false;
+    }
+    if (dispatch === undefined) {
+        return true;
+    }
+    const tr = state.tr;
+    convertListsAndWrapRuns(tr, state, targetType, $from.index(0), $to.index(0));
+    joinAdjacentLists(tr, targetType, tr.mapping.map($from.before(1)), mapKeepBefore(tr, $to.after(1)));
+    dispatch(tr.scrollIntoView());
+    return true;
+};
+/**
+ * Wraps a dispatch so that after a list is wrapped around the selection,
+ * adjacent top-level lists of the same type are joined with it.
+ *
+ * @param state - the editor state the wrap command runs on
+ * @param targetType - the list type being wrapped
+ * @param dispatch - the dispatch function; omitted for a dry-run capability check
+ * @returns the wrapped dispatch, or undefined when no dispatch was given
+ */
+export const joinAdjacentListsOnDispatch = (state, targetType, dispatch) => {
+    if (!dispatch) {
+        return undefined;
+    }
+    const { $from, $to } = state.selection;
+    return (tr) => {
+        // The new list's outer boundaries: the start maps before the
+        // inserted wrapping, the end maps after it.
+        const start = mapKeepBefore(tr, $from.before(1));
+        const end = tr.mapping.map($to.after(1));
+        // Back to front, so the earlier boundary stays valid after a join.
+        joinSameTypeBoundary(tr, targetType, end);
+        joinSameTypeBoundary(tr, targetType, start);
+        dispatch(tr);
+    };
+};
+const joinSameTypeBoundary = (tr, targetType, boundary) => {
+    var _a, _b;
+    if (boundary <= 0 || boundary >= tr.doc.content.size) {
+        return;
+    }
+    const $boundary = tr.doc.resolve(boundary);
+    if (((_a = $boundary.nodeBefore) === null || _a === void 0 ? void 0 : _a.type) === targetType &&
+        ((_b = $boundary.nodeAfter) === null || _b === void 0 ? void 0 : _b.type) === targetType) {
+        tr.join(boundary);
+    }
+};
+const isListNode = (node, schema) => node.type === schema.nodes.bullet_list ||
+    node.type === schema.nodes.ordered_list;
+const innermostListDepth = (state) => {
+    const { $from } = state.selection;
+    for (let depth = $from.depth; depth > 0; depth--) {
+        if (isListNode($from.node(depth), state.schema)) {
+            return depth;
+        }
+    }
+    return null;
+};
+const listContextAt = ($from, listDepth, listType) => ({
+    kind: $from.node(listDepth).type === listType ? 'same-type' : 'other-type',
+    listDepth: listDepth,
+});
+const listAttrsFor = (targetType, attrs, schema) => {
+    var _a;
+    if (targetType === schema.nodes.ordered_list) {
+        return Object.assign(Object.assign({}, attrs), { order: (_a = attrs.order) !== null && _a !== void 0 ? _a : 1 });
+    }
+    const { order } = attrs, withoutOrder = __rest(attrs, ["order"]);
+    return withoutOrder;
+};
+const mapKeepBefore = (tr, position) => 
+// ProseMirror's Mapping.map takes (pos, assoc); the unicorn rule
+// misreads it as Array#map with a `this` argument.
+// eslint-disable-next-line unicorn/no-array-method-this-argument
+tr.mapping.map(position, -1);
+const wrapRunInList = (tr, targetType, runStart, runEnd) => {
+    const $start = tr.doc.resolve(tr.mapping.map(runStart) + 1);
+    const $end = tr.doc.resolve(mapKeepBefore(tr, runEnd) - 1);
+    const range = new NodeRange($start, $end, 0);
+    const wrapping = findWrapping(range, targetType);
+    if (!wrapping) {
+        return;
+    }
+    tr.wrap(range, wrapping);
+    // tr.wrap puts the whole run inside a single list_item; splitting at
+    // each block boundary gives one item per block, the same shape
+    // wrapInList produces.
+    const listIndex = wrapping.findIndex((entry) => entry.type === targetType);
+    const splitDepth = wrapping.length - (listIndex + 1);
+    let splitPos = range.start + wrapping.length;
+    for (let i = range.startIndex; i < range.endIndex; i++) {
+        if (i > range.startIndex && canSplit(tr.doc, splitPos, splitDepth)) {
+            tr.split(splitPos, splitDepth);
+            splitPos += 2 * splitDepth;
+        }
+        splitPos += range.parent.child(i).nodeSize;
+    }
+};
+const convertListsAndWrapRuns = (tr, state, targetType, startIndex, endIndex) => {
+    // Positions computed against the pre-transform doc are mapped through
+    // tr.mapping when applied.
+    const doc = state.doc;
+    let runStart = null;
+    let runEnd = null;
+    let pos = 0;
+    for (let i = 0; i < doc.childCount; i++) {
+        const child = doc.child(i);
+        const inRange = i >= startIndex && i <= endIndex;
+        const isList = isListNode(child, state.schema);
+        if (inRange && child.type === state.schema.nodes.paragraph) {
+            runStart = runStart !== null && runStart !== void 0 ? runStart : pos;
+            runEnd = pos + child.nodeSize;
+        }
+        else if (runStart !== null && runEnd !== null) {
+            wrapRunInList(tr, targetType, runStart, runEnd);
+            runStart = null;
+            runEnd = null;
+        }
+        if (inRange && isList && child.type !== targetType) {
+            tr.setNodeMarkup(tr.mapping.map(pos), targetType, listAttrsFor(targetType, child.attrs, state.schema));
+        }
+        pos += child.nodeSize;
+    }
+    if (runStart !== null && runEnd !== null) {
+        wrapRunInList(tr, targetType, runStart, runEnd);
+    }
+};
+const joinAdjacentLists = (tr, targetType, mappedFrom, mappedTo) => {
+    // Scan the transformed doc's top-level boundaries back to front, so
+    // earlier join positions stay valid as joins shrink the doc.
+    const boundaries = [];
+    let boundary = 0;
+    for (let i = 0; i < tr.doc.childCount; i++) {
+        boundary += tr.doc.child(i).nodeSize;
+        boundaries.push(boundary);
+    }
+    for (let i = boundaries.length - 1; i >= 0; i--) {
+        const joinPos = boundaries[i];
+        if (joinPos <= mappedFrom || joinPos > mappedTo + 1) {
+            continue;
+        }
+        joinSameTypeBoundary(tr, targetType, joinPos);
+    }
+};

package/dist/collection/components/text-editor/prosemirror-adapter/menu/menu-command-utils/node-utils.js

@@ -0,0 +1,15 @@
+/**
+ * Finds the depth of the nearest ancestor of a given node type.
+ *
+ * @param $pos - The resolved position in the document.
+ * @param type - The node type to search for.
+ * @returns The depth at which the node is found, or null if not found.
+ */
+export const findAncestorDepthOfType = ($pos, type) => {
+    for (let depth = $pos.depth; depth > 0; depth--) {
+        if ($pos.node(depth).type === type) {
+            return depth;
+        }
+    }
+    return null;
+};

package/dist/collection/components/text-editor/prosemirror-adapter/menu/menu-commands.js

@@ -1,47 +1,10 @@
 import { toggleMark, setBlockType, wrapIn, lift } from "prosemirror-commands";
-import { findWrapping, liftTarget } from "prosemirror-transform";
-import { TextSelection } from "prosemirror-state";
+import { wrapInList, liftListItem } from "prosemirror-schema-list";
+import { AllSelection, EditorState, TextSelection, } from "prosemirror-state";
 import { EditorMenuTypes, LevelMapping } from "./types";
 import { getLinkAttributes } from "../plugins/link/utils";
-const setActiveMethodForMark = (command, markType) => {
-    command.active = (state) => {
-        const { from, $from, to, empty } = state.selection;
-        if (empty) {
-            return !!markType.isInSet(state.storedMarks || $from.marks());
-        }
-        else {
-            return state.doc.rangeHasMark(from, to, markType);
-        }
-    };
-};
-const setActiveMethodForNode = (command, nodeType, level) => {
-    command.active = (state) => {
-        const { $from } = state.selection;
-        const node = $from.node($from.depth);
-        if (node && node.type.name === nodeType.name) {
-            if (nodeType.name === LevelMapping.Heading && level) {
-                return node.attrs.level === level;
-            }
-            return true;
-        }
-        return false;
-    };
-};
-const setActiveMethodForWrap = (command, nodeType) => {
-    command.active = (state) => {
-        const { from, to } = state.selection;
-        for (let pos = from; pos <= to; pos++) {
-            const resolvedPos = state.doc.resolve(pos);
-            for (let i = resolvedPos.depth; i > 0; i--) {
-                const node = resolvedPos.node(i);
-                if (node && node.type.name === nodeType.name) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    };
-};
+import { setActiveMethodForMark, setActiveMethodForNode, setActiveMethodForWrap, } from "./menu-command-utils/active-state-utils";
+import { resolveListContext, convertInnermostList, joinAdjacentListsOnDispatch, selectionHasNonListableBlock, unifyToList, } from "./menu-command-utils/list-utils";
 const createInsertLinkCommand = (schema, _, link) => {
     const command = (state, dispatch) => {
         const { from, to } = state.selection;
@@ -101,11 +64,13 @@ const toggleNodeType = (schema, type, attrs = {}, shouldWrap = false) => {
     const paragraphType = schema.nodes.paragraph;
     return (state, dispatch) => {
         const { $from, $to } = state.selection;
-        const hasActiveWrap = $from.node($from.depth - 1).type === nodeType;
         if (state.selection instanceof TextSelection &&
             // Ensure selection is within the same parent block
             // We don't want toggling block types across multiple blocks
             $from.sameParent($from.doc.resolve($to.pos))) {
+            // Resolved only under the TextSelection guard: an AllSelection
+            // resolves at depth 0, where there is no parent node to read.
+            const hasActiveWrap = $from.node($from.depth - 1).type === nodeType;
             if ($from.parent.type === nodeType) {
                 if (dispatch) {
                     dispatch(state.tr.setBlockType($from.pos, $to.pos, paragraphType));
@@ -162,40 +127,85 @@ const createWrapInCommand = (schema, nodeType) => {
     setActiveMethodForWrap(command, type);
     return command;
 };
-const toggleList = (listType) => {
-    return (state, dispatch) => {
-        const { $from, $to } = state.selection;
-        const range = $from.blockRange($to);
-        if (!range) {
+// Select-all produces an AllSelection, whose endpoints resolve at the
+// document level where list commands cannot operate. Re-anchoring it as
+// a TextSelection over the same content lets the list ladder (and the
+// delegated prosemirror-schema-list commands) treat select-all like any
+// other full-content selection.
+const withTextSelection = (state) => {
+    if (!(state.selection instanceof AllSelection)) {
+        return state;
+    }
+    const selection = TextSelection.between(state.doc.resolve(0), state.doc.resolve(state.doc.content.size));
+    // A plugin-free scratch state on the shared doc: only feed it
+    // commands driven by doc and selection.
+    return EditorState.create({
+        doc: state.doc,
+        selection: selection,
+        storedMarks: state.storedMarks,
+    });
+};
+/**
+ * Creates a command for toggling list types.
+ *
+ * @param schema - The ProseMirror schema.
+ * @param listTypeName - The name of the list type to toggle.
+ * @returns A command for toggling list types.
+ */
+export const createListCommand = (schema, listTypeName) => {
+    const type = schema.nodes[listTypeName];
+    if (!type) {
+        throw new Error(`List type "${listTypeName}" not found in schema`);
+    }
+    const itemType = schema.nodes.list_item;
+    if (!itemType) {
+        throw new Error('Node type "list_item" not found in schema');
+    }
+    // The keymap invokes the command directly, so the command body applies
+    // the same applicability rules as `allowed` to keep keyboard and
+    // toolbar behavior identical.
+    const command = (state, dispatch) => {
+        state = withTextSelection(state);
+        if (!(state.selection instanceof TextSelection)) {
             return false;
         }
-        const wrapping = range && findWrapping(range, listType);
-        if (wrapping) {
-            // Wrap the selection in a list
-            if (dispatch) {
-                dispatch(state.tr.wrap(range, wrapping).scrollIntoView());
-            }
-            return true;
+        const context = resolveListContext(state, type);
+        if (context.kind === 'same-type') {
+            return liftListItem(itemType)(state, dispatch);
         }
-        else {
-            // Check if we are in a list item and lift out of the list
-            const liftRange = range && liftTarget(range);
-            if (liftRange !== null) {
-                if (dispatch) {
-                    dispatch(state.tr.lift(range, liftRange).scrollIntoView());
-                }
-                return true;
+        if (context.kind === 'other-type') {
+            return convertInnermostList(state, context.listDepth, type, dispatch);
+        }
+        if (context.kind === 'no-list') {
+            // For a single block the schema decides, through the wrap
+            // command itself; multi-block selections keep the stricter
+            // gate so unify cannot half-apply.
+            if (!context.singleBlock && selectionHasNonListableBlock(state)) {
+                return false;
             }
+            return wrapInList(type)(state, joinAdjacentListsOnDispatch(state, type, dispatch));
+        }
+        if (selectionHasNonListableBlock(state)) {
             return false;
         }
+        return unifyToList(state, type, dispatch);
+    };
+    command.allowed = (state) => {
+        state = withTextSelection(state);
+        if (!(state.selection instanceof TextSelection)) {
+            return false;
+        }
+        const context = resolveListContext(state, type);
+        // Inside a list, toggling or converting is always applicable, even
+        // when a non-listable ancestor wraps the list.
+        if (context.kind === 'same-type' || context.kind === 'other-type') {
+            return true;
+        }
+        if (context.kind === 'no-list' && context.singleBlock) {
+            return wrapInList(type)(state);
+        }
+        return !selectionHasNonListableBlock(state);
     };
-};
-const createListCommand = (schema, listType) => {
-    const type = schema.nodes[listType];
-    if (!type) {
-        throw new Error(`List type "${listType}" not found in schema`);
-    }
-    const command = toggleList(type);
     setActiveMethodForWrap(command, type);
     return command;
 };
@@ -232,6 +242,8 @@ export class MenuCommandFactory {
             'Mod-Shift-1': this.getCommand(EditorMenuTypes.HeaderLevel1),
             'Mod-Shift-2': this.getCommand(EditorMenuTypes.HeaderLevel2),
             'Mod-Shift-3': this.getCommand(EditorMenuTypes.HeaderLevel3),
+            'Mod-Shift-7': this.getCommand(EditorMenuTypes.OrderedList),
+            'Mod-Shift-8': this.getCommand(EditorMenuTypes.BulletList),
             'Mod-Shift-X': this.getCommand(EditorMenuTypes.Strikethrough),
             'Mod-`': this.getCommand(EditorMenuTypes.Code),
             'Mod-Shift-C': this.getCommand(EditorMenuTypes.CodeBlock),

package/dist/collection/components/text-editor/prosemirror-adapter/plugins/list-key-handler.js

@@ -0,0 +1,44 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import { sinkListItem, liftListItem } from "prosemirror-schema-list";
+import { findAncestorDepthOfType } from "../menu/menu-command-utils/node-utils";
+export const listKeyHandlerPluginKey = new PluginKey('listKeyHandlerPlugin');
+/**
+ * Creates a plugin for handling Tab and Shift+Tab inside list items:
+ * Tab indents the item and Shift+Tab outdents it. Enter and Backspace
+ * are handled by the base keymap (splitListItem and joinBackward), which
+ * runs before this plugin.
+ *
+ * @param schema - The document schema
+ * @returns A ProseMirror plugin for handling list-specific key events
+ */
+export function createListKeyHandlerPlugin(schema) {
+    return new Plugin({
+        key: listKeyHandlerPluginKey,
+        props: {
+            handleKeyDown: (view, event) => {
+                if (event.key !== 'Tab') {
+                    return false;
+                }
+                const { state } = view;
+                const { $from } = state.selection;
+                const inListItem = findAncestorDepthOfType($from, schema.nodes.list_item) !==
+                    null;
+                if (!inListItem) {
+                    return false;
+                }
+                // Inside a list item, Tab and Shift+Tab are always handled
+                // so focus never leaves the editor mid-list, even when the
+                // indent or outdent itself cannot apply.
+                event.preventDefault();
+                if (event.shiftKey) {
+                    liftListItem(schema.nodes.list_item)(state, view.dispatch);
+                    return true;
+                }
+                // Sinking fails on first items (no preceding sibling to
+                // become the parent); Tab is still swallowed.
+                sinkListItem(schema.nodes.list_item)(state, view.dispatch);
+                return true;
+            },
+        },
+    });
+}

package/dist/collection/components/text-editor/prosemirror-adapter/prosemirror-adapter.js

@@ -87,13 +87,14 @@ export class ProsemirrorAdapter {
             return newItem;
         };
         this.updateActiveActionBarItems = (activeTypes, allowedTypes) => {
-            const newItems = getTextEditorMenuItems().map((item) => {
+            this.actionBarItems = getTextEditorMenuItems()
+                .map(this.getTranslatedItem)
+                .map((item) => {
                 if (isItem(item)) {
-                    return Object.assign(Object.assign({}, item), { selected: activeTypes[item.value], allowed: allowedTypes[item.value] });
+                    return Object.assign(Object.assign({}, item), { selected: activeTypes[item.value], disabled: !allowedTypes[item.value] });
                 }
                 return item;
             });
-            this.actionBarItems = newItems.filter((item) => isItem(item) ? item.allowed : true);
         };
         this.handleTransaction = (transaction) => {
             this.transactionFired = true;

package/dist/collection/util/keycodes.js

@@ -3,7 +3,10 @@
 export const TAB = 'Tab';
 export const ENTER = 'Enter';
 export const ESCAPE = 'Escape';
+/** `KeyboardEvent.code` for the space bar. NOT a `KeyboardEvent.key`. */
 export const SPACE = 'Space';
+/** `KeyboardEvent.key` for the space bar. */
+export const SPACEBAR = ' ';
 export const BACKSPACE = 'Backspace';
 export const DELETE = 'Delete';
 export const ARROW_UP = 'ArrowUp';