@limetech/lime-elements 39.44.6 → 39.45.1

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-form.entry.js

@@ -26301,19 +26301,28 @@ function hashString(string) {
     }
     return hash.toString(16);
 }
-/** Stringifies an `object`, sorts object fields in consistent order before stringifying it.
+/** Recursively serializes a value to JSON with object keys sorted alphabetically to produce
+ * a stable string representation.
  *
  * @param object - The object for which the sorted stringify is desired
  * @returns - The stringified object with keys sorted in a consistent order
  */
 function sortedJSONStringify(object) {
-    const allKeys = new Set();
-    // solution source: https://stackoverflow.com/questions/16167581/sort-object-properties-and-json-stringify/53593328#53593328
-    JSON.stringify(object, (key, value) => {
-        allKeys.add(key);
-        return value;
-    });
-    return JSON.stringify(object, Array.from(allKeys).sort());
+    function shouldIncludeValue(value) {
+        return value !== undefined && typeof value !== 'function' && typeof value !== 'symbol';
+    }
+    if (Array.isArray(object)) {
+        return `[${object.map((x) => (x === undefined ? 'undefined' : sortedJSONStringify(x))).join(',')}]`;
+    }
+    if (object === null || typeof object !== 'object') {
+        return JSON.stringify(typeof object === 'function' ? null : object); // Normalise functions
+    }
+    const record = object;
+    const sortedValues = Object.keys(record)
+        .sort()
+        .filter((key) => shouldIncludeValue(record[key]))
+        .map((key) => `${JSON.stringify(key)}:${sortedJSONStringify(record[key])}`);
+    return `{${sortedValues.join(',')}}`;
 }
 /** Stringifies an `object` and returns the hash of the resulting string. Sorts object fields
  * in consistent order before stringify to prevent different hash ids for the same object.
@@ -39691,6 +39700,17 @@ class AJV8Validator {
         }
         catch (err) {
             compilationError = err;
+            // AJV registers a schema in its internal cache before running meta-schema
+            // validation. When that check throws, the broken schema stays cached so
+            // subsequent compile() calls skip revalidation and return silently. Remove
+            // the entry so every call with an invalid schema consistently produces a
+            // compilation error. For schemas with $id the cache key is the id string;
+            // for anonymous schemas AJV uses the object reference as the key.
+            // Guard with compiledValidator === undefined so that a runtime error thrown
+            // by compiledValidator(formData) does not evict a correctly-compiled schema.
+            if (compiledValidator === undefined) {
+                this.ajv.removeSchema(schema[ID_KEY] !== undefined ? schema[ID_KEY] : schema);
+            }
         }
         let errors;
         if (compiledValidator) {
@@ -39797,13 +39817,17 @@ class AJV8Validator {
      */
     isValid(schema, formData, rootSchema) {
         var _a;
+        // schemaId and compiled are declared outside the try so the catch block can
+        // conditionally remove the broken schema from AJV's registry.
+        let schemaId;
+        let compiled = false;
         try {
             this.handleSchemaUpdate(rootSchema);
             // then rewrite the schema ref's to point to the rootSchema
             // this accounts for the case where schema have references to models
             // that lives in the rootSchema but not in the schema in question.
             const schemaWithIdRefPrefix = withIdRefPrefix(schema);
-            const schemaId = (_a = schemaWithIdRefPrefix[ID_KEY]) !== null && _a !== void 0 ? _a : hashForSchema(schemaWithIdRefPrefix);
+            schemaId = (_a = schemaWithIdRefPrefix[ID_KEY]) !== null && _a !== void 0 ? _a : hashForSchema(schemaWithIdRefPrefix);
             let compiledValidator;
             compiledValidator = this.ajv.getSchema(schemaId);
             if (compiledValidator === undefined) {
@@ -39814,12 +39838,20 @@ class AJV8Validator {
                     this.ajv.addSchema(schemaWithIdRefPrefix, schemaId).getSchema(schemaId) ||
                         this.ajv.compile(schemaWithIdRefPrefix);
             }
+            compiled = true;
             const result = compiledValidator(formData);
             return result;
         }
         catch (e) {
             // oxlint-disable-next-line no-console
             console.warn('Error encountered compiling schema:', e);
+            // Remove the broken schema from AJV's registry so a subsequent rawValidation
+            // or isValid call does not silently reuse a cached entry that bypassed
+            // meta-schema validation. Guard with !compiled so that a runtime error thrown
+            // by compiledValidator(formData) does not evict a correctly-compiled schema.
+            if (!compiled && schemaId !== undefined) {
+                this.ajv.removeSchema(schemaId);
+            }
             return false;
         }
     }

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';