@prosekit/extensions 0.7.24 → 0.9.0

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

@@ -1,2 +1,41 @@
-export { defineMarkRule } from './_tsup-dts-rollup.js';
-export { MarkRuleOptions } from './_tsup-dts-rollup.js';
+import { PlainExtension } from "@prosekit/core";
+import { Attrs, MarkType } from "@prosekit/pm/model";
+
+//#region src/mark-rule/types.d.ts
+/**
+* The options for {@link defineMarkRule}.
+*
+* @public
+*/
+/**
+* The options for {@link defineMarkRule}.
+*
+* @public
+*/
+interface MarkRuleOptions {
+  /**
+  * The regular expression to match against. It must has a `g` flag to match
+  * all instances of the mark.
+  */
+  regex: RegExp;
+  /**
+  * The mark type to apply to the matched text.
+  */
+  type: string | MarkType;
+  /**
+  * Attributes to set on the mark. If a function is provided, it will be called
+  * with the matched result from the regular expression.
+  *
+  * @default null
+  */
+  attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+} //#endregion
+//#region src/mark-rule/mark-rule.d.ts
+/**
+* A mark rule is something that can automatically apply marks to text if it
+* matches a certain pattern, and remove them if it doesn't match anymore.
+*/
+declare function defineMarkRule(options: MarkRuleOptions): PlainExtension;
+
+//#endregion
+export { MarkRuleOptions, defineMarkRule };

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

@@ -1,6 +1,3 @@
-import {
-  defineMarkRule
-} from "./chunk-6UYLCVBX.js";
-export {
-  defineMarkRule
-};
+import { defineMarkRule } from "./mark-rule-wEOcDt6i.js";
+
+export { defineMarkRule };

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

@@ -1,4 +1,40 @@
-export { defineMentionSpec } from './_tsup-dts-rollup.js';
-export { defineMentionCommands } from './_tsup-dts-rollup.js';
-export { defineMention } from './_tsup-dts-rollup.js';
-export { MentionAttrs } from './_tsup-dts-rollup.js';
+import { Extension, Union } from "@prosekit/core";
+
+//#region src/mention/index.d.ts
+interface MentionAttrs {
+  id: string;
+  value: string;
+  kind: string;
+}
+/**
+* @internal
+*/
+type MentionSpecExtension = Extension<{
+  Nodes: {
+    mention: MentionAttrs;
+  };
+}>;
+/**
+* @public
+*/
+declare function defineMentionSpec(): MentionSpecExtension;
+/**
+* @internal
+*/
+type MentionCommandsExtension = Extension<{
+  Commands: {
+    insertMention: [attrs: MentionAttrs];
+  };
+}>;
+declare function defineMentionCommands(): MentionCommandsExtension;
+/**
+* @internal
+*/
+type MentionExtension = Union<[MentionSpecExtension, MentionCommandsExtension]>;
+/**
+* @public
+*/
+declare function defineMention(): MentionExtension;
+
+//#endregion
+export { MentionAttrs, MentionCommandsExtension, MentionExtension, MentionSpecExtension, defineMention, defineMentionCommands, defineMentionSpec };

package/dist/prosekit-extensions-mention.js

