@prosekit/extensions 0.7.24 → 0.9.0

package/dist/prosekit-extensions-autocomplete.js

@@ -1,195 +1,143 @@
-// src/autocomplete/autocomplete.ts
-import {
-  defineFacet,
-  defineFacetPayload,
-  pluginFacet
-} from "@prosekit/core";
+import { OBJECT_REPLACEMENT_CHARACTER, defineFacet, defineFacetPayload, pluginFacet } from "@prosekit/core";
+import { Plugin, PluginKey } from "@prosekit/pm/state";
+import { Decoration, DecorationSet } from "@prosekit/pm/view";
 
-// src/autocomplete/autocomplete-plugin.ts
-import { OBJECT_REPLACEMENT_CHARACTER } from "@prosekit/core";
-import {
-  Plugin
-} from "@prosekit/pm/state";
-import {
-  Decoration,
-  DecorationSet
-} from "@prosekit/pm/view";
-
-// src/autocomplete/autocomplete-helpers.ts
-import {
-  PluginKey
-} from "@prosekit/pm/state";
+//#region src/autocomplete/autocomplete-helpers.ts
 function defaultCanMatch({ state }) {
-  return state.selection.empty && !isInsideCode(state.selection.$from);
+	return state.selection.empty && !isInsideCode(state.selection.$from);
 }
 function isInsideCode($pos) {
-  for (let d = $pos.depth; d > 0; d--) {
-    if ($pos.node(d).type.spec.code) {
-      return true;
-    }
-  }
-  return $pos.marks().some((mark) => mark.type.name === "code");
+	for (let d = $pos.depth; d > 0; d--) if ($pos.node(d).type.spec.code) return true;
+	return $pos.marks().some((mark) => mark.type.name === "code");
 }
 function getPluginState(state) {
-  return pluginKey.getState(state);
+	return pluginKey.getState(state);
 }
 function getTrMeta(tr) {
-  return tr.getMeta(pluginKey);
+	return tr.getMeta(pluginKey);
 }
 function setTrMeta(tr, meta) {
-  return tr.setMeta(pluginKey, meta);
+	return tr.setMeta(pluginKey, meta);
 }
-var pluginKey = new PluginKey(
-  "prosekit-autocomplete"
-);
+const pluginKey = new PluginKey("prosekit-autocomplete");
 
