@limetech/lime-elements 39.44.6 → 39.45.0

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/esm/limel-markdown.entry.js

@@ -1,5 +1,5 @@
 import { r as registerInstance, h, H as Host } from './index-BGxJfR2f.js';
-import { m as markdownToHTML } from './markdown-parser-BSQKleVw.js';
+import { m as markdownToHTML } from './markdown-parser-DrxxGLF5.js';
 import { g as globalConfig } from './config-Dnt5w_Bp.js';
 import { d as defaultSchema } from './index-CbciMfiU.js';
 import { a as adaptColorContrast } from './adapt-color-contrast-Dgcw_h7C.js';