@@ -1,56 +1,58 @@
-// src/mention/index.ts
-import {
-  defineCommands,
-  defineNodeSpec,
-  insertNode,
-  union
-} from "@prosekit/core";
+import { defineCommands, defineNodeSpec, insertNode, union } from "@prosekit/core";
+
+//#region src/mention/index.ts
+/**
+* @public
+*/
 function defineMentionSpec() {
-  return defineNodeSpec({
-    name: "mention",
-    atom: true,
-    group: "inline",
-    attrs: {
-      id: {},
-      value: {},
-      kind: { default: "" }
-    },
-    inline: true,
-    leafText: (node) => node.attrs.value.toString(),
-    parseDOM: [
-      {
-        tag: `span[data-mention]`,
-        getAttrs: (dom) => ({
-          id: dom.getAttribute("data-id") || "",
-          kind: dom.getAttribute("data-mention") || "",
-          value: dom.textContent || ""
-        })
-      }
-    ],
-    toDOM(node) {
-      return [
-        "span",
-        {
-          "data-id": node.attrs.id.toString(),
-          "data-mention": node.attrs.kind.toString()
-        },
-        node.attrs.value.toString()
-      ];
-    }
-  });
+	return defineNodeSpec({
+		name: "mention",
+		atom: true,
+		group: "inline",
+		attrs: {
+			id: { validate: "string" },
+			value: { validate: "string" },
+			kind: {
+				default: "",
+				validate: "string"
+			}
+		},
+		inline: true,
+		leafText: (node) => node.attrs.value.toString(),
+		parseDOM: [{
+			tag: `span[data-mention]`,
+			getAttrs: (dom) => ({
+				id: dom.getAttribute("data-id") || "",
+				kind: dom.getAttribute("data-mention") || "",
+				value: dom.textContent || ""
+			})
+		}],
+		toDOM(node) {
+			return [
+				"span",
+				{
+					"data-id": node.attrs.id.toString(),
+					"data-mention": node.attrs.kind.toString()
+				},
+				node.attrs.value.toString()
+			];
+		}
+	});
 }
 function defineMentionCommands() {
-  return defineCommands({
-    insertMention: (attrs) => {
-      return insertNode({ type: "mention", attrs });
-    }
-  });
+	return defineCommands({ insertMention: (attrs) => {
+		return insertNode({
+			type: "mention",
+			attrs
+		});
+	} });
 }
+/**
+* @public
+*/
 function defineMention() {
-  return union(defineMentionSpec(), defineMentionCommands());
+	return union(defineMentionSpec(), defineMentionCommands());
 }
-export {
-  defineMention,
-  defineMentionCommands,
-  defineMentionSpec
-};
+
+//#endregion
+export { defineMention, defineMentionCommands, defineMentionSpec };

package/dist/prosekit-extensions-mod-click-prevention.d.ts

@@ -1,2 +1,20 @@
-export { defineModClickPrevention } from './_tsup-dts-rollup.js';
-export { ModClickPreventionExtension } from './_tsup-dts-rollup.js';
+import { PlainExtension } from "@prosekit/core";
+
+//#region src/mod-click-prevention/index.d.ts
+/**
+* @internal
+*/
+/**
+* @internal
+*/
+type ModClickPreventionExtension = PlainExtension;
+/**
+* By default, clicking a node while holding the mod key will select the node. This
+* extension disables that behavior.
+*
+* @public
+*/
+declare function defineModClickPrevention(): ModClickPreventionExtension;
+
+//#endregion
+export { ModClickPreventionExtension, defineModClickPrevention };

package/dist/prosekit-extensions-mod-click-prevention.js

@@ -1,20 +1,24 @@
-// src/mod-click-prevention/index.ts
-import {
-  definePlugin,
-  isApple
-} from "@prosekit/core";
-import {
-  Plugin,
-  PluginKey
-} from "@prosekit/pm/state";
+import { definePlugin, isApple } from "@prosekit/core";
+import { Plugin, PluginKey } from "@prosekit/pm/state";
+
+//#region src/mod-click-prevention/index.ts
+/**
+* By default, clicking a node while holding the mod key will select the node. This
+* extension disables that behavior.
+*
+* @public
+*/
 function defineModClickPrevention() {
-  return definePlugin(new Plugin({ key, props: { handleClick } }));
+	return definePlugin(new Plugin({
+		key,
+		props: { handleClick }
+	}));
 }
-var key = new PluginKey("prosekit-mod-click-prevention");
+const key = new PluginKey("prosekit-mod-click-prevention");
 function handleClick(_view, _pos, event) {
-  return !!event[selectNodeModifier];
+	return !!event[selectNodeModifier];
 }
-var selectNodeModifier = isApple ? "metaKey" : "ctrlKey";
-export {
-  defineModClickPrevention
-};
+const selectNodeModifier = isApple ? "metaKey" : "ctrlKey";
+
+//#endregion
+export { defineModClickPrevention };

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