-// src/autocomplete/autocomplete-plugin.ts
-function createAutocompletePlugin({
-  getRules
-}) {
-  return new Plugin({
-    key: pluginKey,
-    state: {
-      init: () => {
-        return { active: false, ignore: null, matching: null };
-      },
-      apply: (tr, prevValue, oldState, newState) => {
-        const meta = getTrMeta(tr);
-        if (!tr.docChanged && oldState.selection.eq(newState.selection) && !meta) {
-          return prevValue;
-        }
-        if (meta) {
-          return meta;
-        }
-        const nextValue = calcPluginState(newState, getRules());
-        if (nextValue.active && prevValue.ignore != null && nextValue.matching?.from === prevValue.ignore) {
-          return prevValue;
-        }
-        return nextValue;
-      }
-    },
-    view: () => ({
-      update: (view, prevState) => {
-        const prevValue = getPluginState(prevState);
-        const currValue = getPluginState(view.state);
-        if (prevValue?.active && prevValue.matching && prevValue.matching.rule !== currValue?.matching?.rule) {
-          prevValue.matching.rule.onLeave?.();
-        }
-        if (currValue?.active && currValue.matching && currValue.matching.from !== currValue.ignore) {
-          const { from, to, match, rule } = currValue.matching;
-          const textContent = view.state.doc.textBetween(
-            from,
-            to,
-            null,
-            OBJECT_REPLACEMENT_CHARACTER
-          );
-          const deleteMatch = () => {
-            if (view.state.doc.textBetween(
-              from,
-              to,
-              null,
-              OBJECT_REPLACEMENT_CHARACTER
-            ) === textContent) {
-              view.dispatch(view.state.tr.delete(from, to));
-            }
-          };
-          const ignoreMatch = () => {
-            view.dispatch(
-              setTrMeta(view.state.tr, {
-                active: false,
-                ignore: from,
-                matching: null
-              })
-            );
-          };
-          rule.onMatch({
-            state: view.state,
-            match,
-            from,
-            to,
-            deleteMatch,
-            ignoreMatch
-          });
-        }
-      }
-    }),
-    props: {
-      decorations: (state) => {
-        const pluginState = getPluginState(state);
-        if (pluginState?.active && pluginState.matching) {
-          const { from, to } = pluginState.matching;
-          const deco = Decoration.inline(from, to, {
-            class: "prosemirror-prediction-match"
-          });
-          return DecorationSet.create(state.doc, [deco]);
-        }
-        return null;
-      }
-    }
-  });
+//#endregion
+//#region src/autocomplete/autocomplete-plugin.ts
+function createAutocompletePlugin({ getRules }) {
+	return new Plugin({
+		key: pluginKey,
+		state: {
+			init: () => {
+				return {
+					ignores: [],
+					matching: null
+				};
+			},
+			apply: (tr, prevValue, oldState, newState) => {
+				const meta = getTrMeta(tr);
+				if (!tr.docChanged && oldState.selection.eq(newState.selection) && !meta) return prevValue;
+				if (meta) {
+					let ignores = prevValue.ignores;
+					if (!ignores.includes(meta.ignore)) ignores = [...ignores, meta.ignore];
+					return {
+						matching: null,
+						ignores
+					};
+				}
+				const ignoreSet = new Set(prevValue.ignores.map((pos) => tr.mapping.map(pos)));
+				let matching = calcPluginStateMatching(newState, getRules());
+				if (matching && ignoreSet.has(matching.from)) matching = null;
+				return {
+					matching,
+					ignores: Array.from(ignoreSet)
+				};
+			}
+		},
+		view: () => ({ update: (view, prevState) => {
+			const prevValue = getPluginState(prevState);
+			const currValue = getPluginState(view.state);
+			if (prevValue?.matching && prevValue.matching.rule !== currValue?.matching?.rule) prevValue.matching.rule.onLeave?.();
+			if (currValue?.matching && !currValue.ignores.includes(currValue.matching.from)) {
+				const { from, to, match, rule } = currValue.matching;
+				const textContent = view.state.doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER);
+				const deleteMatch = () => {
+					if (view.state.doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER) === textContent) view.dispatch(view.state.tr.delete(from, to));
+				};
+				const ignoreMatch = () => {
+					view.dispatch(setTrMeta(view.state.tr, { ignore: from }));
+				};
+				rule.onMatch({
+					state: view.state,
+					match,
+					from,
+					to,
+					deleteMatch,
+					ignoreMatch
+				});
+			}
+		} }),
+		props: { decorations: (state) => {
+			const pluginState = getPluginState(state);
+			if (pluginState?.matching) {
+				const { from, to } = pluginState.matching;
+				const deco = Decoration.inline(from, to, { class: "prosemirror-prediction-match" });
+				return DecorationSet.create(state.doc, [deco]);
+			}
+			return null;
+		} }
+	});
 }
