New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@prosekit/core

Package Overview
Dependencies
Maintainers
0
Versions
112
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@prosekit/core - npm Package Compare versions

Comparing version

0.0.0-next-20240724173606
to
0.0.0-next-20240901092634

dist/chunk-RNBMCB5M.js

35

dist/prosekit-core-test.js

@@ -7,7 +7,11 @@ import {

createNodeActions,
isProseMirrorNode,
setupEditorExtension
} from "./chunk-MOSGJZHV.js";
} from "./chunk-RNBMCB5M.js";
// src/test/test-editor.ts
import { EditorState, NodeSelection, TextSelection } from "@prosekit/pm/state";
import {
NodeSelection,
TextSelection
} from "@prosekit/pm/state";

@@ -57,3 +61,3 @@ // src/test/test-builder.ts

return children.map((node) => {
const newNode = node.mark([mark]);
const newNode = node.mark(mark.addToSet(node.marks));
newNode.tags = node.tags;

@@ -90,2 +94,8 @@ return newNode;

}
setContent(content, selection) {
return super.setContent(
content,
isProseMirrorNode(content) && !selection ? getSelection(content) : selection
);
}
};

@@ -110,17 +120,3 @@ var TestEditor = class extends Editor {

set(doc) {
assert(
doc.type.schema === this.schema,
"Document schema does not match editor schema"
);
assert(
doc.type === this.schema.topNodeType,
"Document type does not match editor top node type"
);
const selection = getSelection(doc);
const state = EditorState.create({
doc,
selection,
plugins: this.state.plugins
});
this.updateState(state);
return this.setContent(doc);
}

@@ -133,3 +129,4 @@ dispatchEvent(event) {

const extension = setupEditorExtension(options);
return new TestEditor(new TestEditorInstance(extension));
const instance = new TestEditorInstance(extension);
return new TestEditor(instance);
}

@@ -136,0 +133,0 @@ export {

11

dist/prosekit-core.d.ts

@@ -7,2 +7,4 @@ export { addMark } from './_tsup-dts-rollup';

export { InsertNodeOptions } from './_tsup-dts-rollup';
export { insertDefaultBlock } from './_tsup-dts-rollup';
export { InsertDefaultBlockOptions } from './_tsup-dts-rollup';
export { removeMark } from './_tsup-dts-rollup';

@@ -108,3 +110,2 @@ export { RemoveMarkOptions } from './_tsup-dts-rollup';

export { pluginFacet } from './_tsup-dts-rollup';
export { PluginExtension } from './_tsup-dts-rollup';
export { PluginPayload } from './_tsup-dts-rollup';

@@ -128,2 +129,3 @@ export { defineText } from './_tsup-dts-rollup';

export { ExtractNodes } from './_tsup-dts-rollup';
export { PlainExtension } from './_tsup-dts-rollup';
export { Union } from './_tsup-dts-rollup';

@@ -148,2 +150,3 @@ export { UnionExtension } from './_tsup-dts-rollup';

export { clsx } from './_tsup-dts-rollup';
export { collectChildren } from './_tsup-dts-rollup';
export { collectNodes } from './_tsup-dts-rollup';

@@ -154,2 +157,5 @@ export { NodeContent } from './_tsup-dts-rollup';

export { isApple } from './_tsup-dts-rollup';
export { findParentNode } from './_tsup-dts-rollup';
export { FindParentNodeResult } from './_tsup-dts-rollup';
export { findParentNodeOfType } from './_tsup-dts-rollup';
export { _getId } from './_tsup-dts-rollup';

@@ -179,7 +185,10 @@ export { getMarkType } from './_tsup-dts-rollup';

export { isAllSelection } from './_tsup-dts-rollup';
export { isFragment } from './_tsup-dts-rollup';
export { isMark } from './_tsup-dts-rollup';
export { isNodeSelection } from './_tsup-dts-rollup';
export { isProseMirrorNode } from './_tsup-dts-rollup';
export { isSelection } from './_tsup-dts-rollup';
export { isSlice } from './_tsup-dts-rollup';
export { isTextSelection } from './_tsup-dts-rollup';
export { withSkipCodeBlock } from './_tsup-dts-rollup';
export { OBJECT_REPLACEMENT_CHARACTER } from './_tsup-dts-rollup';

626

dist/prosekit-core.js

@@ -18,2 +18,4 @@ import {

isAllSelection,
isElement,
isFragment,
isMark,

@@ -24,4 +26,6 @@ isMarkAbsent,

isNodeSelection,
isNotNull,
isNotNullish,
isProseMirrorNode,
isSelection,
isSlice,
isTextSelection,

@@ -40,6 +44,5 @@ jsonFromHTML,

union
} from "./chunk-MOSGJZHV.js";
} from "./chunk-RNBMCB5M.js";
// src/commands/add-mark.ts
import "@prosekit/pm/model";
function addMark(options) {

@@ -145,4 +148,38 @@ return (state, dispatch) => {

// src/commands/insert-default-block.ts
import { TextSelection as TextSelection3 } from "@prosekit/pm/state";
// src/utils/default-block-at.ts
function defaultBlockAt(match) {
for (let i = 0; i < match.edgeCount; i++) {
const { type } = match.edge(i);
if (type.isTextblock && !type.hasRequiredAttrs()) return type;
}
return null;
}
// src/commands/insert-default-block.ts
function insertDefaultBlock(options) {
return (state, dispatch) => {
const $pos = (options == null ? void 0 : options.pos) == null ? state.selection.$to : state.doc.resolve(options.pos);
const depth = $pos.parent.isTextblock ? $pos.depth - 1 : $pos.depth;
const parent = $pos.node(depth);
const index = $pos.indexAfter(depth);
const type = defaultBlockAt(parent.contentMatchAt(index));
if (!type) return false;
if (dispatch) {
const pos = $pos.posAtIndex(index, depth);
const node = type.createAndFill();
if (!node) return false;
const tr = state.tr.insert(pos, node);
const selection = TextSelection3.findFrom(tr.doc.resolve(pos), 1);
if (!selection) return false;
tr.setSelection(selection);
dispatch(tr.scrollIntoView());
}
return true;
};
}
// src/commands/remove-mark.ts
import "@prosekit/pm/model";
function removeMark(options) {

@@ -164,30 +201,27 @@ return (state, dispatch) => {

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

@@ -198,3 +232,3 @@ };

// src/utils/get-custom-selection.ts
import { TextSelection as TextSelection3 } from "@prosekit/pm/state";
import { TextSelection as TextSelection4 } from "@prosekit/pm/state";
function getCustomSelection(state, from, to) {

@@ -205,3 +239,3 @@ const pos = from != null ? from : to;

const $to = state.doc.resolve(to != null ? to : pos);
return TextSelection3.between($from, $to);
return TextSelection4.between($from, $to);
}

@@ -251,3 +285,2 @@ return state.selection;

// src/utils/get-node-types.ts
import "@prosekit/pm/model";
function getNodeTypes(schema, types) {

@@ -293,73 +326,13 @@ if (Array.isArray(types)) {

// src/commands/toggle-mark.ts
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 }) {
import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
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);

@@ -371,3 +344,2 @@ };

import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
import "@prosekit/pm/model";
function toggleNode({ type, attrs }) {

@@ -390,3 +362,2 @@ return (state, dispatch, view) => {

import { Fragment, Slice } from "@prosekit/pm/model";
import "@prosekit/pm/state";
import { ReplaceAroundStep } from "@prosekit/pm/transform";

@@ -445,5 +416,4 @@ function unsetBlockType(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) => {

@@ -453,3 +423,4 @@ const { $from, $to } = state.selection;

if (!range) return false;
const wrapping = findWrapping(range, nodeType, attrs);
const nodeType = getNodeType(state.schema, options.nodeType || options.type);
const wrapping = findWrapping(range, nodeType, options.attrs);
if (!wrapping) return false;

@@ -509,2 +480,3 @@ dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));

setNodeAttrs,
insertDefaultBlock,
selectAll,

@@ -519,6 +491,6 @@ addMark,

// src/extensions/node-spec.ts
import clone from "just-clone";
import OrderedMap2 from "orderedmap";
// src/facets/schema-spec.ts
import "@prosekit/pm/model";
import OrderedMap from "orderedmap";

@@ -542,8 +514,135 @@ var schemaSpecFacet = defineFacet({

// 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

@@ -562,83 +661,40 @@ function defineNodeSpec(options) {

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);
}

@@ -650,14 +706,2 @@ return { nodes: specs, topNode: topNodeName };

});
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);
}

@@ -674,19 +718,21 @@ // src/extensions/doc.ts

// src/extensions/events/plugin-view.ts
import { PluginKey, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
import {
PluginKey,
ProseMirrorPlugin
} from "@prosekit/pm/state";
// src/extensions/plugin.ts
import "@prosekit/pm/model";
import { Plugin } from "@prosekit/pm/state";
function definePlugin(plugin) {
if (plugin instanceof Plugin) {
return defineFacetPayload(pluginFacet, [() => [plugin]]);
if (plugin instanceof Plugin || Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin)) {
return definePluginPayload(() => plugin);
}
if (Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin)) {
return defineFacetPayload(pluginFacet, [() => plugin]);
}
if (typeof plugin === "function") {
return defineFacetPayload(pluginFacet, [plugin]);
return definePluginPayload(plugin);
}
throw new TypeError("Invalid plugin");
}
function definePluginPayload(payload) {
return defineFacetPayload(pluginFacet, [payload]);
}
var pluginFacet = defineFacet({

@@ -716,10 +762,13 @@ reducer: (payloads) => {

function defineMountHandler(handler) {
return defineFacetPayload(pluginViewFacet, [["mount", handler]]);
return definePluginViewFacetPayload(["mount", handler]);
}
function defineUpdateHandler(handler) {
return defineFacetPayload(pluginViewFacet, [["update", handler]]);
return definePluginViewFacetPayload(["update", handler]);
}
function defineUnmountHandler(handler) {
return defineFacetPayload(pluginViewFacet, [["unmount", handler]]);
return definePluginViewFacetPayload(["unmount", handler]);
}
function definePluginViewFacetPayload(input) {
return defineFacetPayload(pluginViewFacet, [input]);
}
var pluginViewFacet = defineFacet({

@@ -730,3 +779,3 @@ reduce: () => {

let unmountHandlers = [];
const plugin = new ProseMirrorPlugin2({
const plugin = new ProseMirrorPlugin({
key: pluginKey,

@@ -783,12 +832,12 @@ view: (view) => {

// src/extensions/events/dom-event.ts
import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
import { PluginKey as PluginKey2, ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
// src/utils/combine-event-handlers.ts
function combineEventHandlers() {
let _handlers = [];
function setHandlers(handlers) {
_handlers = toReversed(handlers);
let handlers = [];
function setHandlers(eventHandlers) {
handlers = toReversed(eventHandlers);
}
function combinedEventHandler(...args) {
for (const handler of _handlers) {
for (const handler of handlers) {
if (handler(...args)) {

@@ -803,16 +852,2 @@ return true;

// 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

@@ -849,3 +884,3 @@ function defineDOMEventHandler(event, handler) {

if (hasNewEvent) {
plugin = new ProseMirrorPlugin3({
plugin = new ProseMirrorPlugin2({
key: new PluginKey2("prosekit-dom-event-handler"),

@@ -866,3 +901,3 @@ props: { handleDOMEvents: combinedHandlerMap }

// src/extensions/events/editor-event.ts
import { PluginKey as PluginKey3, ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
import { PluginKey as PluginKey3, ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
function defineKeyDownHandler(handler) {

@@ -944,3 +979,3 @@ return defineFacetPayload(editorEventFacet, [["keyDown", handler]]);

};
const plugin = new ProseMirrorPlugin4({
const plugin = new ProseMirrorPlugin3({
key: new PluginKey3("prosekit-editor-event"),

@@ -985,2 +1020,3 @@ props: {

import { Plugin as Plugin2, PluginKey as PluginKey4 } from "@prosekit/pm/state";
import mapValues from "just-map-values";
function defineKeymap(keymap2) {

@@ -1021,9 +1057,7 @@ return defineFacetPayload(keymapFacet, [keymap2]);

}
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");

@@ -1047,7 +1081,7 @@

} = {}) {
return union([
return union(
definePlugin(history({ depth, newGroupDelay })),
defineKeymap(keymap),
defineCommands(commands)
]);
);
}

@@ -1093,2 +1127,3 @@

// src/extensions/mark-spec.ts
import clone2 from "just-clone";
import OrderedMap3 from "orderedmap";

@@ -1106,68 +1141,36 @@ function defineMarkSpec(options) {

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);
}

@@ -1179,5 +1182,11 @@ return { marks: specs, nodes: {} };

});
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";
import { PluginKey as PluginKey5, ProseMirrorPlugin as ProseMirrorPlugin4 } from "@prosekit/pm/state";
function defineNodeView(options) {

@@ -1195,3 +1204,3 @@ return defineFacetPayload(nodeViewFacet, [options]);

return () => [
new ProseMirrorPlugin5({
new ProseMirrorPlugin4({
key: new PluginKey5("prosekit-node-view"),

@@ -1206,3 +1215,3 @@ props: { nodeViews }

// src/extensions/node-view-effect.ts
import { PluginKey as PluginKey6, ProseMirrorPlugin as ProseMirrorPlugin6 } from "@prosekit/pm/state";
import { PluginKey as PluginKey6, ProseMirrorPlugin as ProseMirrorPlugin5 } from "@prosekit/pm/state";
function defineNodeViewFactory(options) {

@@ -1221,4 +1230,4 @@ const input = [options, null];

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) {

@@ -1230,3 +1239,3 @@ const factory = factories.find((factory2) => factory2.group === group);

return () => [
new ProseMirrorPlugin6({
new ProseMirrorPlugin5({
key: new PluginKey6("prosekit-node-view-effect"),

@@ -1279,3 +1288,3 @@ props: { nodeViews }

return "ab".replace(new RegExp("(?<=a)b", "g"), "c") === "ac";
} catch (error) {
} catch (e) {
return false;

@@ -1289,4 +1298,13 @@ }

// src/utils/collect-children.ts
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";
import { ProseMirrorFragment, ProseMirrorNode } from "@prosekit/pm/model";
function collectNodes(content) {

@@ -1296,3 +1314,3 @@ if (Array.isArray(content)) {

}
if (content instanceof ProseMirrorNode2) {
if (content instanceof ProseMirrorNode) {
return [content];

@@ -1320,11 +1338,2 @@ }

// src/utils/default-block-at.ts
function defaultBlockAt(match) {
for (let i = 0; i < match.edgeCount; i++) {
const { type } = match.edge(i);
if (type.isTextblock && !type.hasRequiredAttrs()) return type;
}
return null;
}
// src/utils/get-id.ts

@@ -1381,2 +1390,3 @@ var id = 0;

clsx,
collectChildren,
collectNodes,

@@ -1426,2 +1436,4 @@ containsInlineNode,

expandMark,
findParentNode,
findParentNodeOfType,
getMarkType,

@@ -1431,2 +1443,3 @@ getNodeType,

htmlFromNode,
insertDefaultBlock,
insertNode,

@@ -1436,2 +1449,3 @@ isAllSelection,

isAtBlockStart,
isFragment,
isInCodeBlock,

@@ -1443,2 +1457,4 @@ isMark,

isProseMirrorNode,
isSelection,
isSlice,
isTextSelection,

@@ -1445,0 +1461,0 @@ jsonFromHTML,

15

package.json
{
"name": "@prosekit/core",
"type": "module",
"version": "0.0.0-next-20240724173606",
"version": "0.0.0-next-20240901092634",
"private": false,

@@ -44,11 +44,14 @@ "author": {

"clsx": "^2.1.1",
"just-clone": "^6.2.0",
"just-map-values": "^3.2.0",
"orderedmap": "^2.1.1",
"prosemirror-splittable": "^0.1.1",
"type-fest": "^4.23.0",
"@prosekit/pm": "^0.0.0-next-20240724173606"
"type-fest": "^4.25.0",
"@prosekit/pm": "^0.0.0-next-20240901092634"
},
"devDependencies": {
"tsup": "^8.2.2",
"typescript": "^5.5.3",
"vitest": "^2.0.4",
"@vitest/browser": "^2.0.5",
"tsup": "^8.2.4",
"typescript": "^5.5.4",
"vitest": "^2.0.5",
"@prosekit/dev": "0.0.0"

@@ -55,0 +58,0 @@ },

dist/chunk-MOSGJZHV.js
dist/_tsup-dts-rollup.d.ts

Sorry, the diff of this file is too big to display