@@ -0,0 +1,65 @@
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+import { Command } from "@prosekit/pm/state";
+import { Attrs } from "@prosekit/pm/model";
+
+//#region src/paragraph/paragraph-commands.d.ts
+/**
+* @internal
+*/
+/**
+* @internal
+*/
+type ParagraphCommandsExtension = Extension<{
+  Commands: {
+    setParagraph: [];
+  };
+}>;
+/**
+* @internal
+*/
+
+/**
+* @internal
+*/
+declare function defineParagraphCommands(): ParagraphCommandsExtension; //#endregion
+//#region src/paragraph/paragraph-spec.d.ts
+/**
+* @internal
+*/
+type ParagraphSpecExtension = Extension<{
+  Nodes: {
+    paragraph: Attrs;
+  };
+}>;
+/**
+* @internal
+*
+* Defines a paragraph node spec.
+*/
+declare function defineParagraphSpec(): ParagraphSpecExtension;
+
+//#endregion
+//#region src/paragraph/paragraph.d.ts
+/**
+* @internal
+*/
+type ParagraphExtension = Union<[ParagraphSpecExtension, ParagraphCommandsExtension]>;
+/**
+* @public
+*
+* Defines a paragraph node.
+*
+* The paragraph node spec has the highest priority, because it should be the
+* default block node for most cases.
+*/
+declare function defineParagraph(): ParagraphExtension;
+
+//#endregion
+//#region src/paragraph/paragraph-keymap.d.ts
+/**
+* @internal
+*/
+declare function defineParagraphKeymap(): PlainExtension;
+
+//#endregion
+export { ParagraphCommandsExtension, ParagraphExtension, ParagraphSpecExtension, defineParagraph, defineParagraphCommands, defineParagraphKeymap, defineParagraphSpec };

package/dist/prosekit-extensions-paragraph.js

@@ -0,0 +1,60 @@
+import { Priority, defineCommands, defineKeymap, defineNodeSpec, setBlockType, union, withPriority } from "@prosekit/core";
+
+//#region src/paragraph/paragraph-commands.ts
+/**
+* @internal
+*/
+function setParagraph() {
+	return setBlockType({ type: "paragraph" });
+}
+/**
+* @internal
+*/
+function defineParagraphCommands() {
+	return defineCommands({ setParagraph });
+}
+
+//#endregion
+//#region src/paragraph/paragraph-keymap.ts
+/**
+* @internal
+*/
+function defineParagraphKeymap() {
+	return defineKeymap({ "mod-alt-0": setParagraph() });
+}
+
+//#endregion
+//#region src/paragraph/paragraph-spec.ts
+/**
+* @internal
+*
+* Defines a paragraph node spec.
+*/
+function defineParagraphSpec() {
+	return defineNodeSpec({
+		name: "paragraph",
+		content: "inline*",
+		group: "block",
+		parseDOM: [{ tag: "p" }],
+		toDOM() {
+			return ["p", 0];
+		}
+	});
+}
+
+//#endregion
+//#region src/paragraph/paragraph.ts
+/**
+* @public
+*
+* Defines a paragraph node.
+*
+* The paragraph node spec has the highest priority, because it should be the
+* default block node for most cases.
+*/
+function defineParagraph() {
+	return union(withPriority(defineParagraphSpec(), Priority.highest), defineParagraphCommands(), defineParagraphKeymap());
+}
+
+//#endregion
+export { defineParagraph, defineParagraphCommands, defineParagraphKeymap, defineParagraphSpec };

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