-var MAX_MATCH = 200;
-function calcPluginState(state, rules) {
-  const $pos = state.selection.$from;
-  const parentOffset = $pos.parentOffset;
-  const textBefore = $pos.parent.textBetween(
-    Math.max(0, parentOffset - MAX_MATCH),
-    parentOffset,
-    null,
-    OBJECT_REPLACEMENT_CHARACTER
-  );
-  for (const rule of rules) {
-    if (!rule.canMatch({ state })) {
-      continue;
-    }
-    rule.regex.lastIndex = 0;
-    const match = rule.regex.exec(textBefore);
-    if (!match) {
-      continue;
-    }
-    const from = $pos.pos - textBefore.length + match.index;
-    return {
-      active: true,
-      ignore: null,
-      matching: {
-        rule,
-        match,
-        from,
-        to: $pos.pos
-      }
-    };
-  }
-  return { active: false, ignore: null, matching: null };
+const MAX_MATCH = 200;
+function calcPluginStateMatching(state, rules) {
+	const $pos = state.selection.$from;
+	const parentOffset = $pos.parentOffset;
+	const textBefore = $pos.parent.textBetween(Math.max(0, parentOffset - MAX_MATCH), parentOffset, null, OBJECT_REPLACEMENT_CHARACTER);
+	for (const rule of rules) {
+		if (!rule.canMatch({ state })) continue;
+		rule.regex.lastIndex = 0;
+		const match = rule.regex.exec(textBefore);
+		if (!match) continue;
+		const to = $pos.pos;
+		const from = to - textBefore.length + match.index;
+		return {
+			rule,
+			match,
+			from,
+			to
+		};
+	}
+	return null;
 }
 
-// src/autocomplete/autocomplete.ts
+//#endregion
+//#region src/autocomplete/autocomplete.ts
 function defineAutocomplete(rule) {
-  return defineFacetPayload(autocompleteFacet, [rule]);
+	return defineFacetPayload(autocompleteFacet, [rule]);
 }
-var autocompleteFacet = defineFacet({
-  reduce: () => {
-    let rules = [];
-    const getRules = () => rules;
-    const plugin = createAutocompletePlugin({ getRules });
-    return function reducer(inputs) {
-      rules = inputs;
-      return plugin;
-    };
-  },
-  parent: pluginFacet,
-  singleton: true
+const autocompleteFacet = defineFacet({
+	reduce: () => {
+		let rules = [];
+		const getRules = () => rules;
+		const plugin = createAutocompletePlugin({ getRules });
+		return function reducer(inputs) {
+			rules = inputs;
+			return plugin;
+		};
+	},
+	parent: pluginFacet,
+	singleton: true
 });
 
-// src/autocomplete/autocomplete-rule.ts
+//#endregion
+//#region src/autocomplete/autocomplete-rule.ts
 var AutocompleteRule = class {
-  constructor(options) {
-    this.regex = options.regex;
-    this.onMatch = options.onEnter;
-    this.onLeave = options.onLeave;
-    this.canMatch = options.canMatch ?? defaultCanMatch;
-  }
-};
-export {
-  AutocompleteRule,
-  defineAutocomplete
+	constructor(options) {
+		this.regex = options.regex;
+		this.onMatch = options.onEnter;
+		this.onLeave = options.onLeave;
+		this.canMatch = options.canMatch ?? defaultCanMatch;
+	}
 };
+
+//#endregion
+export { AutocompleteRule, defineAutocomplete };

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

@@ -1,8 +1,51 @@
-export { defineBlockquote_alias_1 as defineBlockquote } from './_tsup-dts-rollup.js';
-export { BlockquoteExtension_alias_1 as BlockquoteExtension } from './_tsup-dts-rollup.js';
-export { defineBlockquoteCommands_alias_1 as defineBlockquoteCommands } from './_tsup-dts-rollup.js';
-export { BlockquoteCommandsExtension_alias_1 as BlockquoteCommandsExtension } from './_tsup-dts-rollup.js';
-export { defineBlockquoteInputRule_alias_1 as defineBlockquoteInputRule } from './_tsup-dts-rollup.js';
-export { defineBlockquoteKeymap_alias_1 as defineBlockquoteKeymap } from './_tsup-dts-rollup.js';
-export { defineBlockquoteSpec_alias_1 as defineBlockquoteSpec } from './_tsup-dts-rollup.js';
-export { BlockquoteSpecExtension_alias_1 as BlockquoteSpecExtension } from './_tsup-dts-rollup.js';
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+import { Attrs } from "@prosekit/pm/model";
+
+//#region src/blockquote/blockquote-commands.d.ts
+type BlockquoteCommandsExtension = Extension<{
+  Commands: {
+    setBlockquote: [];
+    insertBlockquote: [];
+    toggleBlockquote: [];
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineBlockquoteCommands(): BlockquoteCommandsExtension; //#endregion
+//#region src/blockquote/blockquote-spec.d.ts
+type BlockquoteSpecExtension = Extension<{
+  Nodes: {
+    blockquote: Attrs;
+  };
+}>;
+declare function defineBlockquoteSpec(): BlockquoteSpecExtension;
+
+//#endregion
+//#region src/blockquote/blockquote.d.ts
+/**
+* @internal
+*/
+type BlockquoteExtension = Union<[BlockquoteSpecExtension, BlockquoteCommandsExtension]>;
+/**
+* @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.
+*/
+declare function defineBlockquoteInputRule(): PlainExtension;
+
+//#endregion
+//#region src/blockquote/blockquote-keymap.d.ts
+/**
+* @internal
+*/
+declare function defineBlockquoteKeymap(): PlainExtension;
+
+//#endregion
+export { BlockquoteCommandsExtension, BlockquoteExtension, BlockquoteSpecExtension, defineBlockquote, defineBlockquoteCommands, defineBlockquoteInputRule, defineBlockquoteKeymap, defineBlockquoteSpec };

package/dist/prosekit-extensions-blockquote.js

@@ -1,97 +1,83 @@
-import {
-  defineWrappingInputRule
-} from "./chunk-BV3SHIMW.js";
-
-// src/blockquote/blockquote.ts
-import {
-  union
-} from "@prosekit/core";
+import { defineWrappingInputRule } from "./input-rule-Gji4N7Oe.js";
+import { defineCommands, defineKeymap, defineNodeSpec, insertNode, isAtBlockStart, toggleWrap, union, wrap } from "@prosekit/core";
+import { joinBackward } from "@prosekit/pm/commands";
 
-// src/blockquote/blockquote-commands.ts
-import {
-  defineCommands,
-  insertNode,
-  toggleWrap,
-  wrap
-} from "@prosekit/core";
+//#region src/blockquote/blockquote-commands.ts
+/**
+* @internal
+*/
 function defineBlockquoteCommands() {
-  return defineCommands({
-    setBlockquote: () => {
-      return wrap({ type: "blockquote" });
-    },
-    insertBlockquote: () => {
-      return insertNode({ type: "blockquote" });
-    },
-    toggleBlockquote: () => {
-      return toggleWrap({ type: "blockquote" });
-    }
-  });
+	return defineCommands({
+		setBlockquote: () => {
+			return wrap({ type: "blockquote" });
+		},
+		insertBlockquote: () => {
+			return insertNode({ type: "blockquote" });
+		},
+		toggleBlockquote: () => {
+			return toggleWrap({ type: "blockquote" });
+		}
+	});
 }
 
-// src/blockquote/blockquote-input-rule.ts
+//#endregion
+//#region src/blockquote/blockquote-input-rule.ts
+/**
+* Wraps the text block in a blockquote when `>` is typed at the start of a new
+* line followed by a space.
+*/
 function defineBlockquoteInputRule() {
-  return defineWrappingInputRule({
-    regex: /^>\s/,
-    type: "blockquote"
-  });
+	return defineWrappingInputRule({
+		regex: /^>\s/,
+		type: "blockquote"
+	});
 }
 
-// src/blockquote/blockquote-keymap.ts
-import {
-  defineKeymap,
-  isAtBlockStart,
-  toggleWrap as toggleWrap2
-} from "@prosekit/core";
-import { joinBackward } from "@prosekit/pm/commands";
+//#endregion
+//#region src/blockquote/blockquote-keymap.ts
 function toggleBlockquoteKeybinding() {
-  return toggleWrap2({ type: "blockquote" });
+	return toggleWrap({ type: "blockquote" });
 }
 function backspaceUnsetBlockquote() {
-  return (state, dispatch, view) => {
-    const $pos = isAtBlockStart(state, view);
-    if ($pos?.node(-1).type.name === "blockquote") {
-      return joinBackward(state, dispatch, view);
-    }
-    return false;
-  };
+	return (state, dispatch, view) => {
+		const $pos = isAtBlockStart(state, view);
+		if ($pos?.node(-1).type.name === "blockquote") return joinBackward(state, dispatch, view);
+		return false;
+	};
 }
+/**
+* @internal
+*/
 function defineBlockquoteKeymap() {
-  return defineKeymap({
-    "mod-shift-b": toggleBlockquoteKeybinding(),
-    "Backspace": backspaceUnsetBlockquote()
-  });
+	return defineKeymap({
+		"mod-shift-b": toggleBlockquoteKeybinding(),
+		"Backspace": backspaceUnsetBlockquote()
+	});
 }
 
-// src/blockquote/blockquote-spec.ts
-import {
-  defineNodeSpec
-} from "@prosekit/core";
+//#endregion
+//#region src/blockquote/blockquote-spec.ts
 function defineBlockquoteSpec() {
-  return defineNodeSpec({
-    name: "blockquote",
-    content: "block+",
-    group: "block",
-    defining: true,
-    parseDOM: [{ tag: "blockquote" }],
-    toDOM() {
-      return ["blockquote", 0];
-    }
-  });
+	return defineNodeSpec({
+		name: "blockquote",
+		content: "block+",
+		group: "block",
+		defining: true,
+		parseDOM: [{ tag: "blockquote" }],
+		toDOM() {
+			return ["blockquote", 0];
+		}
+	});
 }
 
-// src/blockquote/blockquote.ts
+//#endregion
+//#region src/blockquote/blockquote.ts
+/**
+* @public
+*/
 function defineBlockquote() {
-  return union(
-    defineBlockquoteSpec(),
-    defineBlockquoteInputRule(),
-    defineBlockquoteCommands(),
-    defineBlockquoteKeymap()
-  );
+	return union(defineBlockquoteSpec(), defineBlockquoteInputRule(), defineBlockquoteCommands(), defineBlockquoteKeymap());
 }
-export {
-  defineBlockquote,
-  defineBlockquoteCommands,
-  defineBlockquoteInputRule,
-  defineBlockquoteKeymap,
-  defineBlockquoteSpec
-};
+
+//#endregion
+export { defineBlockquote, defineBlockquoteCommands, defineBlockquoteInputRule, defineBlockquoteKeymap, defineBlockquoteSpec };

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

@@ -1,8 +1,61 @@
-export { defineBold_alias_1 as defineBold } from './_tsup-dts-rollup.js';
-export { BoldExtension_alias_1 as BoldExtension } from './_tsup-dts-rollup.js';
-export { defineBoldCommands_alias_1 as defineBoldCommands } from './_tsup-dts-rollup.js';
-export { BoldCommandsExtension_alias_1 as BoldCommandsExtension } from './_tsup-dts-rollup.js';
-export { defineBoldInputRule_alias_1 as defineBoldInputRule } from './_tsup-dts-rollup.js';
-export { defineBoldKeymap_alias_1 as defineBoldKeymap } from './_tsup-dts-rollup.js';
-export { defineBoldSpec_alias_1 as defineBoldSpec } from './_tsup-dts-rollup.js';
-export { BoldSpecExtension_alias_1 as BoldSpecExtension } from './_tsup-dts-rollup.js';
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+import { Attrs } from "@prosekit/pm/model";
+
+//#region src/bold/bold-commands.d.ts
+/**
+* @internal
+*/
+/**
+* @internal
+*/
+type BoldCommandsExtension = Extension<{
+  Commands: {
+    toggleBold: [];
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineBoldCommands(): BoldCommandsExtension;
+//#endregion
+//#region src/bold/bold-spec.d.ts
+/**
+* @internal
+*/
+type BoldSpecExtension = Extension<{
+  Marks: {
+    bold: Attrs;
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineBoldSpec(): BoldSpecExtension;
+
+//#endregion
+//#region src/bold/bold.d.ts
+/**
+* @internal
+*/
+type BoldExtension = Union<[BoldSpecExtension, BoldCommandsExtension]>;
+/**
+* @public
+*/
+declare function defineBold(): BoldExtension;
+
+//#endregion
+//#region src/bold/bold-input-rule.d.ts
+/**
+* @internal
+*/
+declare function defineBoldInputRule(): PlainExtension;
+
+//#endregion
+//#region src/bold/bold-keymap.d.ts
+/**
+* @internal
+*/
+declare function defineBoldKeymap(): PlainExtension;
+
+//#endregion
+export { BoldCommandsExtension, BoldExtension, BoldSpecExtension, defineBold, defineBoldCommands, defineBoldInputRule, defineBoldKeymap, defineBoldSpec };