@prosekit/extensions 0.11.2 → 0.11.3

package/dist/paste-rule-Cca3n5TA.js

@@ -0,0 +1,173 @@
+import { defineFacet, defineFacetPayload, getMarkType, pluginFacet } from "@prosekit/core";
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+import { Fragment, Slice } from "@prosekit/pm/model";
+
+//#region src/paste-rule/paste-rule-plugin.ts
+/**
+* @internal
+*/
+const pasteRuleFacet = defineFacet({
+	reduce: () => {
+		let handlers = [];
+		let isPlainText = false;
+		const transformPasted = (slice, view) => {
+			for (const handler of handlers) slice = handler({
+				slice,
+				view,
+				plain: isPlainText
+			});
+			return slice;
+		};
+		const plugin = new ProseMirrorPlugin({
+			key: new PluginKey("prosekit-paste-rule"),
+			props: {
+				transformPasted,
+				transformPastedText: (text, plain) => {
+					isPlainText = plain;
+					return text;
+				},
+				transformPastedHTML(html) {
+					isPlainText = false;
+					return html;
+				}
+			}
+		});
+		return (inputs) => {
+			handlers = [...inputs].reverse();
+			return plugin;
+		};
+	},
+	singleton: true,
+	parent: pluginFacet
+});
+/**
+* @internal
+*/
+function definePasteRulePlugin(payload) {
+	return defineFacetPayload(pasteRuleFacet, [payload]);
+}
+
+//#endregion
+//#region src/paste-rule/paste-rule.ts
+/**
+* Defines a paste rule. This rule allows you to modify pasted or dragged
+* content before it is inserted into the document.
+*
+* @param options
+*
+* @public
+*/
+function definePasteRule({ handler }) {
+	return definePasteRulePlugin(handler);
+}
+
+//#endregion
+//#region src/paste-rule/split-text-by-regex.ts
+/**
+* Splits text into chunks based on regex matches, preserving both matched and unmatched segments.
+* Returns an array of tuples where each tuple contains a text segment and either the match data
+* (for matched segments) or undefined (for unmatched segments).
+*/
+function splitTextByRegex(text, regex) {
+	regex.lastIndex = 0;
+	const chunks = [];
+	let lastIndex = 0;
+	let match;
+	let matched = false;
+	while (match = regex.exec(text)) {
+		const start = match.index;
+		const end = regex.lastIndex;
+		if (start > lastIndex) chunks.push([text.slice(lastIndex, start), void 0]);
+		chunks.push([text.slice(start, end), match]);
+		matched = true;
+		if (lastIndex === end) return;
+		lastIndex = end;
+	}
+	if (matched && lastIndex < text.length) chunks.push([text.slice(lastIndex), void 0]);
+	regex.lastIndex = 0;
+	return matched ? chunks : void 0;
+}
+
+//#endregion
+//#region src/paste-rule/mark-paste-rule.ts
+/**
+* Defines a paste rule that applies marks based on regex patterns.
+*
+* @public
+*/
+function defineMarkPasteRule(options) {
+	return definePasteRule({ handler: ({ slice, view, plain }) => {
+		if (plain) return slice;
+		const markType = getMarkType(view.state.schema, options.type);
+		return replaceMarkInSlice({
+			markType,
+			regex: options.regex,
+			getAttrs: options.getAttrs,
+			shouldSkip: options.shouldSkip
+		}, slice);
+	} });
+}
+function replaceMarkInSlice(options, slice) {
+	const newFragment = replaceMarkInFragment(options, slice.content);
+	if (!newFragment) return slice;
+	return new Slice(newFragment, slice.openStart, slice.openEnd);
+}
+function replaceMarkInFragment(options, fragment) {
+	let changed = false;
+	let children = [];
+	for (const child of fragment.content) {
+		const newChild = replaceMarkInNode(options, child);
+		if (newChild) changed = true;
+		children.push(newChild || child);
+	}
+	if (changed) return Fragment.from(children);
+}
+function replaceMarkInNode(options, node) {
+	if (node.type.spec.code) return;
+	if (node.type.isInline) return;
+	if (node.type.isTextblock) return replaceMarkInTextblockNode(options, node);
+	const newChildren = replaceMarkInFragment(options, node.content);
+	if (!newChildren) return;
+	return node.copy(newChildren);
+}
+function replaceMarkInTextblockNode(options, node) {
+	const newChildren = [];
+	let changed = false;
+	for (const inlineNode of node.content.content) {
+		const newInlineNodes = replaceMarkInInlineNode(options, inlineNode);
+		if (newInlineNodes) {
+			changed = true;
+			newChildren.push(...newInlineNodes);
+		} else newChildren.push(inlineNode);
+	}
+	if (changed) return node.copy(Fragment.from(newChildren));
+}
+function replaceMarkInInlineNode(options, node) {
+	const text = node.text;
+	if (!text) return;
+	const { markType, shouldSkip } = options;
+	if (shouldSkip) {
+		if (shouldSkip(node)) return;
+	} else {
+		if (node.marks.some((mark) => mark.type === markType)) return;
+		if (node.marks.some((mark) => mark.type.spec.code)) return;
+	}
+	const chunks = splitTextByRegex(text, options.regex);
+	if (!chunks) return;
+	const schema = node.type.schema;
+	const nodes = [];
+	for (const [text$1, match] of chunks) {
+		if (!text$1) continue;
+		if (match) {
+			const attrs = options.getAttrs?.(match) ?? null;
+			if (attrs !== false) {
+				const mark = markType.create(attrs);
+				nodes.push(schema.text(text$1, [...node.marks, mark]));
+			} else nodes.push(schema.text(text$1, node.marks));
+		} else nodes.push(schema.text(text$1, node.marks));
+	}
+	return nodes;
+}
+
+//#endregion
+export { defineMarkPasteRule, definePasteRule };