@@ -1,2 +1,32 @@
-export { definePlaceholder } from './_tsup-dts-rollup.js';
-export { PlaceholderOptions } from './_tsup-dts-rollup.js';
+import { PlainExtension } from "@prosekit/core";
+import { EditorState } from "@prosekit/pm/state";
+
+//#region src/placeholder/index.d.ts
+interface PlaceholderOptions {
+  /**
+  * The placeholder to use. It can be a static string or a function that
+  * receives the current editor state and returns a string.
+  */
+  placeholder: string | ((state: EditorState) => string);
+  /**
+  * By default, the placeholder text will be shown whenever the current text
+  * cursor is in an empty text node and it's not inside a code block or a
+  * table node.
+  *
+  * If you only want to show the placeholder when the whole doc is empty, you
+  * can set this option to 'doc'.
+  *
+  * You can also pass a function that receives the current editor state and
+  * returns a boolean value to determine whether the placeholder should be
+  * shown.
+  *
+  * @default 'block'
+  */
+  strategy?: "doc" | "block" | ((state: EditorState) => boolean);
+}
+/**
+* Add a placeholder text to the editor when the current block or document is
+* empty.
+*/
+declare function definePlaceholder(options: PlaceholderOptions): PlainExtension; //#endregion
+export { PlaceholderOptions, definePlaceholder };

package/dist/prosekit-extensions-placeholder.js

@@ -1,68 +1,51 @@
-import {
-  findTable
-} from "./chunk-HFAZX2J3.js";
+import { findTable } from "./table-DnVliJ6E.js";
+import { definePlugin, isInCodeBlock, maybeRun } from "@prosekit/core";
+import { Plugin, PluginKey } from "@prosekit/pm/state";
+import { Decoration, DecorationSet } from "@prosekit/pm/view";
 
-// src/placeholder/index.ts
-import {
-  definePlugin,
-  isInCodeBlock,
-  maybeRun
-} from "@prosekit/core";
-import {
-  Plugin,
-  PluginKey
-} from "@prosekit/pm/state";
-import {
-  Decoration,
-  DecorationSet
-} from "@prosekit/pm/view";
+//#region src/placeholder/index.ts
+/**
+* Add a placeholder text to the editor when the current block or document is
+* empty.
+*/
 function definePlaceholder(options) {
-  return definePlugin(createPlaceholderPlugin(options));
+	return definePlugin(createPlaceholderPlugin(options));
 }
