@prosekit/extensions 0.11.1 → 0.11.3

package/dist/{drop-indicator-QKkPzJIx.js → drop-indicator-B8P652g2.js}

@@ -52,7 +52,7 @@ function buildGetTarget(view, onDrag) {
 		prevTargets = getTargetsByView(view);
 		return prevTargets;
 	};
-	const getTarget = (point, event) => {
+	const getTargetImpl = (point, event) => {
 		if (!view.editable || view.isDestroyed) return;
 		const compare = (p1, p2) => {
 			const [pos1, line1] = p1;
@@ -71,7 +71,18 @@ function buildGetTarget(view, onDrag) {
 		if (target && isDraggingToItself(view, target[0])) return void 0;
 		return target;
 	};
-	return getTarget;
+	let prevPoint;
+	let prevTarget;
+	const getTargetCached = (point, event) => {
+		if (prevPoint && pointEqual(prevPoint, point)) return prevTarget;
+		prevPoint = point;
+		prevTarget = getTargetImpl(point, event);
+		return prevTarget;
+	};
+	return getTargetCached;
+}
+function pointEqual(a, b) {
+	return a[0] === b[0] && a[1] === b[1];
 }
 function pointPointDistance(a, b) {
 	return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);

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-autocomplete.d.ts

@@ -3,88 +3,88 @@ import { EditorState } from "@prosekit/pm/state";
 
 //#region src/autocomplete/autocomplete-rule.d.ts
 /**
-* Options for the {@link MatchHandler} callback.
-*/
+ * Options for the {@link MatchHandler} callback.
+ */
 interface MatchHandlerOptions {
   /**
-  * The editor state.
-  */
+   * The editor state.
+   */
   state: EditorState;
   /**
-  * The result of `RegExp.exec`.
-  */
+   * The result of `RegExp.exec`.
+   */
   match: RegExpExecArray;
   /**
-  * The start position of the matched text.
-  */
+   * The start position of the matched text.
+   */
   from: number;
   /**
-  * The end position of the matched text.
-  */
+   * The end position of the matched text.
+   */
   to: number;
   /**
-  * Call this function to ignore the match. You probably want to call this
-  * function when the user presses the `Escape` key.
-  */
+   * Call this function to ignore the match. You probably want to call this
+   * function when the user presses the `Escape` key.
+   */
   ignoreMatch: () => void;
   /**
-  * Call this function to delete the matched text. For example, in a slash
-  * menu, you might want to delete the matched text first then do something
-  * else when the user presses the `Enter` key.
-  */
+   * Call this function to delete the matched text. For example, in a slash
+   * menu, you might want to delete the matched text first then do something
+   * else when the user presses the `Enter` key.
+   */
   deleteMatch: () => void;
 }
 /**
-* A callback that is called when the rule starts to match, and also on
-* subsequent updates while the rule continues to match.
-*/
+ * A callback that is called when the rule starts to match, and also on
+ * subsequent updates while the rule continues to match.
+ */
 type MatchHandler = (options: MatchHandlerOptions) => void;
 /**
-* Options for the {@link CanMatchPredicate} callback.
-*/
+ * Options for the {@link CanMatchPredicate} callback.
+ */
 interface CanMatchOptions {
   /**
-  * The editor state.
-  */
+   * The editor state.
+   */
   state: EditorState;
 }
 /**
-* A predicate to determine if the rule can be applied in the current editor state.
-*/
+ * A predicate to determine if the rule can be applied in the current editor state.
+ */
 type CanMatchPredicate = (options: CanMatchOptions) => boolean;
 /**
-* Options for creating an {@link AutocompleteRule}
-*/
+ * Options for creating an {@link AutocompleteRule}
+ */
 interface AutocompleteRuleOptions {
   /**
-  * The regular expression to match against the text before the cursor. The
-  * last match before the cursor is used.
-  *
-  * For a slash menu, you might use `/(?<!\S)\/(|\S.*)$/u`.
-  * For a mention, you might use `/@\w*$/`
-  */
+   * The regular expression to match against the text before the cursor. The
+   * last match before the cursor is used.
+   *
+   * For a slash menu, you might use `/(?<!\S)\/(|\S.*)$/u`.
+   * For a mention, you might use `/@\w*$/`
+   */
   regex: RegExp;
   /**
-  * A callback that is called when the rule starts to match, and also on
-  * subsequent updates while the rule continues to match.
-  */
+   * A callback that is called when the rule starts to match, and also on
+   * subsequent updates while the rule continues to match.
+   */
   onEnter: MatchHandler;
   /**
-  * A callback that is called when the rule stops matching.
-  */
+   * A callback that is called when the rule stops matching.
+   */
   onLeave?: VoidFunction;
   /**
-  * A predicate to determine if the rule can be applied in the current editor
-  * state. If not provided, it defaults to only allowing matches in empty
-  * selections that are not inside a code block or code mark.
-  */
+   * A predicate to determine if the rule can be applied in the current editor
+   * state. If not provided, it defaults to only allowing matches in empty
+   * selections that are not inside a code block or code mark.
+   */
   canMatch?: CanMatchPredicate;
 }
 /**
-* An autocomplete rule that can be used to create an autocomplete extension.
-*
-* @public
-*/
+ * An autocomplete rule that can be used to create an autocomplete extension.
+ *
+ * @public
+ */
 declare class AutocompleteRule {
   /** @internal */
   readonly regex: RegExp;

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

@@ -10,8 +10,8 @@ type BlockquoteCommandsExtension = Extension<{
   };
 }>;
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineBlockquoteCommands(): BlockquoteCommandsExtension;
 //#endregion
 //#region src/blockquote/blockquote-spec.d.ts
@@ -24,25 +24,25 @@ declare function defineBlockquoteSpec(): BlockquoteSpecExtension;
 //#endregion
 //#region src/blockquote/blockquote.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 type BlockquoteExtension = Union<[BlockquoteSpecExtension, BlockquoteCommandsExtension]>;
 /**
-* @public
-*/
+ * @public
+ */
 declare function defineBlockquote(): BlockquoteExtension;
 //#endregion
 //#region src/blockquote/blockquote-input-rule.d.ts
 /**
-* Wraps the text block in a blockquote when `>` is typed at the start of a new
-* line followed by a space.
-*/
+ * Wraps the text block in a blockquote when `>` is typed at the start of a new
+ * line followed by a space.
+ */
 declare function defineBlockquoteInputRule(): PlainExtension;
 //#endregion
 //#region src/blockquote/blockquote-keymap.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineBlockquoteKeymap(): PlainExtension;
 //#endregion
 export { type BlockquoteCommandsExtension, type BlockquoteExtension, type BlockquoteSpecExtension, defineBlockquote, defineBlockquoteCommands, defineBlockquoteInputRule, defineBlockquoteKeymap, defineBlockquoteSpec };

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

@@ -3,52 +3,52 @@ import { Attrs } from "@prosekit/pm/model";
 
 //#region src/bold/bold-commands.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 type BoldCommandsExtension = Extension<{
   Commands: {
     toggleBold: [];
   };
 }>;
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineBoldCommands(): BoldCommandsExtension;
 //#endregion
 //#region src/bold/bold-spec.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 type BoldSpecExtension = Extension<{
   Marks: {
     bold: Attrs;
   };
 }>;
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineBoldSpec(): BoldSpecExtension;
 //#endregion
 //#region src/bold/bold.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 type BoldExtension = Union<[BoldSpecExtension, BoldCommandsExtension]>;
 /**
-* @public
-*/
+ * @public
+ */
 declare function defineBold(): BoldExtension;
 //#endregion
 //#region src/bold/bold-input-rule.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineBoldInputRule(): PlainExtension;
 //#endregion
 //#region src/bold/bold-keymap.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineBoldKeymap(): PlainExtension;
 //#endregion
 export { type BoldCommandsExtension, type BoldExtension, type BoldSpecExtension, defineBold, defineBoldCommands, defineBoldInputRule, defineBoldKeymap, defineBoldSpec };

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