package/dist/prosekit-extensions-code-block.d.ts

@@ -1,4 +1,4 @@
-import { ShikiHighlighterOptions } from "./shiki-highlighter-chunk-D7gKY7Kr.js";
+import { ShikiHighlighterOptions } from "./shiki-highlighter-chunk-DSPM0T27.js";
 import { Extension, PlainExtension, Union } from "@prosekit/core";
 import { Parser } from "prosemirror-highlight";
 import { BundledLanguage as ShikiBundledLanguage, BundledLanguageInfo as ShikiBundledLanguageInfo, BundledTheme as ShikiBundledTheme, BundledThemeInfo as ShikiBundledThemeInfo, SpecialLanguage, bundledLanguagesInfo as shikiBundledLanguagesInfo, bundledThemesInfo as shikiBundledThemesInfo } from "shiki";

package/dist/prosekit-extensions-link.d.ts

@@ -1,7 +1,13 @@
 import { Extension, PlainExtension, Union } from "@prosekit/core";
 
-//#region src/link/index.d.ts
+//#region src/link/link-paste-rule.d.ts
 
+/**
+ * @internal
+ */
+declare function defineLinkPasteRule(): PlainExtension;
+//#endregion
+//#region src/link/link-types.d.ts
 /**
  * @public
  */
@@ -10,6 +16,8 @@ interface LinkAttrs {
   target?: string | null;
   rel?: string | null;
 }
+//#endregion
+//#region src/link/index.d.ts
 /**
  * @internal
  */
@@ -61,4 +69,4 @@ type LinkExtension = Union<[LinkSpecExtension, LinkCommandsExtension]>;
  */
 declare function defineLink(): LinkExtension;
 //#endregion
-export { LinkAttrs, LinkCommandsExtension, LinkExtension, LinkSpecExtension, defineLink, defineLinkCommands, defineLinkEnterRule, defineLinkInputRule, defineLinkMarkRule, defineLinkSpec };
+export { type LinkAttrs, LinkCommandsExtension, LinkExtension, LinkSpecExtension, defineLink, defineLinkCommands, defineLinkEnterRule, defineLinkInputRule, defineLinkMarkRule, defineLinkPasteRule, defineLinkSpec };

package/dist/prosekit-extensions-link.js

@@ -1,6 +1,7 @@
 import { defineInputRule } from "./input-rule-Gji4N7Oe.js";
 import { defineEnterRule } from "./enter-rule-RdhEA900.js";
 import { defineMarkRule } from "./mark-rule-D7zaa32n.js";
+import { defineMarkPasteRule } from "./paste-rule-Cca3n5TA.js";
 import { addMark, defineCommands, defineMarkSpec, expandMark, removeMark, toggleMark, union } from "@prosekit/core";
 import { InputRule } from "@prosekit/pm/inputrules";
 
@@ -17,6 +18,22 @@ const LINK_ENTER_RE = new RegExp(LINK_ENTER_PATTERN, "gi");
 const LINK_INPUT_RE = new RegExp(LINK_INPUT_PATTERN, "gi");
 const LINK_MARK_RE = new RegExp(LINK_MARK_PATTERN, "gi");
 
