@prosekit/extensions 0.0.3 → 0.0.5

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

@@ -0,0 +1,31 @@
+import { Extension } from '@prosekit/core';
+import { EditorState, Transaction } from '@prosekit/pm/state';
+
+type MatchHandler = (options: {
+    state: EditorState;
+    match: RegExpExecArray;
+    from: number;
+    to: number;
+    ignoreMatch: () => void;
+    deleteMatch: () => void;
+}) => Transaction | null | void;
+declare class AutocompleteRule {
+    readonly regex: RegExp;
+    readonly onMatch: MatchHandler;
+    readonly onLeave?: VoidFunction;
+    readonly canMatch: (options: {
+        state: EditorState;
+    }) => boolean;
+    constructor(options: {
+        regex: RegExp;
+        onEnter: MatchHandler;
+        onLeave?: VoidFunction;
+        canMatch?: (options: {
+            state: EditorState;
+        }) => boolean;
+    });
+}
+
+declare function addAutocomplete(rule: AutocompleteRule): Extension;
+
+export { AutocompleteRule, MatchHandler, addAutocomplete };

package/dist/prosekit-extensions-autocomplete.js

@@ -0,0 +1,178 @@
+// src/autocomplete/index.ts
+import {
+  Facet,
+  pluginFacet
+} from "@prosekit/core";
+
+// src/autocomplete/plugin.ts
+import { Plugin } from "@prosekit/pm/state";
+import { Decoration, DecorationSet } from "@prosekit/pm/view";
+
+// src/autocomplete/helpers.ts
+import "@prosekit/pm/model";
+import { PluginKey } from "@prosekit/pm/state";
+function defaultCanMatch({ 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");
+}
+var OBJECT_REPLACEMENT = "\uFFFC";
+function getPluginState(state) {
+  return pluginKey.getState(state);
+}
+function getTrMeta(tr) {
+  return tr.getMeta(pluginKey);
+}
+function setTrMeta(tr, meta) {
+  return tr.setMeta(pluginKey, meta);
+}
+var pluginKey = new PluginKey(
+  "prosemirror-prediction"
+);
+
+// src/autocomplete/plugin.ts
+function createAutocompletePlugin({
+  rules
+}) {
+  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;
+        }
+        const nextValue = calcPluginState(newState, 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) => {
+        var _a, _b, _c;
+        const prevValue = getPluginState(prevState);
+        const currValue = getPluginState(view.state);
+        if ((prevValue == null ? void 0 : prevValue.active) && prevValue.matching && prevValue.matching.rule !== ((_a = currValue == null ? void 0 : currValue.matching) == null ? void 0 : _a.rule)) {
+          (_c = (_b = prevValue.matching.rule).onLeave) == null ? void 0 : _c.call(_b);
+        }
+        if ((currValue == null ? void 0 : currValue.active) && currValue.matching && currValue.matching.from !== currValue.ignore) {
+          const { from, to, match, rule } = currValue.matching;
+          const textContent = view.state.doc.textBetween(
+            from,
+            to,
+            OBJECT_REPLACEMENT
+          );
+          const deleteMatch = () => {
+            if (view.state.doc.textBetween(from, to, OBJECT_REPLACEMENT) === 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 == 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;
+      }
+    }
+  });
+}
+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
+  );
+  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 };
+}
+
+// src/autocomplete/rule.ts
+var AutocompleteRule = class {
+  constructor(options) {
+    var _a;
+    this.regex = options.regex;
+    this.onMatch = options.onEnter;
+    this.onLeave = options.onLeave;
+    this.canMatch = (_a = options.canMatch) != null ? _a : defaultCanMatch;
+  }
+};
+
+// src/autocomplete/index.ts
+function addAutocomplete(rule) {
+  return autocompleteFacet.extension([rule]);
+}
+var autocompleteFacet = Facet.define({
+  combine: (rules) => {
+    return () => [createAutocompletePlugin({ rules })];
+  },
+  next: pluginFacet
+});
+export {
+  AutocompleteRule,
+  addAutocomplete
+};

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