-function createPlaceholderPlugin({
-  placeholder,
-  strategy = "block"
-}) {
-  return new Plugin({
-    key: new PluginKey("prosekit-placeholder"),
-    props: {
-      decorations: (state) => {
-        const strategyFn = typeof strategy === "function" ? strategy : strategy === "doc" ? docStrategy : defaultStrategy;
-        if (!strategyFn(state)) {
-          return null;
-        }
-        const placeholderText = maybeRun(placeholder, state);
-        const deco = createPlaceholderDecoration(state, placeholderText);
-        if (!deco) {
-          return null;
-        }
-        return DecorationSet.create(state.doc, [deco]);
-      }
-    }
-  });
+function createPlaceholderPlugin({ placeholder, strategy = "block" }) {
+	return new Plugin({
+		key: new PluginKey("prosekit-placeholder"),
+		props: { decorations: (state) => {
+			const strategyFn = typeof strategy === "function" ? strategy : strategy === "doc" ? docStrategy : defaultStrategy;
+			if (!strategyFn(state)) return null;
+			const placeholderText = maybeRun(placeholder, state);
+			const deco = createPlaceholderDecoration(state, placeholderText);
+			if (!deco) return null;
+			return DecorationSet.create(state.doc, [deco]);
+		} }
+	});
 }
 function defaultStrategy(state) {
-  return !isInCodeBlock(state.selection) && !findTable(state.selection.$from);
+	return !isInCodeBlock(state.selection) && !findTable(state.selection.$from);
 }
 function docStrategy(state) {
-  return isDocEmpty(state.doc) && defaultStrategy(state);
+	return isDocEmpty(state.doc) && defaultStrategy(state);
 }
 function isDocEmpty(doc) {
-  return doc.childCount <= 1 && !doc.firstChild?.content.size;
+	return doc.childCount <= 1 && !doc.firstChild?.content.size;
 }
 function createPlaceholderDecoration(state, placeholderText) {
-  if (!placeholderText) return null;
-  const { selection } = state;
-  if (!selection.empty) return null;
-  const $pos = selection.$anchor;
-  const node = $pos.parent;
-  if (node.content.size > 0) return null;
-  const before = $pos.before();
-  return Decoration.node(before, before + node.nodeSize, {
-    "class": "prosekit-placeholder",
-    "data-placeholder": placeholderText
-  });
+	if (!placeholderText) return null;
+	const { selection } = state;
+	if (!selection.empty) return null;
+	const $pos = selection.$anchor;
+	const node = $pos.parent;
+	if (node.content.size > 0) return null;
+	const before = $pos.before();
+	return Decoration.node(before, before + node.nodeSize, {
+		"class": "prosekit-placeholder",
+		"data-placeholder": placeholderText
+	});
 }
-export {
-  definePlaceholder
-};
+
+//#endregion
+export { definePlaceholder };

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

@@ -1 +1,13 @@
-export { defineReadonly } from './_tsup-dts-rollup.js';
+import { PlainExtension } from "@prosekit/core";
+
+//#region src/readonly/index.d.ts
+/**
+* Make the editor read-only.
+*/
+/**
+* Make the editor read-only.
+*/
+declare function defineReadonly(): PlainExtension;
+
+//#endregion
+export { defineReadonly };

package/dist/prosekit-extensions-readonly.js

@@ -1,18 +1,17 @@
-// src/readonly/index.ts
 import { definePlugin } from "@prosekit/core";
-import {
-  PluginKey,
-  ProseMirrorPlugin
-} from "@prosekit/pm/state";
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+
+//#region src/readonly/index.ts
+/**
+* Make the editor read-only.
+*/
 function defineReadonly() {
-  return definePlugin(plugin);
+	return definePlugin(plugin);
 }
-var plugin = new ProseMirrorPlugin({
-  key: new PluginKey("prosekey-readonly"),
-  props: {
-    editable: () => false
-  }
+const plugin = new ProseMirrorPlugin({
+	key: new PluginKey("prosekey-readonly"),
+	props: { editable: () => false }
 });
-export {
-  defineReadonly
-};
+
+//#endregion
+export { defineReadonly };

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

@@ -1,3 +1,77 @@
-export { defineSearchQuery } from './_tsup-dts-rollup.js';
-export { defineSearchCommands } from './_tsup-dts-rollup.js';
-export { SearchQueryOptions } from './_tsup-dts-rollup.js';
+import { Extension, PlainExtension } from "@prosekit/core";
+
+//#region src/search/index.d.ts
+/**
+* Options for {@link defineSearchQuery}
+*
+* @public
+*/
+/**
+* Options for {@link defineSearchQuery}
+*
+* @public
+*/
+interface SearchQueryOptions {
+  /**
+  * The search string (or regular expression).
+  */
+  search: string;
+  /**
+  * The replace text.
+  */
+  replace?: string;
+  /**
+  * Indicates whether the search is case-sensitive
+  *
+  * @default false
+  */
+  caseSensitive?: boolean;
+  /**
+  * By default, string search will replace `\n`, `\r`, and `\t` in the query
+  * with newline, return, and tab characters. When this is set to true, that
+  * behavior is disabled.
+  *
+  * @default false
+  */
+  literal?: boolean;
+  /**
+  * When true, the search string is interpreted as a regular expression.
+  *
+  * @default false
+  */
+  regexp?: boolean;
+  /**
+  * Enable whole-word matching.
+  *
+  * @default false
+  */
+  wholeWord?: boolean;
+}
+/**
+* Defines an extension that stores a current search query and replace string.
+*
+* @public
+*/
+declare function defineSearchQuery(options: SearchQueryOptions): PlainExtension;
+/**
+* @internal
+*/
+type SearchCommandsExtension = Extension<{
+  Commands: {
+    findNext: [];
+    findPrev: [];
+    findNextNoWrap: [];
+    findPrevNoWrap: [];
+    replaceNext: [];
+    replaceNextNoWrap: [];
+    replaceCurrent: [];
+    replaceAll: [];
+  };
+}>;
+/**
+* Defines commands for search and replace.
+*
+* @public
+*/
+declare function defineSearchCommands(): SearchCommandsExtension; //#endregion
+export { SearchCommandsExtension, SearchQueryOptions, defineSearchCommands, defineSearchQuery };