+//#endregion
+//#region src/link/link-paste-rule.ts
+/**
+* @internal
+*/
+function defineLinkPasteRule() {
+	return defineMarkPasteRule({
+		type: "link",
+		regex: LINK_MARK_RE,
+		getAttrs: (match) => {
+			if (match[1]) return { href: match[1] };
+			return false;
+		}
+	});
+}
+
 //#endregion
 //#region src/link/index.ts
 /**
@@ -121,8 +138,8 @@ function defineLinkMarkRule() {
 * @public
 */
 function defineLink() {
-	return union(defineLinkSpec(), defineLinkCommands(), defineLinkInputRule(), defineLinkEnterRule());
+	return union(defineLinkSpec(), defineLinkCommands(), defineLinkInputRule(), defineLinkEnterRule(), defineLinkPasteRule());
 }
 
 //#endregion
-export { defineLink, defineLinkCommands, defineLinkEnterRule, defineLinkInputRule, defineLinkMarkRule, defineLinkSpec };
+export { defineLink, defineLinkCommands, defineLinkEnterRule, defineLinkInputRule, defineLinkMarkRule, defineLinkPasteRule, defineLinkSpec };

package/dist/prosekit-extensions-paste-rule.d.ts

@@ -0,0 +1,93 @@
+import { PlainExtension } from "@prosekit/core";
+import { EditorView } from "@prosekit/pm/view";
+import { Attrs, MarkType, ProseMirrorNode, Slice } from "@prosekit/pm/model";
+
+//#region src/paste-rule/mark-paste-rule.d.ts
+
+/**
+ * The options for {@link defineMarkPasteRule}.
+ *
+ * @public
+ */
+interface MarkPasteRuleOptions {
+  /**
+   * The regular expression to match against. It must have a `g` flag to match
+   * all instances of the mark.
+   */
+  regex: RegExp;
+  /**
+   * The mark type to apply to the matched text.
+   */
+  type: string | MarkType;
+  /**
+   * A function used to compute attributes to set on the mark created by this
+   * rule. When it returns `false`, the rule won't match. When it returns `null`
+   * or `undefined`, that is interpreted as an empty/default set of attributes.
+   * @default null
+   */
+  getAttrs?: (match: RegExpExecArray) => Attrs | null | undefined | false;
+  /**
+   * Optional function to determine if a text node should be skipped.
+   * Default behavior: skip code nodes and nodes that already have the target mark.
+   */
+  shouldSkip?: (node: ProseMirrorNode) => boolean;
+}
+/**
+ * Defines a paste rule that applies marks based on regex patterns.
+ *
+ * @public
+ */
+declare function defineMarkPasteRule(options: MarkPasteRuleOptions): PlainExtension;
+//#endregion
+//#region src/paste-rule/paste-rule.d.ts
+/**
+ * @public
+ *
+ * Options for {@link PasteRuleHandler}.
+ */
+interface PasteRuleHandlerOptions {
+  /**
+   * The slice to be pasted.
+   */
+  slice: Slice;
+  /**
+   * The editor view.
+   */
+  view: EditorView;
+  /**
+   * Whether the pasted content is treated as plain text. This is true when the
+   * `Shift` key is held when pasting.
+   */
+  plain: boolean;
+}
+/**
+ * @public
+ *
+ * Can be used to transform pasted or dragged-and-dropped content before it is
+ * applied to the document.
+ */
+type PasteRuleHandler = (options: PasteRuleHandlerOptions) => Slice;
+/**
+ * Options for {@link definePasteRule}.
+ *
+ * @public
+ */
+interface PasteRuleOptions {
+  /**
+   * A function to be called when a paste rule is triggered.
+   */
+  handler: PasteRuleHandler;
+}
+/**
+ * Defines a paste rule. This rule allows you to modify pasted or dragged
+ * content before it is inserted into the document.
+ *
+ * @param options
+ *
+ * @public
+ */
+declare function definePasteRule({
+  handler
+}: PasteRuleOptions): PlainExtension;
+//#endregion
+export { type MarkPasteRuleOptions, type PasteRuleHandler, type PasteRuleHandlerOptions, type PasteRuleOptions, defineMarkPasteRule, definePasteRule };

package/dist/prosekit-extensions-paste-rule.js

