@prosekit/extensions 0.4.4 → 0.4.6

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

@@ -29,7 +29,7 @@ import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
 import { Transaction } from '@prosekit/pm/state';
 import { UnwrapListOptions } from 'prosemirror-flat-list';
 
-export declare function applyMarkRules(rules: MarkRule[], transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;
+export declare function applyMarkRules(rules: MarkRuleOptions[], transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;
 
 declare class AutocompleteRule {
     readonly regex: RegExp;
@@ -118,6 +118,11 @@ export declare function createAutocompletePlugin({ getRules, }: {
  */
 export declare function createLazyParser(highlighterOptions: HighlighterOptions): Parser;
 
+/**
+ * @internal
+ */
+export declare function createMarkInputRule({ regex, type, attrs, }: MarkInputRuleOptions): InputRule;
+
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
 export declare const default_alias_1: {
@@ -165,6 +170,8 @@ toggleBold: [];
 };
 }>;
 
+export declare function defineBoldInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 export declare function defineBoldKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
 export declare function defineBoldSpec(): Extension<    {
@@ -283,6 +290,10 @@ toggleCode: [];
 };
 }>;
 
+export declare function defineCodeInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineCodeKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 /**
  * @public
  */
@@ -385,9 +396,9 @@ toggleItalic: [];
 };
 }>;
 
-export declare function defineItalicKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineItalicInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function defineItalicKeymap_alias_1(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineItalicKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
 export declare function defineItalicSpec(): Extension<    {
 MARKS: "italic";
@@ -481,6 +492,14 @@ export declare function defineListSpec(): Extension<{
     NODES: "list";
 }>;
 
+/**
+ * Defines an input rule for automatically adding inline marks when a given
+ * pattern is typed.
+ *
+ * @public
+ */
+export declare function defineMarkInputRule(options: MarkInputRuleOptions): Extension;
+
 /**
  * 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.
@@ -539,6 +558,8 @@ toggleStrike: [];
 };
 }>;
 
+export declare function defineStrikeInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 export declare function defineStrikeKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
 export declare function defineStrikeSpec(): Extension<    {
@@ -628,8 +649,9 @@ export declare function defineTextBlockEnterRule({ regex, type, attrs, stop, }:
  */
 export declare function defineTextBlockInputRule({ regex, type, attrs, }: {
     /**
-     * The regular expression to match against. You'll usually want to start it
-     * with `^` to that it is only matched at the start of a textblock.
+     * The regular expression to match against, which should end with `$`. It
+     * usually also starts with `^` to that it is only matched at the start of a
+     * textblock.
      */
     regex: RegExp;
     /**
@@ -686,8 +708,9 @@ export declare function defineVirtualSelection(): Extension;
  */
 export declare function defineWrappingInputRule({ regex, type, attrs, join, }: {
     /**
-     * The regular expression to match against. You'll usually want to start it
-     * with `^` to that it is only matched at the start of a textblock.
+     * The regular expression to match against, which should end with `$`. It
+     * usually also starts with `^` to that it is only matched at the start of a
+     * textblock.
      */
     regex: RegExp;
     /**
@@ -839,12 +862,25 @@ export declare interface LinkAttrs {
 export { ListDOMSerializer }
 
 /**
- * @internal
+ * Options for {@link defineMarkInputRule}.
+ *
+ * @public
  */
-export declare interface MarkRule {
+export declare interface MarkInputRuleOptions {
+    /**
+     * The regular expression to match against, which should end with `$` and has
+     * exactly one capture group. All other matched text outside the capture group
+     * will be deleted.
+     */
     regex: RegExp;
+    /**
+     * The type of mark to set.
+     */
     type: string | MarkType;
-    getAttrs?: ((match: RegExpMatchArray) => Attrs | null) | null;
+    /**
+     * Attributes to set on the mark.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
 }
 
 /**

package/dist/{chunk-MX6UNVWH.js → chunk-7G7COECS.js}

@@ -3,7 +3,11 @@ import { Facet, pluginFacet } from "@prosekit/core";
 import { ProseMirrorPlugin } from "@prosekit/pm/state";
 
 // src/mark-rule/apply.ts
-import { OBJECT_REPLACEMENT_CHARACTER, getMarkType } from "@prosekit/core";
+import {
+  OBJECT_REPLACEMENT_CHARACTER,
+  getMarkType,
+  maybeRun
+} from "@prosekit/core";
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
 
@@ -77,8 +81,7 @@ function getCheckRanges(transactions, oldState, newState) {
 
 // src/mark-rule/apply.ts
 function getExpectedMarkings(rules, doc, from, to) {
-  var _a;
-  const text = doc.textBetween(from, to, OBJECT_REPLACEMENT_CHARACTER);
+  const text = doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER);
   const ranges = [];
   for (const rule of rules) {
     rule.regex.lastIndex = 0;
@@ -88,7 +91,7 @@ function getExpectedMarkings(rules, doc, from, to) {
       const index = match.index;
       if (index == null)
         continue;
-      const attrs = (_a = rule.getAttrs) == null ? void 0 : _a.call(rule, match);
+      const attrs = maybeRun(rule.attrs, match);
       const mark = markType.create(attrs);
       ranges.push([from + index, from + index + match[0].length, mark]);
     }
@@ -155,9 +158,7 @@ function applyMarkRules(rules, transactions, oldState, newState) {
 
 // src/mark-rule/extension.ts
 function defineMarkRule(options) {
-  const { regex, type, attrs } = options;
-  const getAttrs = attrs && typeof attrs === "object" ? () => attrs : attrs;
-  return markRuleFacet.extension([{ regex, type, getAttrs }]);
+  return markRuleFacet.extension([options]);
 }
 var markRuleFacet = Facet.define({
   converter: () => {

package/dist/chunk-CJ3SOSL6.js

@@ -0,0 +1,100 @@
+// src/input-rule/index.ts
+import {
+  Facet,
+  getMarkType,
+  getNodeType,
+  isMarkAbsent,
+  maybeRun,
+  pluginFacet
+} from "@prosekit/core";
+import {
+  InputRule,
+  inputRules,
+  textblockTypeInputRule,
+  wrappingInputRule
+} from "@prosekit/pm/inputrules";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+function defineInputRule(rule) {
+  return inputRuleFacet.extension([() => rule]);
+}
+function createMarkInputRule({
+  regex,
+  type,
+  attrs = null
+}) {
+  const rule = new InputRule(regex, (state, match, start, end) => {
+    var _a;
+    const { tr, schema } = state;
+    const [fullText, markText] = match;
+    if (!markText) {
+      return null;
+    }
+    const markStart = start + fullText.indexOf(markText);
+    const markEnd = markStart + markText.length;
+    if (!(start <= markStart && markStart < markEnd && markEnd <= end)) {
+      return null;
+    }
+    const markType = getMarkType(schema, type);
+    const mark = markType.create(maybeRun(attrs, match));
+    if (!isMarkAbsent(tr.doc, markStart, markEnd, markType, attrs)) {
+      return null;
+    }
+    const initialStoredMarks = (_a = tr.storedMarks) != null ? _a : [];
+    tr.addMark(markStart, markEnd, mark);
+    if (markEnd < end) {
+      tr.delete(markEnd, end);
+    }
+    if (start < markStart) {
+      tr.delete(start, markStart);
+    }
+    tr.setStoredMarks(initialStoredMarks);
+    return tr;
+  });
+  return rule;
+}
+function defineMarkInputRule(options) {
+  return defineInputRule(createMarkInputRule(options));
+}
+function defineTextBlockInputRule({
+  regex,
+  type,
+  attrs
+}) {
+  return inputRuleFacet.extension([
+    ({ schema }) => {
+      const nodeType = getNodeType(schema, type);
+      return textblockTypeInputRule(regex, nodeType, attrs);
+    }
+  ]);
+}
+function defineWrappingInputRule({
+  regex,
+  type,
+  attrs,
+  join
+}) {
+  return inputRuleFacet.extension([
+    ({ schema }) => {
+      const nodeType = getNodeType(schema, type);
+      return wrappingInputRule(regex, nodeType, attrs, join);
+    }
+  ]);
+}
+var inputRuleFacet = Facet.define({
+  convert: (inputs) => {
+    return (context) => {
+      const rules = inputs.flatMap((callback) => callback(context));
+      return [inputRules({ rules })];
+    };
+  },
+  next: pluginFacet
+});
+
+export {
+  defineInputRule,
+  createMarkInputRule,
+  defineMarkInputRule,
+  defineTextBlockInputRule,
+  defineWrappingInputRule
+};

package/dist/{chunk-ASTUC4KT.js → chunk-HLBUHIMJ.js}

@@ -4,6 +4,7 @@ import {
   OBJECT_REPLACEMENT_CHARACTER,
   getNodeType,
   isTextSelection,
+  maybeRun,
   pluginFacet
 } from "@prosekit/core";
 import { keydownHandler } from "@prosekit/pm/keymap";
@@ -32,7 +33,7 @@ function defineTextBlockEnterRule({
       if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) {
         return null;
       }
-      const nodeAttrs = attrs && typeof attrs === "function" ? attrs(match) : attrs;
+      const nodeAttrs = maybeRun(attrs, match);
       return state.tr.delete(from, to).setBlockType(from, from, nodeType, nodeAttrs);
     },
     stop

package/dist/prosekit-extensions-autocomplete.js

@@ -75,12 +75,14 @@ function createAutocompletePlugin({
           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));

package/dist/prosekit-extensions-blockquote.js

@@ -1,6 +1,6 @@
 import {
   defineWrappingInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/blockquote/index.ts
 import { defineNodeSpec, union } from "@prosekit/core";

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

@@ -1,4 +1,5 @@
 export { defineBoldSpec } from './_tsup-dts-rollup';
 export { defineBoldCommands } from './_tsup-dts-rollup';
 export { defineBoldKeymap } from './_tsup-dts-rollup';
+export { defineBoldInputRule } from './_tsup-dts-rollup';
 export { defineBold } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-bold.js

@@ -1,10 +1,15 @@
+import {
+  defineMarkInputRule
+} from "./chunk-CJ3SOSL6.js";
+
 // src/bold/index.ts
 import {
+  canUseRegexLookbehind,
   defineCommands,
   defineKeymap,
   defineMarkSpec,
-  union,
-  toggleMark
+  toggleMark,
+  union
 } from "@prosekit/core";
 function defineBoldSpec() {
   return defineMarkSpec({
@@ -43,12 +48,24 @@ function defineBoldKeymap() {
     "Mod-b": toggleMark({ type: "bold" })
   });
 }
+function defineBoldInputRule() {
+  return defineMarkInputRule({
+    regex: canUseRegexLookbehind() ? /(?<=\s|^)\*\*([^\s*]|[^\s*][^*]*[^\s*])\*\*$/ : /\*\*([^\s*]|[^\s*][^*]*[^\s*])\*\*$/,
+    type: "bold"
+  });
+}
 function defineBold() {
-  return union([defineBoldSpec(), defineBoldCommands(), defineBoldKeymap()]);
+  return union([
+    defineBoldSpec(),
+    defineBoldCommands(),
+    defineBoldKeymap(),
+    defineBoldInputRule()
+  ]);
 }
 export {
   defineBold,
   defineBoldCommands,
+  defineBoldInputRule,
   defineBoldKeymap,
   defineBoldSpec
 };

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

@@ -1,9 +1,9 @@
 import {
   defineTextBlockEnterRule
-} from "./chunk-ASTUC4KT.js";
+} from "./chunk-HLBUHIMJ.js";
 import {
   defineTextBlockInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/code-block/code-block.ts
 import { union } from "@prosekit/core";

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

@@ -1,4 +1,5 @@
 export { defineCodeSpec } from './_tsup-dts-rollup';
 export { defineCodeCommands } from './_tsup-dts-rollup';
-export { defineItalicKeymap } from './_tsup-dts-rollup';
+export { defineCodeKeymap } from './_tsup-dts-rollup';
+export { defineCodeInputRule } from './_tsup-dts-rollup';
 export { defineCode } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-code.js

@@ -1,5 +1,10 @@
+import {
+  defineMarkInputRule
+} from "./chunk-CJ3SOSL6.js";
+
 // src/code/index.ts
 import {
+  canUseRegexLookbehind,
   defineCommands,
   defineKeymap,
   defineMarkSpec,
@@ -20,17 +25,29 @@ function defineCodeCommands() {
     toggleCode: () => toggleMark({ type: "code" })
   });
 }
-function defineItalicKeymap() {
+function defineCodeKeymap() {
   return defineKeymap({
     "Mod-e": toggleMark({ type: "code" })
   });
 }
+function defineCodeInputRule() {
+  return defineMarkInputRule({
+    regex: canUseRegexLookbehind() ? /(?<=\s|^)`([^\s`]|[^\s`][^`]*[^\s`])`$/ : /`([^\s`]|[^\s`][^`]*[^\s`])`$/,
+    type: "code"
+  });
+}
 function defineCode() {
-  return union([defineCodeSpec(), defineCodeCommands(), defineItalicKeymap()]);
+  return union([
+    defineCodeSpec(),
+    defineCodeCommands(),
+    defineCodeKeymap(),
+    defineCodeInputRule()
+  ]);
 }
 export {
   defineCode,
   defineCodeCommands,
-  defineCodeSpec,
-  defineItalicKeymap
+  defineCodeInputRule,
+  defineCodeKeymap,
+  defineCodeSpec
 };

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

@@ -1,7 +1,7 @@
 import {
   defineEnterRule,
   defineTextBlockEnterRule
-} from "./chunk-ASTUC4KT.js";
+} from "./chunk-HLBUHIMJ.js";
 export {
   defineEnterRule,
   defineTextBlockEnterRule

package/dist/prosekit-extensions-heading.js

@@ -1,6 +1,6 @@
 import {
   defineTextBlockInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/heading/index.ts
 import {

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

@@ -1,3 +1,6 @@
 export { defineInputRule } from './_tsup-dts-rollup';
+export { createMarkInputRule } from './_tsup-dts-rollup';
+export { defineMarkInputRule } from './_tsup-dts-rollup';
 export { defineTextBlockInputRule } from './_tsup-dts-rollup';
 export { defineWrappingInputRule } from './_tsup-dts-rollup';
+export { MarkInputRuleOptions } from './_tsup-dts-rollup';

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

@@ -1,10 +1,14 @@
 import {
+  createMarkInputRule,
   defineInputRule,
+  defineMarkInputRule,
   defineTextBlockInputRule,
   defineWrappingInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 export {
+  createMarkInputRule,
   defineInputRule,
+  defineMarkInputRule,
   defineTextBlockInputRule,
   defineWrappingInputRule
 };

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

@@ -1,4 +1,5 @@
 export { defineItalicSpec } from './_tsup-dts-rollup';
 export { defineItalicCommands } from './_tsup-dts-rollup';
-export { defineItalicKeymap_alias_1 as defineItalicKeymap } from './_tsup-dts-rollup';
+export { defineItalicKeymap } from './_tsup-dts-rollup';
+export { defineItalicInputRule } from './_tsup-dts-rollup';
 export { defineItalic } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-italic.js

@@ -1,10 +1,15 @@
+import {
+  defineMarkInputRule
+} from "./chunk-CJ3SOSL6.js";
+
 // src/italic/index.ts
 import {
+  canUseRegexLookbehind,
   defineCommands,
   defineKeymap,
   defineMarkSpec,
-  union,
-  toggleMark
+  toggleMark,
+  union
 } from "@prosekit/core";
 function defineItalicSpec() {
   return defineMarkSpec({
@@ -33,16 +38,24 @@ function defineItalicKeymap() {
     "Mod-i": toggleMark({ type: "italic" })
   });
 }
+function defineItalicInputRule() {
+  return defineMarkInputRule({
+    regex: canUseRegexLookbehind() ? /(?<=\s|^)\*([^\s*]|[^\s*][^*]*[^\s*])\*$/ : /\*([^\s*]|[^\s*][^*]*[^\s*])\*$/,
+    type: "italic"
+  });
+}
 function defineItalic() {
   return union([
     defineItalicSpec(),
     defineItalicCommands(),
-    defineItalicKeymap()
+    defineItalicKeymap(),
+    defineItalicInputRule()
   ]);
 }
 export {
   defineItalic,
   defineItalicCommands,
+  defineItalicInputRule,
   defineItalicKeymap,
   defineItalicSpec
 };

package/dist/prosekit-extensions-link.js

@@ -1,12 +1,12 @@
 import {
   defineMarkRule
-} from "./chunk-MX6UNVWH.js";
+} from "./chunk-7G7COECS.js";
 import {
   defineEnterRule
-} from "./chunk-ASTUC4KT.js";
+} from "./chunk-HLBUHIMJ.js";
 import {
   defineInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/link/index.ts
 import {

package/dist/prosekit-extensions-list.js

@@ -1,6 +1,6 @@
 import {
   defineInputRule
-} from "./chunk-DYFRBXUX.js";
+} from "./chunk-CJ3SOSL6.js";
 
 // src/list/index.ts
 import {

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

@@ -1,2 +1,2 @@
-export { MarkRuleOptions } from './_tsup-dts-rollup';
 export { defineMarkRule_alias_1 as defineMarkRule } from './_tsup-dts-rollup';
+export { MarkRuleOptions } from './_tsup-dts-rollup';

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

@@ -1,6 +1,6 @@
 import {
   defineMarkRule
-} from "./chunk-MX6UNVWH.js";
+} from "./chunk-7G7COECS.js";
 export {
   defineMarkRule
 };

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

@@ -1,4 +1,5 @@
 export { defineStrikeSpec } from './_tsup-dts-rollup';
 export { defineStrikeCommands } from './_tsup-dts-rollup';
 export { defineStrikeKeymap } from './_tsup-dts-rollup';
+export { defineStrikeInputRule } from './_tsup-dts-rollup';
 export { defineStrike } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-strike.js

@@ -1,10 +1,15 @@
+import {
+  defineMarkInputRule
+} from "./chunk-CJ3SOSL6.js";
+
 // src/strike/index.ts
 import {
   defineCommands,
   defineKeymap,
   defineMarkSpec,
   union,
-  toggleMark
+  toggleMark,
+  canUseRegexLookbehind
 } from "@prosekit/core";
 function defineStrikeSpec() {
   return defineMarkSpec({
@@ -32,16 +37,24 @@ function defineStrikeKeymap() {
     "Mod-shift-x": toggleMark({ type: "strike" })
   });
 }
+function defineStrikeInputRule() {
+  return defineMarkInputRule({
+    regex: canUseRegexLookbehind() ? /(?<=\s|^)~~([^\s~]|[^\s~][^~]*[^\s~])~~$/ : /~~([^\s~]|[^\s~][^~]*[^\s~])~~$/,
+    type: "strike"
+  });
+}
 function defineStrike() {
   return union([
     defineStrikeSpec(),
     defineStrikeCommands(),
-    defineStrikeKeymap()
+    defineStrikeKeymap(),
+    defineStrikeInputRule()
   ]);
 }
 export {
   defineStrike,
   defineStrikeCommands,
+  defineStrikeInputRule,
   defineStrikeKeymap,
   defineStrikeSpec
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/extensions",
   "type": "module",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -152,7 +152,7 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/core": "^0.4.1",
+    "@prosekit/core": "^0.4.2",
     "@prosekit/pm": "^0.1.2",
     "prosemirror-dropcursor": "^1.8.1",
     "prosemirror-flat-list": "^0.5.0",

package/dist/chunk-DYFRBXUX.js

@@ -1,56 +0,0 @@
-// src/input-rule/index.ts
-import {
-  Facet,
-  getNodeType,
-  pluginFacet
-} from "@prosekit/core";
-import {
-  inputRules,
-  textblockTypeInputRule,
-  wrappingInputRule
-} from "@prosekit/pm/inputrules";
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function defineInputRule(rule) {
-  return inputRuleFacet.extension([() => rule]);
-}
-function defineTextBlockInputRule({
-  regex,
-  type,
-  attrs
-}) {
-  return inputRuleFacet.extension([
-    ({ schema }) => {
-      const nodeType = getNodeType(schema, type);
-      return textblockTypeInputRule(regex, nodeType, attrs);
-    }
-  ]);
-}
-function defineWrappingInputRule({
-  regex,
-  type,
-  attrs,
-  join
-}) {
-  return inputRuleFacet.extension([
-    ({ schema }) => {
-      const nodeType = getNodeType(schema, type);
-      return wrappingInputRule(regex, nodeType, attrs, join);
-    }
-  ]);
-}
-var inputRuleFacet = Facet.define({
-  convert: (inputs) => {
-    return (context) => {
-      const rules = inputs.flatMap((callback) => callback(context));
-      return [inputRules({ rules })];
-    };
-  },
-  next: pluginFacet
-});
-
-export {
-  defineInputRule,
-  defineTextBlockInputRule,
-  defineWrappingInputRule
-};