@prosekit/core 0.7.6 → 0.7.8

package/dist/prosekit-core.js

@@ -15,13 +15,17 @@ import {
   htmlFromJSON,
   htmlFromNode,
   isAllSelection,
+  isElement,
+  isFragment,
   isMark,
   isMarkAbsent,
   isMarkActive,
   isNodeActive,
   isNodeSelection,
-  isNotNull,
+  isNotNullish,
   isProseMirrorNode,
+  isSelection,
+  isSlice,
   isTextSelection,
   jsonFromHTML,
   jsonFromNode,
@@ -35,7 +39,7 @@ import {
   stateFromJSON,
   toReversed,
   union
-} from "./chunk-MOSGJZHV.js";
+} from "./chunk-UKHJHMFE.js";
 
 // src/commands/add-mark.ts
 import "@prosekit/pm/model";
@@ -157,34 +161,31 @@ function removeMark(options) {
 }
 
 // src/utils/find-parent-node.ts
-function findParentNode(nodeType, $pos) {
-  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+function findParentNode(predicate, $pos) {
+  for (let depth = $pos.depth; depth >= 0; depth -= 1) {
     const node = $pos.node(depth);
-    if (node.type === nodeType) {
-      const from = $pos.before(depth);
-      const to = $pos.after(depth);
-      return {
-        from,
-        to
-      };
+    if (predicate(node)) {
+      const pos = depth === 0 ? 0 : $pos.before(depth);
+      const start = $pos.start(depth);
+      return { node, pos, start, depth };
     }
   }
-  return {
-    from: null,
-    to: null
-  };
+}
+
+// src/utils/find-parent-node-of-type.ts
+function findParentNodeOfType(type, $pos) {
+  const nodeType = getNodeType($pos.doc.type.schema, type);
+  return findParentNode((node) => node.type === nodeType, $pos);
 }
 
 // src/commands/remove-node.ts
 function removeNode(options) {
   return (state, dispatch) => {
-    const nodeType = getNodeType(state.schema, options.type);
     const $pos = typeof options.pos === "number" ? state.doc.resolve(options.pos) : state.selection.$anchor;
-    const { from, to } = findParentNode(nodeType, $pos);
-    if (from == null || to == null || from > to) {
-      return false;
-    }
-    dispatch == null ? void 0 : dispatch(state.tr.delete(from, to));
+    const found = findParentNodeOfType(options.type, $pos);
+    if (!found) return false;
+    const { pos, node } = found;
+    dispatch == null ? void 0 : dispatch(state.tr.delete(pos, pos + node.nodeSize));
     return true;
   };
 }
@@ -282,77 +283,18 @@ function setNodeAttrs(options) {
 }
 
 // src/commands/toggle-mark.ts
+import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function markApplies(doc, ranges, type) {
-  for (const { $from, $to } of ranges) {
-    let can = $from.depth == 0 ? doc.inlineContent && doc.type.allowsMarkType(type) : false;
-    doc.nodesBetween($from.pos, $to.pos, (node) => {
-      if (can) return false;
-      can = node.inlineContent && node.type.allowsMarkType(type);
-    });
-    if (can) return true;
-  }
-  return false;
-}
-function baseToggleMark(markType, attrs = null, options) {
-  const removeWhenPresent = (options && options.removeWhenPresent) !== false;
-  return function(state, dispatch) {
-    const { empty, $cursor, ranges } = state.selection;
-    if (empty && !$cursor || !markApplies(state.doc, ranges, markType))
-      return false;
-    if (dispatch) {
-      if ($cursor) {
-        if (markType.isInSet(state.storedMarks || $cursor.marks()))
-          dispatch(state.tr.removeStoredMark(markType));
-        else dispatch(state.tr.addStoredMark(markType.create(attrs)));
-      } else {
-        let add;
-        const tr = state.tr;
-        if (removeWhenPresent) {
-          add = !ranges.some(
-            (r) => state.doc.rangeHasMark(r.$from.pos, r.$to.pos, markType)
-          );
-        } else {
-          add = !ranges.every((r) => {
-            let missing = false;
-            tr.doc.nodesBetween(r.$from.pos, r.$to.pos, (node, pos, parent) => {
-              if (missing) return false;
-              missing = !markType.isInSet(node.marks) && !!parent && parent.type.allowsMarkType(markType) && !(node.isText && /^\s*$/.test(
-                node.textBetween(
-                  Math.max(0, r.$from.pos - pos),
-                  Math.min(node.nodeSize, r.$to.pos - pos)
-                )
-              ));
-            });
-            return !missing;
-          });
-        }
-        for (const { $from, $to } of ranges) {
-          if (!add) {
-            tr.removeMark($from.pos, $to.pos, markType);
-          } else {
-            let from = $from.pos, to = $to.pos;
-            const start = $from.nodeAfter, end = $to.nodeBefore;
-            const spaceStart = start && start.isText ? /^\s*/.exec(start.text)[0].length : 0;
-            const spaceEnd = end && end.isText ? /\s*$/.exec(end.text)[0].length : 0;
-            if (from + spaceStart < to) {
-              from += spaceStart;
-              to -= spaceEnd;
-            }
-            tr.addMark(from, to, markType.create(attrs));
-          }
-        }
-        dispatch(tr.scrollIntoView());
-      }
-    }
-    return true;
-  };
-}
-function toggleMark({ type, attrs }) {
+function toggleMark({
+  type,
+  attrs,
+  removeWhenPresent = false,
+  enterInlineAtoms = true
+}) {
   return (state, dispatch, view) => {
     return baseToggleMark(getMarkType(state.schema, type), attrs, {
-      removeWhenPresent: false
+      removeWhenPresent,
+      enterInlineAtoms
     })(state, dispatch, view);
   };
 }
@@ -433,12 +375,13 @@ function unsetMark(options) {
 // src/commands/wrap.ts
 import "@prosekit/pm/model";
 import { findWrapping } from "@prosekit/pm/transform";
-function wrap({ nodeType, attrs }) {
+function wrap(options) {
   return (state, dispatch) => {
     const { $from, $to } = state.selection;
     const range = $from.blockRange($to);
     if (!range) return false;
-    const wrapping = findWrapping(range, nodeType, attrs);
+    const nodeType = getNodeType(state.schema, options.type || options.nodeType);
+    const wrapping = findWrapping(range, nodeType, options.attrs);
     if (!wrapping) return false;
     dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
     return true;
@@ -502,6 +445,7 @@ function defineBaseCommands() {
 }
 
 // src/extensions/node-spec.ts
+import clone from "just-clone";
 import OrderedMap2 from "orderedmap";
 
 // src/facets/schema-spec.ts
@@ -524,10 +468,137 @@ var schemaSpecFacet = defineFacet({
   singleton: true
 });
 
-// src/utils/is-element.ts
-var hasElement = typeof Element !== "undefined";
-function isElement(value) {
-  return hasElement && value instanceof Element;
+// src/utils/array-grouping.ts
+function groupBy(items, keySelector) {
+  const result = {};
+  for (const item of items) {
+    const key = keySelector(item);
+    const values = result[key] || (result[key] = []);
+    values.push(item);
+  }
+  return result;
+}
+function groupEntries(entries) {
+  const result = {};
+  for (const [key, value] of entries) {
+    const values = result[key] || (result[key] = []);
+    values.push(value);
+  }
+  return result;
+}
+
+// src/utils/remove-undefined-values.ts
+function removeUndefinedValues(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/utils/merge-objects.ts
+function mergeObjects(...objects) {
+  const filteredObjects = objects.filter(isNotNullish).map(removeUndefinedValues);
+  return Object.assign({}, ...filteredObjects);
+}
+
+// src/utils/merge-specs.ts
+function mergeSpecs(a, b) {
+  var _a, _b, _c, _d, _e, _f;
+  const attrs = {};
+  const attrNames = /* @__PURE__ */ new Set([
+    ...Object.keys((_a = a.attrs) != null ? _a : {}),
+    ...Object.keys((_b = b.attrs) != null ? _b : {})
+  ]);
+  for (const name of attrNames) {
+    const attrSpecA = (_c = a.attrs) == null ? void 0 : _c[name];
+    const attrSpecB = (_d = b.attrs) == null ? void 0 : _d[name];
+    const attrSpecMerged = mergeObjects(attrSpecA, attrSpecB);
+    if (attrSpecMerged) {
+      attrs[name] = attrSpecMerged;
+    }
+  }
+  const parseDOM = [...(_e = a.parseDOM) != null ? _e : [], ...(_f = b.parseDOM) != null ? _f : []];
+  return mergeObjects(a, b, { attrs, parseDOM });
+}
+
+// src/utils/output-spec.ts
+function wrapOutputSpecAttrs(toDOM, options) {
+  return (node, ...args) => {
+    const dom = toDOM(node, ...args);
+    const pairs = options.map((option) => {
+      var _a;
+      return (_a = option.toDOM) == null ? void 0 : _a.call(option, node.attrs[option.attr]);
+    }).filter(isNotNullish);
+    return insertOutputSpecAttrs(dom, pairs);
+  };
+}
+function wrapTagParseRuleAttrs(rule, options) {
+  const existingGetAttrs = rule.getAttrs;
+  const existingAttrs = rule.attrs;
+  return {
+    ...rule,
+    getAttrs: (dom) => {
+      var _a, _b;
+      const baseAttrs = (_b = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs) != null ? _b : {};
+      if (baseAttrs === false || !dom || !isElement(dom)) {
+        return baseAttrs != null ? baseAttrs : null;
+      }
+      const insertedAttrs = {};
+      for (const option of options) {
+        if (option.parseDOM) {
+          insertedAttrs[option.attr] = option.parseDOM(dom);
+        }
+      }
+      return { ...baseAttrs, ...insertedAttrs };
+    }
+  };
+}
+function insertOutputSpecAttrs(dom, attrs) {
+  if (!dom) {
+    return dom;
+  }
+  if (Array.isArray(dom)) {
+    const rest = dom.slice(1);
+    let oldAttrs;
+    if (rest.length > 0 && (rest[0] == null || typeof rest[0] === "object")) {
+      oldAttrs = rest.shift();
+    } else {
+      oldAttrs = {};
+    }
+    const newAttrs = setObjectAttributes(oldAttrs, attrs);
+    return [dom[0], newAttrs, ...rest];
+  }
+  if (isElement(dom)) {
+    return setElementAttributes(dom, attrs);
+  }
+  if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+    return { ...dom, dom: setElementAttributes(dom.dom, attrs) };
+  }
+  return dom;
+}
+function setObjectAttributes(obj, attrs) {
+  obj = { ...obj };
+  for (const [key, value] of attrs) {
+    const oldValue = obj[key];
+    const newValue = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
+    obj[key] = newValue;
+  }
+  return obj;
+}
+function setElementAttributes(element, attrs) {
+  element = element.cloneNode(true);
+  for (const [key, value] of attrs) {
+    const oldValue = element.getAttribute(key);
+    const newValue = key === "style" ? joinStyles(value, typeof oldValue === "string" ? oldValue : "") : value;
+    element.setAttribute(key, newValue);
+  }
+  return element;
+}
+function joinStyles(...styles) {
+  return styles.map((style) => style.trim().replace(/;$/, "")).filter(Boolean).join("; ");
 }
 
 // src/extensions/node-spec.ts
@@ -543,105 +614,50 @@ var nodeSpecFacet = defineFacet({
   reducer: (payloads) => {
     let specs = OrderedMap2.from({});
     let topNodeName = void 0;
-    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
-    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNullish);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNullish);
     for (const { name, topNode, ...spec } of specPayloads) {
-      assert(!specs.get(name), `Node type ${name} can only be defined once`);
       if (topNode) {
         topNodeName = name;
       }
-      specs = specs.addToStart(name, spec);
+      const prevSpec = specs.get(name);
+      if (prevSpec) {
+        specs = specs.update(name, mergeSpecs(prevSpec, spec));
+      } else {
+        specs = specs.addToStart(name, spec);
+      }
     }
-    for (const {
-      type,
-      attr,
-      default: defaultValue,
-      splittable,
-      toDOM,
-      parseDOM
-    } of attrPayloads) {
-      const spec = specs.get(type);
-      assert(spec, `Node type ${type} must be defined`);
+    const groupedAttrs = groupBy(attrPayloads, (payload) => payload.type);
+    for (const [type, attrs] of Object.entries(groupedAttrs)) {
+      if (!attrs) continue;
+      const maybeSpec = specs.get(type);
+      assert(maybeSpec, `Node type ${type} must be defined`);
+      const spec = clone(maybeSpec);
       if (!spec.attrs) {
         spec.attrs = {};
       }
-      spec.attrs[attr] = {
-        default: defaultValue,
-        splittable
-      };
-      if (toDOM && spec.toDOM) {
-        const existingToDom = spec.toDOM;
-        spec.toDOM = (node) => {
-          const dom = existingToDom(node);
-          if (!dom) {
-            return dom;
-          }
-          const attrDOM = toDOM(node.attrs[attr]);
-          if (!attrDOM) {
-            return dom;
-          }
-          const [key, value] = attrDOM;
-          if (!key) {
-            return dom;
-          }
-          if (Array.isArray(dom)) {
-            if (typeof dom[1] === "object") {
-              return [
-                dom[0],
-                setObjectAttribute(
-                  dom[1],
-                  key,
-                  value
-                ),
-                ...dom.slice(2)
-              ];
-            } else {
-              return [dom[0], { [key]: value }, ...dom.slice(1)];
-            }
-          } else if (isElement(dom)) {
-            setElementAttribute(dom, key, value);
-          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
-            setElementAttribute(dom.dom, key, value);
-          }
-          return dom;
+      for (const attr of attrs) {
+        spec.attrs[attr.attr] = {
+          default: attr.default,
+          validate: attr.validate,
+          splittable: attr.splittable
         };
       }
-      if (parseDOM && spec.parseDOM) {
-        for (const rule of spec.parseDOM) {
-          const existingGetAttrs = rule.getAttrs;
-          const existingAttrs = rule.attrs;
-          rule.getAttrs = (dom) => {
-            var _a;
-            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
-            if (attrs === false || !dom || !isElement(dom)) {
-              return attrs != null ? attrs : null;
-            }
-            const value = parseDOM(dom);
-            return {
-              ...attrs,
-              [attr]: value
-            };
-          };
-        }
+      if (spec.toDOM) {
+        spec.toDOM = wrapOutputSpecAttrs(spec.toDOM, attrs);
+      }
+      if (spec.parseDOM) {
+        spec.parseDOM = spec.parseDOM.map(
+          (rule) => wrapTagParseRuleAttrs(rule, attrs)
+        );
       }
+      specs = specs.update(type, spec);
     }
     return { nodes: specs, topNode: topNodeName };
   },
   parent: schemaSpecFacet,
   singleton: true
 });
-function setObjectAttribute(obj, key, value) {
-  if (key === "style") {
-    value = `${value}${obj.style || ""}`;
-  }
-  return { ...obj, [key]: value };
-}
-function setElementAttribute(element, key, value) {
-  if (key === "style") {
-    value = `${value}${element.getAttribute("style") || ""}`;
-  }
-  element.setAttribute(key, value);
-}
 
 // src/extensions/doc.ts
 function defineDoc() {
@@ -781,20 +797,6 @@ function combineEventHandlers() {
   return [setHandlers, combinedEventHandler];
 }
 
-// src/utils/group-entries.ts
-function groupEntries(entries) {
-  const map = {};
-  for (const [key, value] of entries) {
-    const values = map[key];
-    if (!values) {
-      map[key] = [value];
-    } else {
-      values.push(value);
-    }
-  }
-  return map;
-}
-
 // src/extensions/events/dom-event.ts
 function defineDOMEventHandler(event, handler) {
   return defineFacetPayload(domEventFacet, [
@@ -959,6 +961,7 @@ var isApple = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navig
 import { chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
 import { Plugin as Plugin2, PluginKey as PluginKey4 } from "@prosekit/pm/state";
+import mapValues from "just-map-values";
 function defineKeymap(keymap2) {
   return defineFacetPayload(keymapFacet, [keymap2]);
 }
@@ -994,12 +997,10 @@ function mergeKeymaps(keymaps) {
       commands2.push(command);
     }
   }
-  return Object.fromEntries(
-    Object.entries(bindings).map(([key, commands2]) => [
-      key,
-      chainCommands(...commands2)
-    ])
-  );
+  return mapValues(bindings, mergeCommands);
+}
+function mergeCommands(commands2) {
+  return chainCommands(...commands2);
 }
 var keymapPluginKey = new PluginKey4("prosekit-keymap");
 
@@ -1064,6 +1065,7 @@ function defineBaseKeymap(options) {
 }
 
 // src/extensions/mark-spec.ts
+import clone2 from "just-clone";
 import OrderedMap3 from "orderedmap";
 function defineMarkSpec(options) {
   const payload = [options, void 0];
@@ -1076,78 +1078,52 @@ function defineMarkAttr(options) {
 var markSpecFacet = defineFacet({
   reducer: (payloads) => {
     let specs = OrderedMap3.from({});
-    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
-    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNullish);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNullish);
     for (const { name, ...spec } of specPayloads) {
-      assert(!specs.get(name), `Mark type ${name} can only be defined once`);
-      specs = specs.addToStart(name, spec);
+      const prevSpec = specs.get(name);
+      if (prevSpec) {
+        specs = specs.update(name, mergeSpecs(prevSpec, spec));
+      } else {
+        specs = specs.addToStart(name, spec);
+      }
     }
-    for (const {
-      type,
-      attr,
-      default: defaultValue,
-      toDOM,
-      parseDOM
-    } of attrPayloads) {
-      const spec = specs.get(type);
-      assert(spec, `Mark type ${type} must be defined`);
+    const groupedAttrs = groupBy(attrPayloads, (payload) => payload.type);
+    for (const [type, attrs] of Object.entries(groupedAttrs)) {
+      if (!attrs) continue;
+      const maybeSpec = specs.get(type);
+      assert(maybeSpec, `Mark type ${type} must be defined`);
+      const spec = clone2(maybeSpec);
       if (!spec.attrs) {
         spec.attrs = {};
       }
-      spec.attrs[attr] = { default: defaultValue };
-      if (toDOM && spec.toDOM) {
-        const existingToDom = spec.toDOM;
-        spec.toDOM = (mark, inline) => {
-          const dom = existingToDom(mark, inline);
-          if (!dom) {
-            return dom;
-          }
-          const attrDOM = toDOM(mark.attrs[attr]);
-          if (!attrDOM) {
-            return dom;
-          }
-          const [key, value] = attrDOM;
-          if (!key) {
-            return dom;
-          }
-          if (Array.isArray(dom)) {
-            if (typeof dom[1] === "object") {
-              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
-            } else {
-              return [dom[0], { [key]: value }, ...dom.slice(1)];
-            }
-          } else if (isElement(dom)) {
-            dom.setAttribute(key, value);
-          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
-            dom.dom.setAttribute(key, value);
-          }
-          return dom;
+      for (const attr of attrs) {
+        spec.attrs[attr.attr] = {
+          default: attr.default,
+          validate: attr.validate
         };
       }
-      if (parseDOM && spec.parseDOM) {
-        for (const rule of spec.parseDOM) {
-          const existingGetAttrs = rule.getAttrs;
-          const existingAttrs = rule.attrs;
-          rule.getAttrs = (dom) => {
-            var _a;
-            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
-            if (attrs === false || !dom || !isElement(dom)) {
-              return attrs != null ? attrs : null;
-            }
-            const value = parseDOM(dom);
-            return {
-              ...attrs,
-              [attr]: value
-            };
-          };
-        }
+      if (spec.toDOM) {
+        spec.toDOM = wrapOutputSpecAttrs(spec.toDOM, attrs);
+      }
+      if (spec.parseDOM) {
+        spec.parseDOM = spec.parseDOM.map(
+          (rule) => wrapParseRuleAttrs(rule, attrs)
+        );
       }
+      specs = specs.update(type, spec);
     }
     return { marks: specs, nodes: {} };
   },
   parent: schemaSpecFacet,
   singleton: true
 });
+function wrapParseRuleAttrs(rule, attrs) {
+  if (rule.tag) {
+    return wrapTagParseRuleAttrs(rule, attrs);
+  }
+  return rule;
+}
 
 // src/extensions/node-view.ts
 import { PluginKey as PluginKey5, ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
@@ -1187,8 +1163,8 @@ var nodeViewFactoryFacet = defineFacet({
   reducer: (inputs) => {
     if (isServer) return [];
     const nodeViews = {};
-    const factories = inputs.map((x) => x[0]).filter(isNotNull);
-    const options = inputs.map((x) => x[1]).filter(isNotNull);
+    const factories = inputs.map((x) => x[0]).filter(isNotNullish);
+    const options = inputs.map((x) => x[1]).filter(isNotNullish);
     for (const { group, name, args } of options) {
       const factory = factories.find((factory2) => factory2.group === group);
       if (!factory) continue;
@@ -1252,6 +1228,16 @@ var canUseRegexLookbehind = cache(() => {
 import clsxLite from "clsx/lite";
 var clsx = clsxLite;
 
+// src/utils/collect-children.ts
+import "@prosekit/pm/model";
+function collectChildren(parent) {
+  const children = [];
+  for (let i = 0; i < parent.childCount; i++) {
+    children.push(parent.child(i));
+  }
+  return children;
+}
+
 // src/utils/collect-nodes.ts
 import { ProseMirrorFragment, ProseMirrorNode as ProseMirrorNode2 } from "@prosekit/pm/model";
 function collectNodes(content) {
@@ -1341,6 +1327,7 @@ export {
   assert,
   canUseRegexLookbehind,
   clsx,
+  collectChildren,
   collectNodes,
   containsInlineNode,
   createEditor,
@@ -1385,6 +1372,8 @@ export {
   elementFromJSON,
   elementFromNode,
   expandMark,
+  findParentNode,
+  findParentNodeOfType,
   getMarkType,
   getNodeType,
   htmlFromJSON,
@@ -1393,12 +1382,15 @@ export {
   isAllSelection,
   isApple,
   isAtBlockStart,
+  isFragment,
   isInCodeBlock,
   isMark,
   isMarkAbsent,
   isMarkActive,
   isNodeSelection,
   isProseMirrorNode,
+  isSelection,
+  isSlice,
   isTextSelection,
   jsonFromHTML,
   jsonFromNode,