@@ -6,10 +6,11 @@ interface HeadingAttrs {
 declare function addHeadingSpec(): _prosekit_core.Extension<{
     NODES: "heading";
 }>;
+declare function addHeadingKeymap(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
 declare function addHeadingInputRule(): _prosekit_core.Extension<_prosekit_core.ExtensionTyping<string, string, _prosekit_core.CommandArgs>>;
 /** @public */
 declare function addHeading(): _prosekit_core.Extension<{
     NODES: "heading";
 }>;
 
-export { HeadingAttrs, addHeading, addHeadingInputRule, addHeadingSpec };
+export { HeadingAttrs, addHeading, addHeadingInputRule, addHeadingKeymap, addHeadingSpec };

package/dist/prosekit-extensions-heading.js

@@ -1,9 +1,11 @@
 // src/heading/index.ts
 import {
   addInputRule,
+  addKeymap,
   addNodeSpec,
   defineExtension,
-  getNodeType
+  getNodeType,
+  toggleNode
 } from "@prosekit/core";
 import { textblockTypeInputRule } from "@prosekit/pm/inputrules";
 function addHeadingSpec() {
@@ -28,6 +30,16 @@ function addHeadingSpec() {
     }
   });
 }
+function addHeadingKeymap() {
+  return addKeymap({
+    "mod-1": toggleNode({ type: "heading", attrs: { level: 1 } }),
+    "mod-2": toggleNode({ type: "heading", attrs: { level: 2 } }),
+    "mod-3": toggleNode({ type: "heading", attrs: { level: 3 } }),
+    "mod-4": toggleNode({ type: "heading", attrs: { level: 4 } }),
+    "mod-5": toggleNode({ type: "heading", attrs: { level: 5 } }),
+    "mod-6": toggleNode({ type: "heading", attrs: { level: 6 } })
+  });
+}
 function addHeadingInputRule() {
   return addInputRule(({ schema }) => {
     const nodeSpec = getNodeType(schema, "heading");
@@ -44,10 +56,15 @@ function addHeadingInputRule() {
   });
 }
 function addHeading() {
-  return defineExtension([addHeadingSpec(), addHeadingInputRule()]);
+  return defineExtension([
+    addHeadingSpec(),
+    addHeadingInputRule(),
+    addHeadingKeymap()
+  ]);
 }
 export {
   addHeading,
   addHeadingInputRule,
+  addHeadingKeymap,
   addHeadingSpec
 };

package/dist/prosekit-extensions-placeholder.js

@@ -1,5 +1,6 @@
 // src/placeholder/index.ts
 import { addPlugin } from "@prosekit/core";
+import "@prosekit/pm/model";
 import { Plugin } from "@prosekit/pm/state";
 import { Decoration, DecorationSet } from "@prosekit/pm/view";
 function addPlaceholder(options) {

package/dist/prosekit-extensions-suggestion.js

@@ -7,6 +7,8 @@ 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);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -30,6 +30,11 @@
       "import": "./dist/prosekit-extensions.js",
       "default": "./dist/prosekit-extensions.js"
     },
+    "./autocomplete": {
+      "types": "./dist/prosekit-extensions-autocomplete.d.ts",
+      "import": "./dist/prosekit-extensions-autocomplete.js",
+      "default": "./dist/prosekit-extensions-autocomplete.js"
+    },
     "./blockquote": {
       "types": "./dist/prosekit-extensions-blockquote.d.ts",
       "import": "./dist/prosekit-extensions-blockquote.js",
@@ -81,7 +86,7 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/core": "^0.0.3",
+    "@prosekit/core": "^0.0.5",
     "@prosekit/pm": "^0.0.3",
     "prosemirror-flat-list": "^0.3.15"
   },
@@ -101,6 +106,9 @@
       ".": [
         "./dist/prosekit-extensions.d.ts"
       ],
+      "autocomplete": [
+        "./dist/prosekit-extensions-autocomplete.d.ts"
+      ],
       "blockquote": [
         "./dist/prosekit-extensions-blockquote.d.ts"
       ],