@@ -0,0 +1,3 @@
+import { defineMarkPasteRule, definePasteRule } from "./paste-rule-Cca3n5TA.js";
+
+export { defineMarkPasteRule, definePasteRule };

package/dist/prosekit-extensions-placeholder.js

@@ -1,4 +1,4 @@
-import { findTable } from "./table-3rDWFyBH.js";
+import { findTable } from "./table-C_qAMj5-.js";
 import { definePlugin, isInCodeBlock, maybeRun } from "@prosekit/core";
 import { Plugin, PluginKey } from "@prosekit/pm/state";
 import { Decoration, DecorationSet } from "@prosekit/pm/view";

package/dist/prosekit-extensions-table.js

@@ -1,3 +1,3 @@
-import { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow } from "./table-3rDWFyBH.js";
+import { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow } from "./table-C_qAMj5-.js";
 
 export { defineTable, defineTableCellSpec, defineTableCommands, defineTableHeaderCellSpec, defineTablePlugins, defineTableRowSpec, defineTableSpec, exitTable, findTable, insertTable, isCellSelection, moveTableColumn, moveTableRow, selectTable, selectTableCell, selectTableColumn, selectTableRow };

package/dist/shiki-highlighter-chunk.d.ts

@@ -1,2 +1,2 @@
-import { HighlighterOptions, HighlighterResult, ShikiHighlighterOptions, createOrGetHighlighter } from "./shiki-highlighter-chunk-D7gKY7Kr.js";
+import { HighlighterOptions, HighlighterResult, ShikiHighlighterOptions, createOrGetHighlighter } from "./shiki-highlighter-chunk-DSPM0T27.js";
 export { HighlighterOptions, HighlighterResult, ShikiHighlighterOptions, createOrGetHighlighter };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "private": false,
   "description": "A collection of common extensions for ProseKit",
   "author": {
@@ -142,6 +142,10 @@
       "types": "./dist/prosekit-extensions-paragraph.d.ts",
       "default": "./dist/prosekit-extensions-paragraph.js"
     },
+    "./paste-rule": {
+      "types": "./dist/prosekit-extensions-paste-rule.d.ts",
+      "default": "./dist/prosekit-extensions-paste-rule.js"
+    },
     "./placeholder": {
       "types": "./dist/prosekit-extensions-placeholder.d.ts",
       "default": "./dist/prosekit-extensions-placeholder.js"
@@ -210,7 +214,7 @@
     "prosemirror-highlight": "^0.13.0",
     "prosemirror-search": "^1.1.0",
     "prosemirror-tables": "^1.7.1",
-    "shiki": "^3.9.1",
+    "shiki": "^3.9.2",
     "@prosekit/core": "^0.8.3",
     "@prosekit/pm": "^0.1.11"
   },
@@ -239,16 +243,16 @@
     "@vitest/browser": "^3.2.4",
     "diffable-html": "^6.0.1",
     "just-pick": "^4.2.0",
-    "loro-crdt": "^1.5.9",
+    "loro-crdt": "^1.5.10",
     "loro-prosemirror": "^0.2.3",
     "rehype-parse": "^9.0.1",
     "rehype-remark": "^10.0.1",
     "remark-html": "^16.0.1",
     "remark-parse": "^11.0.0",
     "remark-stringify": "^11.0.0",
-    "tsdown": "^0.13.2",
+    "tsdown": "^0.13.4",
     "type-fest": "^4.41.0",
-    "typescript": "~5.8.3",
+    "typescript": "~5.9.2",
     "unified": "^11.0.5",
     "vitest": "^3.2.4",
     "y-prosemirror": "^1.3.7",
@@ -292,6 +296,7 @@
       "prosekit-extensions-mention": "./src/mention/index.ts",
       "prosekit-extensions-mod-click-prevention": "./src/mod-click-prevention/index.ts",
       "prosekit-extensions-paragraph": "./src/paragraph/index.ts",
+      "prosekit-extensions-paste-rule": "./src/paste-rule/index.ts",
       "prosekit-extensions-placeholder": "./src/placeholder/index.ts",
       "placeholder/style": "./src/placeholder/style.css",
       "prosekit-extensions-readonly": "./src/readonly/index.ts",
@@ -394,6 +399,9 @@
       "paragraph": [
         "./dist/prosekit-extensions-paragraph.d.ts"
       ],
+      "paste-rule": [
+        "./dist/prosekit-extensions-paste-rule.d.ts"
+      ],
       "placeholder": [
         "./dist/prosekit-extensions-placeholder.d.ts"
       ],