@prosekit/extensions 0.1.5 → 0.2.0

package/dist/_tsup-dts-rollup.d.ts

@@ -3,7 +3,6 @@ import { DedentListOptions } from 'prosemirror-flat-list';
 import { EditorState } from '@prosekit/pm/state';
 import { Extension } from '@prosekit/core';
 import { ExtensionTyping } from '@prosekit/core';
-import type { HLJSApi } from 'highlight.js';
 import { IndentListOptions } from 'prosemirror-flat-list';
 import { ListAttributes } from 'prosemirror-flat-list';
 import { NodeRange } from 'prosemirror-model';
@@ -34,6 +33,11 @@ declare class AutocompleteRule {
 export { AutocompleteRule }
 export { AutocompleteRule as AutocompleteRule_alias_1 }
 
+/**
+ * The attributes for the `codeBlock` node.
+ *
+ * @public
+ */
 declare interface CodeBlockAttrs {
     language?: string;
 }
@@ -44,8 +48,6 @@ export declare function createAutocompletePlugin({ getRules, }: {
     getRules: () => AutocompleteRule[];
 }): Plugin_2;
 
-export declare function createPredictionPlugin(options: SuggestionOptions): Plugin_2;
-
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
 export declare const default_alias_1: {
@@ -58,10 +60,6 @@ export declare function defaultCanMatch({ state }: {
     state: EditorState;
 }): boolean;
 
-export declare function defaultIsValid({ state }: {
-    state: EditorState;
-}): boolean;
-
 export declare function defineAutocomplete(rule: AutocompleteRule): Extension;
 
 /**
@@ -108,46 +106,67 @@ toggleCode: [];
 }>;
 
 /**
+ * Adds `codeBlock` nodes to the editor. This includes the following extensions:
+ *
+ * - {@link defineCodeBlockSpec}
+ * - {@link defineCodeBlockInputRule}
+ * - {@link defineCodeBlockCommands}.
+ *
  * @public
  */
-export declare function defineCodeBlock(options?: {
-    /**
-     * @deprecated Use `highlight` instead.
-     */
-    hljs?: HLJSApi;
-    /**
-     * A parser for the `prosemirror-highlight` package to use for syntax highlighting.
-     */
-    parser?: HighlightParser;
-}): Extension<    {
+export declare function defineCodeBlock(): Extension<    {
 NODES: "codeBlock";
 COMMAND_ARGS: {
 setCodeBlockLanguage: [language: string];
 };
 }>;
 
-export declare function defineCodeBlockCommands(): Extension<    {
+/**
+ * Adds commands for working with `codeBlock` nodes.
+ *
+ * @public
+ */
+declare function defineCodeBlockCommands(): Extension<    {
 COMMAND_ARGS: {
 setCodeBlockLanguage: [language: string];
 };
 }>;
-
-export declare function defineCodeBlockHighlight({ parser }: {
-    parser: Parser;
-}): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineCodeBlockCommands }
+export { defineCodeBlockCommands as defineCodeBlockCommands_alias_1 }
 
 /**
- * @deprecated
+ * 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.
+ *
+ * @public
  */
-export declare function defineCodeBlockHighlightDeprecated(options: {
-    hljs?: HLJSApi;
-}): Extension<ExtensionTyping<string, string, CommandArgs>>;
+declare function defineCodeBlockHighlight({ parser, }: {
+    parser: HighlightParser;
+}): Extension;
+export { defineCodeBlockHighlight }
+export { defineCodeBlockHighlight as defineCodeBlockHighlight_alias_1 }
 
-export declare function defineCodeBlockInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+/**
+ * Adds input rules for `codeBlock` nodes.
+ *
+ * @public
+ */
+declare function defineCodeBlockInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineCodeBlockInputRule }
+export { defineCodeBlockInputRule as defineCodeBlockInputRule_alias_1 }
 
-export declare function defineCodeBlockSpec(): Extension<    {
+/**
+ * Defines the `codeBlock` node spec.
+ *
+ * @public
+ */
+declare function defineCodeBlockSpec(): Extension<    {
 NODES: "codeBlock";
 }>;
+export { defineCodeBlockSpec }
+export { defineCodeBlockSpec as defineCodeBlockSpec_alias_1 }
 
 export declare function defineCodeCommands(): Extension<    {
 COMMAND_ARGS: {
@@ -359,11 +378,6 @@ export declare function defineStrikeSpec(): Extension<    {
 MARKS: "strike";
 }>;
 
-/**
- * @deprecated Use `defineAutocomplete` instead.
- */
-export declare function defineSuggestion(options: SuggestionOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
-
 /**
  * @public
  */
@@ -399,7 +413,9 @@ export declare interface HeadingAttrs {
  *
  * An alias for the `Parser` type from the `prosemirror-highlight` package.
  */
-export declare type HighlightParser = Parser;
+declare type HighlightParser = Parser;
+export { HighlightParser }
+export { HighlightParser as HighlightParser_alias_1 }
 
 export declare interface ImageAttrs {
     src?: string | null;
@@ -423,18 +439,6 @@ declare type MatchHandler = (options: {
 export { MatchHandler }
 export { MatchHandler as MatchHandler_alias_1 }
 
-/**
- * @returns Return a Transaction object if you want to append a transaction to current state (using )
- */
-declare type MatchHandler_2 = (options: {
-    rule: PredictionRule;
-    match: RegExpMatchArray;
-    matchAfter: RegExpMatchArray | null;
-    state: EditorState;
-    dismiss: VoidFunction;
-    deleteMatch: VoidFunction;
-}) => void;
-
 export declare interface MentionAttrs {
     id: string;
     kind: string;
@@ -471,31 +475,6 @@ export declare interface PredictionPluginState {
     } | null;
 }
 
-declare interface PredictionRule {
-    match: RegExp;
-    matchAfter?: RegExp;
-}
-export { PredictionRule }
-export { PredictionRule as PredictionRule_alias_1 }
-
 export declare function setTrMeta(tr: Transaction, meta: PredictionPluginState): Transaction;
 
-declare interface SuggestionOptions {
-    rules: PredictionRule[];
-    onMatch: MatchHandler_2;
-    onDeactivate: VoidFunction;
-    /**
-     * You can pass this function if you want to skip the matching in some cases.
-     * By default, the plugin will only run the matching if the current selection
-     * is empty, and the selection is not inside a
-     * [code](https://prosemirror.net/docs/ref/#model.NodeSpec.code) node nor
-     * inside a mark with the name as `code`.
-     */
-    isValid?: (options: {
-        state: EditorState;
-    }) => boolean;
-}
-export { SuggestionOptions }
-export { SuggestionOptions as SuggestionOptions_alias_1 }
-
 export { }

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

@@ -1,6 +1,7 @@
-export { defineCodeBlockSpec } from './_tsup-dts-rollup';
-export { defineCodeBlockInputRule } from './_tsup-dts-rollup';
-export { defineCodeBlockCommands } from './_tsup-dts-rollup';
 export { defineCodeBlock } from './_tsup-dts-rollup';
+export { defineCodeBlockCommands_alias_1 as defineCodeBlockCommands } from './_tsup-dts-rollup';
+export { defineCodeBlockHighlight_alias_1 as defineCodeBlockHighlight } from './_tsup-dts-rollup';
+export { defineCodeBlockInputRule_alias_1 as defineCodeBlockInputRule } from './_tsup-dts-rollup';
+export { defineCodeBlockSpec_alias_1 as defineCodeBlockSpec } from './_tsup-dts-rollup';
 export { CodeBlockAttrs_alias_1 as CodeBlockAttrs } from './_tsup-dts-rollup';
-export { HighlightParser } from './_tsup-dts-rollup';
+export { HighlightParser_alias_1 as HighlightParser } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-code-block.js

@@ -1,64 +1,50 @@
 // src/code-block/index.ts
-import {
-  defineCommands,
-  defineInputRule,
-  defineNodeSpec,
-  getNodeType,
-  union
-} from "@prosekit/core";
-import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
+import { union } from "@prosekit/core";
+
+// src/code-block/code-block-commands.ts
+import { defineCommands } from "@prosekit/core";
+function defineCodeBlockCommands() {
+  return defineCommands({
+    setCodeBlockLanguage: (language) => (state, dispatch) => {
+      const pos = state.selection.$from.before();
+      const codeBlock = state.doc.nodeAt(pos);
+      if (!codeBlock || codeBlock.type.name !== "codeBlock") {
+        return false;
+      }
+      const { tr } = state;
+      tr.setNodeMarkup(pos, void 0, { language });
+      dispatch == null ? void 0 : dispatch(tr);
+      return true;
+    }
+  });
+}
 
 // src/code-block/code-block-highlight.ts
 import { definePlugin } from "@prosekit/core";
 import { createHighlightPlugin } from "prosemirror-highlight";
-function defineCodeBlockHighlight({ parser }) {
+function defineCodeBlockHighlight({
+  parser
+}) {
   return definePlugin(
     createHighlightPlugin({ parser, nodeTypes: ["codeBlock"] })
   );
 }
 
-// src/code-block/code-block-highlight-deprecated.ts
-import { definePlugin as definePlugin2 } from "@prosekit/core";
-import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
-import { DecorationSet } from "@prosekit/pm/view";
-import { getHighlightDecorations } from "prosemirror-highlightjs";
-function defineCodeBlockHighlightDeprecated(options) {
-  const hljs = options.hljs;
-  const plugin = new ProseMirrorPlugin({
-    key,
-    state: {
-      init(_config, state) {
-        const decorations = hljs ? getHighlightDecorations(
-          state.doc,
-          hljs,
-          blockTypes,
-          languageExtractor
-        ) : [];
-        return DecorationSet.create(state.doc, decorations);
-      },
-      apply(tr, set) {
-        if (!tr.docChanged) {
-          return set.map(tr.mapping, tr.doc);
-        }
-        const decorations = hljs ? getHighlightDecorations(tr.doc, hljs, blockTypes, languageExtractor) : [];
-        return DecorationSet.create(tr.doc, decorations);
-      }
-    },
-    props: {
-      decorations(state) {
-        return key.getState(state);
-      }
-    }
+// src/code-block/code-block-input-rule.ts
+import { defineInputRule, getNodeType } from "@prosekit/core";
+import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
+function defineCodeBlockInputRule() {
+  return defineInputRule(({ schema }) => {
+    const nodeType = getNodeType(schema, "codeBlock");
+    const getAttrs = (match) => {
+      return { language: match[1] || "" };
+    };
+    return textblockTypeInputRule(/^```(\S*)\s$/, nodeType, getAttrs);
   });
-  return definePlugin2(plugin);
-}
-var key = new PluginKey("prosekit-code-block-highlight");
-var blockTypes = ["codeBlock"];
-function languageExtractor(node) {
-  return node.attrs.language || "javascript";
 }
 
-// src/code-block/index.ts
+// src/code-block/code-block-spec.ts
+import { defineNodeSpec } from "@prosekit/core";
 function defineCodeBlockSpec() {
   return defineNodeSpec({
     name: "codeBlock",
@@ -88,49 +74,19 @@ function defineCodeBlockSpec() {
     }
   });
 }
-function defineCodeBlockInputRule() {
-  return defineInputRule(({ schema }) => {
-    const nodeType = getNodeType(schema, "codeBlock");
-    const getAttrs = (match) => {
-      return { language: match[1] || "" };
-    };
-    return textblockTypeInputRule(/^```(\S*)\s$/, nodeType, getAttrs);
-  });
-}
-function defineCodeBlockCommands() {
-  return defineCommands({
-    setCodeBlockLanguage: (language) => (state, dispatch) => {
-      const pos = state.selection.$from.before();
-      const codeBlock = state.doc.nodeAt(pos);
-      if (!codeBlock || codeBlock.type.name !== "codeBlock") {
-        return false;
-      }
-      const { tr } = state;
-      tr.setNodeMarkup(pos, void 0, { language });
-      dispatch == null ? void 0 : dispatch(tr);
-      return true;
-    }
-  });
-}
-function defineCodeBlock(options) {
-  const extensions = [
+
+// src/code-block/index.ts
+function defineCodeBlock() {
+  return union([
     defineCodeBlockSpec(),
     defineCodeBlockInputRule(),
     defineCodeBlockCommands()
-  ];
-  const parser = options == null ? void 0 : options.parser;
-  if (parser) {
-    extensions.push(defineCodeBlockHighlight({ parser }));
-  }
-  const hljs = options == null ? void 0 : options.hljs;
-  if (hljs) {
-    extensions.push(defineCodeBlockHighlightDeprecated({ hljs }));
-  }
-  return union(extensions);
+  ]);
 }
 export {
   defineCodeBlock,
   defineCodeBlockCommands,
+  defineCodeBlockHighlight,
   defineCodeBlockInputRule,
   defineCodeBlockSpec
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -106,11 +106,6 @@
       "import": "./dist/prosekit-extensions-strike.js",
       "default": "./dist/prosekit-extensions-strike.js"
     },
-    "./suggestion": {
-      "types": "./dist/prosekit-extensions-suggestion.d.ts",
-      "import": "./dist/prosekit-extensions-suggestion.js",
-      "default": "./dist/prosekit-extensions-suggestion.js"
-    },
     "./underline": {
       "types": "./dist/prosekit-extensions-underline.d.ts",
       "import": "./dist/prosekit-extensions-underline.js",
@@ -121,18 +116,16 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/core": "^0.1.0",
-    "@prosekit/pm": "^0.1.0",
-    "highlight.js": "^11.9.0",
+    "@prosekit/core": "^0.2.0",
+    "@prosekit/pm": "^0.1.1",
     "prosemirror-flat-list": "^0.4.5",
-    "prosemirror-highlight": "^0.3.1",
-    "prosemirror-highlightjs": "^0.9.1"
+    "prosemirror-highlight": "^0.3.3"
   },
   "devDependencies": {
     "@prosekit/dev": "*",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
-    "vitest": "^1.0.2"
+    "vitest": "^1.1.0"
   },
   "scripts": {
     "build:tsup": "tsup",
@@ -186,9 +179,6 @@
       "strike": [
         "./dist/prosekit-extensions-strike.d.ts"
       ],
-      "suggestion": [
-        "./dist/prosekit-extensions-suggestion.d.ts"
-      ],
       "underline": [
         "./dist/prosekit-extensions-underline.d.ts"
       ]

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

@@ -1,3 +0,0 @@
-export { defineSuggestion } from './_tsup-dts-rollup';
-export { PredictionRule } from './_tsup-dts-rollup';
-export { SuggestionOptions } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-suggestion.js

@@ -1,161 +0,0 @@
-// src/suggestion/index.ts
-import { definePlugin } from "@prosekit/core";
-
-// src/suggestion/plugin.ts
-import { ProseKitError } from "@prosekit/core";
-import { Plugin, PluginKey } from "@prosekit/pm/state";
-import { Decoration, DecorationSet } from "@prosekit/pm/view";
-
-// src/suggestion/is-valid.ts
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function defaultIsValid({ state }) {
-  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");
-}
-
-// src/suggestion/plugin.ts
-var pluginKey = new PluginKey("prosemirror-prediction");
-function getPluginState(state) {
-  return pluginKey.getState(state);
-}
-function getTrMeta(tr) {
-  return tr.getMeta(pluginKey);
-}
-function setTrMeta(tr, meta) {
-  return tr.setMeta(pluginKey, meta);
-}
-function createPredictionPlugin(options) {
-  if (options.rules.length === 0) {
-    throw new ProseKitError(
-      "You can't create a prediction plugin without rules"
-    );
-  }
-  const { onMatch, onDeactivate, isValid = defaultIsValid } = options;
-  return new Plugin({
-    key: pluginKey,
-    state: {
-      init: () => {
-        return { active: false, ignore: null, matching: null };
-      },
-      apply: (tr, prevValue, oldState, newState) => {
-        var _a;
-        const meta = getTrMeta(tr);
-        if (!tr.docChanged && oldState.selection.eq(newState.selection) && !meta) {
-          return prevValue;
-        }
-        if (meta) {
-          return meta;
-        }
-        if (!isValid({ state: newState })) {
-          return { active: false, ignore: null, matching: null };
-        }
-        const nextValue = calcPluginState(newState, options.rules);
-        if (nextValue.active && prevValue.ignore != null && ((_a = nextValue.matching) == null ? void 0 : _a.from) === prevValue.ignore) {
-          return prevValue;
-        }
-        return nextValue;
-      }
-    },
-    view: () => ({
-      update: (view, prevState) => {
-        const prevPluginState = getPluginState(prevState);
-        const currPluginState = getPluginState(view.state);
-        if ((currPluginState == null ? void 0 : currPluginState.active) && currPluginState.matching && currPluginState.matching.from !== currPluginState.ignore) {
-          const { from, to } = currPluginState.matching;
-          const dismiss = () => {
-            view.dispatch(
-              setTrMeta(view.state.tr, {
-                active: false,
-                ignore: from,
-                matching: null
-              })
-            );
-          };
-          const textContent = view.state.doc.textBetween(from, to, "\uFFFC");
-          const deleteMatch = () => {
-            if (view.state.doc.textBetween(from, to, "\uFFFC") === textContent) {
-              view.dispatch(view.state.tr.delete(from, to));
-            }
-          };
-          onMatch({
-            rule: currPluginState.matching.rule,
-            match: currPluginState.matching.match,
-            matchAfter: currPluginState.matching.matchAfter,
-            state: view.state,
-            dismiss,
-            deleteMatch
-          });
-        } else if (prevPluginState == null ? void 0 : prevPluginState.active) {
-          onDeactivate();
-        }
-      }
-    }),
-    props: {
-      decorations: (state) => {
-        const pluginState = getPluginState(state);
-        if ((pluginState == null ? void 0 : 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;
-      }
-    }
-  });
-}
-function calcPluginState(state, rules) {
-  const { $anchor } = state.selection;
-  const matchAfter = rules.some((rule) => rule.matchAfter);
-  const parentOffset = $anchor.parentOffset;
-  const textBefore = $anchor.parent.textBetween(
-    Math.max(0, parentOffset - MAX_MATCH),
-    parentOffset,
-    null,
-    "\uFFFC"
-  );
-  const textAfter = matchAfter ? $anchor.parent.textBetween(
-    parentOffset,
-    Math.min(parentOffset + MAX_MATCH, $anchor.parent.content.size),
-    null
-  ) : "";
-  for (const rule of rules) {
-    const match = textBefore.match(rule.match);
-    const matchAfter2 = rule.matchAfter ? textAfter.match(rule.matchAfter) : null;
-    if ((match == null ? void 0 : match.index) != null) {
-      const from = $anchor.pos - textBefore.length + match.index;
-      const to = $anchor.pos + (matchAfter2 ? matchAfter2[0].length : 0);
-      return {
-        active: true,
-        ignore: null,
-        matching: {
-          rule,
-          from,
-          to,
-          match,
-          matchAfter: matchAfter2
-        }
-      };
-    }
-  }
-  return { active: false };
-}
-var MAX_MATCH = 200;
-
-// src/suggestion/index.ts
-function defineSuggestion(options) {
-  const plugin = createPredictionPlugin(options);
-  return definePlugin(plugin);
-}
-export {
-  defineSuggestion
-};