@@ -1,22 +1,22 @@
-import { ShikiHighlighterOptions } from "./shiki-highlighter-chunk-NV2F_Qjl.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";
 
 //#region src/code-block/code-block-types.d.ts
 /**
-* The attributes for the `codeBlock` node.
-*
-* @public
-*/
+ * The attributes for the `codeBlock` node.
+ *
+ * @public
+ */
 interface CodeBlockAttrs {
   language: string;
 }
 //#endregion
 //#region src/code-block/code-block-commands.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 type CodeBlockCommandsExtension = Extension<{
   Commands: {
     setCodeBlock: [attrs?: CodeBlockAttrs];
@@ -26,130 +26,130 @@ type CodeBlockCommandsExtension = Extension<{
   };
 }>;
 /**
-* Adds commands for working with `codeBlock` nodes.
-*
-* @public
-*/
+ * Adds commands for working with `codeBlock` nodes.
+ *
+ * @public
+ */
 declare function defineCodeBlockCommands(): CodeBlockCommandsExtension;
 //#endregion
 //#region src/code-block/code-block-spec.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 type CodeBlockSpecExtension = Extension<{
   Nodes: {
     codeBlock: CodeBlockAttrs;
   };
 }>;
 /**
-* Defines the `codeBlock` node spec.
-*
-* @public
-*/
+ * Defines the `codeBlock` node spec.
+ *
+ * @public
+ */
 declare function defineCodeBlockSpec(): CodeBlockSpecExtension;
 //#endregion
 //#region src/code-block/code-block.d.ts
 /**
-* @internal
-*/
+ * @internal
+ */
 type CodeBlockExtension = Union<[CodeBlockSpecExtension, CodeBlockCommandsExtension]>;
 /**
-* Adds `codeBlock` nodes to the editor. This includes the following extensions:
-*
-* - {@link defineCodeBlockSpec}
-* - {@link defineCodeBlockInputRule}
-* - {@link defineCodeBlockEnterRule}
-* - {@link defineCodeBlockKeymap}
-* - {@link defineCodeBlockCommands}.
-*
-* @public
-*/
+ * Adds `codeBlock` nodes to the editor. This includes the following extensions:
+ *
+ * - {@link defineCodeBlockSpec}
+ * - {@link defineCodeBlockInputRule}
+ * - {@link defineCodeBlockEnterRule}
+ * - {@link defineCodeBlockKeymap}
+ * - {@link defineCodeBlockCommands}.
+ *
+ * @public
+ */
 declare function defineCodeBlock(): CodeBlockExtension;
 //#endregion
 //#region src/code-block/code-block-highlight.d.ts
 /**
-* @public
-*
-* An alias for the `Parser` type from the `prosemirror-highlight` package.
-*/
+ * @public
+ *
+ * An alias for the `Parser` type from the `prosemirror-highlight` package.
+ */
 type HighlightParser = Parser;
 /**
-* @public
-*/
+ * @public
+ */
 type CodeBlockHighlightOptions = {
   parser: HighlightParser;
 };
 /**
-* Adds syntax highlighting to code blocks. This function requires a `Parser`
-* instance from the `prosemirror-highlight` package. See the
-* [documentation](https://github.com/ocavue/prosemirror-highlight) for more
-* information.
-*
-* @param options
-*
-* @public
-*/
+ * Adds syntax highlighting to code blocks. This function requires a `Parser`
+ * instance from the `prosemirror-highlight` package. See the
+ * [documentation](https://github.com/ocavue/prosemirror-highlight) for more
+ * information.
+ *
+ * @param options
+ *
+ * @public
+ */
 declare function defineCodeBlockHighlight({
   parser
 }: CodeBlockHighlightOptions): Extension;
 //#endregion
 //#region src/code-block/code-block-input-rule.d.ts
 /**
-* Adds input rules for `codeBlock` nodes.
-*
-* @public
-*/
+ * Adds input rules for `codeBlock` nodes.
+ *
+ * @public
+ */
 declare function defineCodeBlockInputRule(): PlainExtension;
 /**
-* Adds enter rules for `codeBlock` nodes.
-*
-* @public
-*/
+ * Adds enter rules for `codeBlock` nodes.
+ *
+ * @public
+ */
 declare function defineCodeBlockEnterRule(): PlainExtension;
 //#endregion
 //#region src/code-block/code-block-keymap.d.ts
 /**
-* Defines the keymap for code blocks.
-*/
+ * Defines the keymap for code blocks.
+ */
 declare function defineCodeBlockKeymap(): PlainExtension;
 //#endregion
 //#region src/code-block/code-block-shiki.d.ts
 /**
-* The options to configure the Shiki highlighter.
-*
-* @public
-*/
-interface CodeBlockShikiOptions extends Omit<ShikiHighlighterOptions, "themes" | "langs" | "engine"> {
+ * The options to configure the Shiki highlighter.
+ *
+ * @public
+ */
+interface CodeBlockShikiOptions extends Omit<ShikiHighlighterOptions, 'themes' | 'langs' | 'engine'> {
   /**
-  * A list of Shiki themes to pre-load. The first theme in the list will be
-  * used to render the code block.
-  *
-  * @default ['one-dark-pro']
-  */
+   * A list of Shiki themes to pre-load. The first theme in the list will be
+   * used to render the code block.
+   *
+   * @default ['one-dark-pro']
+   */
   themes?: ShikiBundledTheme[];
   /**
-  * A list of Shiki languages to pre-load.
-  *
-  * @default ['text']
-  */
+   * A list of Shiki languages to pre-load.
+   *
+   * @default ['text']
+   */
   langs?: (ShikiBundledLanguage | SpecialLanguage)[];
   /**
-  * The RegExp engine to use. By default, the JavaScript engine is used.
-  */
-  engine?: ShikiHighlighterOptions["engine"];
+   * The RegExp engine to use. By default, the JavaScript engine is used.
+   */
+  engine?: ShikiHighlighterOptions['engine'];
 }
 /**
-* Adds syntax highlighting to code blocks using the [Shiki](https://github.com/shikijs/shiki) package.
-*
-* It will set two CSS variables on the code block elements:
-*
-* - `--prosemirror-highlight`: sets text color
-* - `--prosemirror-highlight-bg`: sets background color
-*
-* @param options - The options to configure the Shiki highlighter.
-*
-* @public
-*/
+ * Adds syntax highlighting to code blocks using the [Shiki](https://github.com/shikijs/shiki) package.
+ *
+ * It will set two CSS variables on the code block elements:
+ *
+ * - `--prosemirror-highlight`: sets text color
+ * - `--prosemirror-highlight-bg`: sets background color
+ *
+ * @param options - The options to configure the Shiki highlighter.
+ *
+ * @public
+ */
 declare function defineCodeBlockShiki({
   themes,
   langs,