@prosekit/extensions 0.7.1 → 0.7.3

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

@@ -1,5 +1,5 @@
+import { AddMarkOptions } from '@prosekit/core';
 import { Attrs } from '@prosekit/pm/model';
-import { Attrs as Attrs_2 } from 'prosemirror-model';
 import { BundledLanguage } from 'shiki';
 import { BundledLanguageInfo } from 'shiki';
 import { bundledLanguagesInfo } from 'shiki';
@@ -18,28 +18,33 @@ import { getSingletonHighlighter } from 'shiki/bundle/full';
 import type { Highlighter } from 'shiki';
 import { IndentListOptions } from 'prosemirror-flat-list';
 import { InputRule } from '@prosekit/pm/inputrules';
+import { InsertNodeOptions } from '@prosekit/core';
 import { ListAttributes } from 'prosemirror-flat-list';
 import { ListDOMSerializer } from 'prosemirror-flat-list';
 import { MarkBuilder } from '@prosekit/core';
 import { MarkType } from '@prosekit/pm/model';
-import { MarkType as MarkType_2 } from 'prosemirror-model';
-import { Node as Node_2 } from 'prosemirror-model';
 import { NodeBuilder } from '@prosekit/core';
 import { NodeJSON } from '@prosekit/core';
-import { NodeRange } from 'prosemirror-model';
 import { NodeType } from '@prosekit/pm/model';
-import { NodeType as NodeType_2 } from 'prosemirror-model';
 import { Options } from 'tsup';
 import { Parser } from 'prosemirror-highlight';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { PluginKey } from '@prosekit/pm/state';
 import { ProseMirrorNode } from '@prosekit/pm/model';
+import { RemoveMarkOptions } from '@prosekit/core';
+import { RemoveNodeOptions } from '@prosekit/core';
+import { SetBlockTypeOptions } from '@prosekit/core';
+import { SetNodeAttrsOptions } from '@prosekit/core';
 import type { SpecialLanguage } from 'shiki';
 import { StepJSON } from '@prosekit/core';
 import { TestEditor } from '@prosekit/core/test';
 import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
 import { Transaction } from '@prosekit/pm/state';
+import { UnsetBlockTypeOptions } from '@prosekit/core';
+import { UnsetMarkOptions } from '@prosekit/core';
 import { UnwrapListOptions } from 'prosemirror-flat-list';
+import { WrapInListGetAttrs } from 'prosemirror-flat-list';
+import { WrapOptions } from '@prosekit/core';
 
 export declare function applyMarkRules(rules: MarkRuleOptions[], transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;
 
@@ -174,6 +179,8 @@ export declare function createLazyParser(highlighterOptions: HighlighterOptions)
  */
 export declare function createMarkInputRule({ regex, type, attrs, }: MarkInputRuleOptions): InputRule;
 
+export { DedentListOptions }
+
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
 export { default_alias_1 }
@@ -412,7 +419,7 @@ toggleHeading: [attrs?: HeadingAttrs | undefined];
 };
 }>;
 
-export declare function defineHeadingCommands(): Extension<    {
+declare function defineHeadingCommands(): Extension<    {
 Commands: {
 setHeading: [attrs?: HeadingAttrs | undefined];
 insertHeading: [attrs?: HeadingAttrs | undefined];
@@ -421,20 +428,28 @@ toggleHeading: [attrs?: HeadingAttrs | undefined];
 Nodes: never;
 Marks: never;
 }>;
+export { defineHeadingCommands }
+export { defineHeadingCommands as defineHeadingCommands_alias_1 }
 
 /**
  * Converts the text block to a heading when `#` is typed at the start of a new
  * line followed by a space.
  */
-export declare function defineHeadingInputRule(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineHeadingInputRule(): Extension<ExtensionTyping<any, any, any>>;
+export { defineHeadingInputRule }
+export { defineHeadingInputRule as defineHeadingInputRule_alias_1 }
 
-export declare function defineHeadingKeymap(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineHeadingKeymap(): Extension<ExtensionTyping<any, any, any>>;
+export { defineHeadingKeymap }
+export { defineHeadingKeymap as defineHeadingKeymap_alias_1 }
 
-export declare function defineHeadingSpec(): Extension<    {
+declare function defineHeadingSpec(): Extension<    {
 Nodes: "heading";
 Marks: never;
 Commands: never;
 }>;
+export { defineHeadingSpec }
+export { defineHeadingSpec as defineHeadingSpec_alias_1 }
 
 /**
  * @public
@@ -559,26 +574,31 @@ export declare function defineList(): Extension<{
         toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
         toggleList: [attrs: ListAttributes];
         unwrapList: [options?: UnwrapListOptions | undefined];
-        wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
+        wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
         insertList: [attrs?: ListAttributes | undefined];
     };
 }>;
 
-export declare function defineListCommands(): Extension<{
-    Commands: {
-        dedentList: [options?: DedentListOptions | undefined];
-        indentList: [options?: IndentListOptions | undefined];
-        moveList: [direction: "up" | "down"];
-        splitList: [];
-        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-        toggleList: [attrs: ListAttributes];
-        unwrapList: [options?: UnwrapListOptions | undefined];
-        wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
-        insertList: [attrs?: ListAttributes | undefined];
-    };
-    Nodes: never;
-    Marks: never;
+/**
+ * Defines list commands
+ */
+declare function defineListCommands(): Extension<    {
+Commands: {
+dedentList: [options?: DedentListOptions | undefined];
+indentList: [options?: IndentListOptions | undefined];
+moveList: [direction: "up" | "down"];
+splitList: [];
+toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+toggleList: [attrs: ListAttributes];
+unwrapList: [options?: UnwrapListOptions | undefined];
+wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
+insertList: [attrs?: ListAttributes | undefined];
+};
+Nodes: never;
+Marks: never;
 }>;
+export { defineListCommands }
+export { defineListCommands as defineListCommands_alias_1 }
 
 export declare function defineListInputRules(): Extension;
 
@@ -587,7 +607,9 @@ export declare function defineListInputRules(): Extension;
  *
  * @public
  */
-export declare function defineListKeymap(): Extension<ExtensionTyping<any, any, any>>;
+declare function defineListKeymap(): Extension<ExtensionTyping<any, any, any>>;
+export { defineListKeymap }
+export { defineListKeymap as defineListKeymap_alias_1 }
 
 export declare function defineListPlugins(): Extension<ExtensionTyping<any, any, any>>;
 
@@ -803,58 +825,25 @@ export declare function defineTestExtension(): Extension<{
             from?: number;
             to?: number;
         }];
-        insertNode: [options: {
-            node: Node_2;
-            pos?: number;
-            type?: undefined;
-            attrs?: undefined;
-        } | {
-            node?: undefined;
-            pos?: number;
-            type: string;
-            attrs?: Attrs_2;
-        }];
-        removeNode: [options: {
-            type: string | NodeType_2;
-            pos?: number;
-        }];
-        wrap: [{
-            nodeType: NodeType_2;
-            attrs?: Attrs_2 | null;
-        }];
-        setBlockType: [options: {
-            type: NodeType_2 | string;
-            attrs?: Attrs_2 | null;
-            from?: number;
-            to?: number;
-        }];
-        setNodeAttrs: [options: {
-            type: string | NodeType_2 | string[] | NodeType_2[];
-            attrs: Attrs_2;
-            pos?: number;
-        }];
+        insertNode: [options: InsertNodeOptions];
+        removeNode: [options: RemoveNodeOptions];
+        wrap: [WrapOptions];
+        setBlockType: [options: SetBlockTypeOptions];
+        setNodeAttrs: [options: SetNodeAttrsOptions];
         selectAll: [];
-        addMark: [options: {
-            type: string | MarkType_2;
-            attrs?: Attrs_2 | null;
-            from?: number;
-            to?: number;
-        }];
-        removeMark: [options: {
-            type: string | MarkType_2;
-            attrs?: Attrs_2 | null;
-            from?: number;
-            to?: number;
-        }];
-        toggleItalic: [];
-        undo: [];
-        redo: [];
+        addMark: [options: AddMarkOptions];
+        removeMark: [options: RemoveMarkOptions];
+        unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
+        unsetMark: [options?: UnsetMarkOptions | undefined];
+        readonly undo: [];
+        readonly redo: [];
         toggleBold: [];
         toggleCode: [];
         setHeading: [attrs?: HeadingAttrs | undefined];
         insertHeading: [attrs?: HeadingAttrs | undefined];
         toggleHeading: [attrs?: HeadingAttrs | undefined];
         insertImage: [attrs?: ImageAttrs | undefined];
+        toggleItalic: [];
         addLink: [attrs: LinkAttrs];
         removeLink: [];
         toggleLink: [attrs: LinkAttrs];
@@ -866,7 +855,7 @@ export declare function defineTestExtension(): Extension<{
         toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
         toggleList: [attrs: ListAttributes];
         unwrapList: [options?: UnwrapListOptions | undefined];
-        wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
+        wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
         insertList: [attrs?: ListAttributes | undefined];
         toggleStrike: [];
         insertTable: [{
@@ -1095,9 +1084,11 @@ export { getSingletonHighlighter }
 
 export declare function getTrMeta(tr: Transaction): PredictionPluginState;
 
-export declare interface HeadingAttrs {
+declare interface HeadingAttrs {
     level: number;
 }
+export { HeadingAttrs }
+export { HeadingAttrs as HeadingAttrs_alias_1 }
 
 export declare type HighlighterOptions = {
     themes: BundledTheme[];
@@ -1126,6 +1117,8 @@ export declare interface ImageAttrs {
     src?: string | null;
 }
 
+export { IndentListOptions }
+
 /**
  * Insert a table node with the given number of rows and columns, and optionally
  * a header row.
@@ -1151,6 +1144,8 @@ export declare interface LinkAttrs {
     href: string;
 }
 
+export { ListAttributes }
+
 export { ListDOMSerializer }
 
 /**
@@ -1248,6 +1243,18 @@ export declare interface PredictionPluginState {
 
 export declare function prepareHighlighter(options: HighlighterOptions): HighlighterResult;
 
+/**
+ * @example
+ *
+ * ```ts
+ * await pressKey('mod-1')
+ * await pressKey('Backspace')
+ * ```
+ *
+ * @internal
+ */
+export declare function pressKey(input: string): Promise<void>;
+
 /**
  * Options for {@link defineSearchQuery}
  *
@@ -1303,7 +1310,7 @@ export declare function setTrMeta(tr: Transaction, meta: PredictionPluginState):
 /**
  * @internal
  */
-export declare function setupDefaultTest(): {
+export declare function setupTest(): {
     editor: TestEditor<Extension<{
         Nodes: "blockquote" | "table" | "text" | "doc" | "paragraph" | "heading" | "image" | "list" | "tableRow" | "tableCell" | "tableHeaderCell";
         Marks: "code" | "link" | "bold" | "strike" | "italic" | "underline";
@@ -1313,58 +1320,25 @@ export declare function setupDefaultTest(): {
                 from?: number;
                 to?: number;
             }];
-            insertNode: [options: {
-                node: Node_2;
-                pos?: number;
-                type?: undefined;
-                attrs?: undefined;
-            } | {
-                node?: undefined;
-                pos?: number;
-                type: string;
-                attrs?: Attrs_2;
-            }];
-            removeNode: [options: {
-                type: string | NodeType_2;
-                pos?: number;
-            }];
-            wrap: [{
-                nodeType: NodeType_2;
-                attrs?: Attrs_2 | null;
-            }];
-            setBlockType: [options: {
-                type: NodeType_2 | string;
-                attrs?: Attrs_2 | null;
-                from?: number;
-                to?: number;
-            }];
-            setNodeAttrs: [options: {
-                type: string | NodeType_2 | string[] | NodeType_2[];
-                attrs: Attrs_2;
-                pos?: number;
-            }];
+            insertNode: [options: InsertNodeOptions];
+            removeNode: [options: RemoveNodeOptions];
+            wrap: [WrapOptions];
+            setBlockType: [options: SetBlockTypeOptions];
+            setNodeAttrs: [options: SetNodeAttrsOptions];
             selectAll: [];
-            addMark: [options: {
-                type: string | MarkType_2;
-                attrs?: Attrs_2 | null;
-                from?: number;
-                to?: number;
-            }];
-            removeMark: [options: {
-                type: string | MarkType_2;
-                attrs?: Attrs_2 | null;
-                from?: number;
-                to?: number;
-            }];
-            toggleItalic: [];
-            undo: [];
-            redo: [];
+            addMark: [options: AddMarkOptions];
+            removeMark: [options: RemoveMarkOptions];
+            unsetBlockType: [options?: UnsetBlockTypeOptions | undefined];
+            unsetMark: [options?: UnsetMarkOptions | undefined];
+            readonly undo: [];
+            readonly redo: [];
             toggleBold: [];
             toggleCode: [];
             setHeading: [attrs?: HeadingAttrs | undefined];
             insertHeading: [attrs?: HeadingAttrs | undefined];
             toggleHeading: [attrs?: HeadingAttrs | undefined];
             insertImage: [attrs?: ImageAttrs | undefined];
+            toggleItalic: [];
             addLink: [attrs: LinkAttrs];
             removeLink: [];
             toggleLink: [attrs: LinkAttrs];
@@ -1376,7 +1350,7 @@ export declare function setupDefaultTest(): {
             toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
             toggleList: [attrs: ListAttributes];
             unwrapList: [options?: UnwrapListOptions | undefined];
-            wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
+            wrapInList: [getAttrs: WrapInListGetAttrs<ListAttributes>];
             insertList: [attrs?: ListAttributes | undefined];
             toggleStrike: [];
             insertTable: [{
@@ -1395,7 +1369,7 @@ export declare function setupDefaultTest(): {
 /**
  * @internal
  */
-export declare function setupTest<E extends Extension>(extension: E): {
+export declare function setupTestFromExtension<E extends Extension>(extension: E): {
     editor: TestEditor<E>;
     n: Record<ExtractNodes<E>, NodeBuilder>;
     m: Record<ExtractMarks<E>, MarkBuilder>;
@@ -1445,4 +1419,10 @@ export declare type TextBlockEnterRuleOptions = {
     stop?: boolean;
 };
 
+export { ToggleCollapsedOptions }
+
+export { UnwrapListOptions }
+
+export { WrapInListGetAttrs }
+
 export { }

package/dist/chunk-GPSAJOJA.js

@@ -0,0 +1,188 @@
+// src/mark-rule/extension.ts
+import {
+  defineFacet,
+  defineFacetPayload,
+  pluginFacet
+} from "@prosekit/core";
+import {
+  PluginKey,
+  ProseMirrorPlugin
+} from "@prosekit/pm/state";
+
+// src/mark-rule/apply.ts
+import {
+  OBJECT_REPLACEMENT_CHARACTER,
+  getMarkType,
+  maybeRun
+} from "@prosekit/core";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+
+// src/mark-rule/range.ts
+import "@prosekit/pm/state";
+function getSpanTextRanges($from, $to) {
+  const nodeRange = $from.blockRange($to);
+  if (!nodeRange) {
+    return [];
+  }
+  const stack = [];
+  let start = nodeRange.start;
+  for (let i = nodeRange.startIndex; i < nodeRange.endIndex; i++) {
+    const child = nodeRange.parent.child(i);
+    stack.push([start, child]);
+    start += child.nodeSize;
+  }
+  const ranges = [];
+  while (stack.length > 0) {
+    const [start2, node] = stack.pop();
+    if (node.type.spec.code) {
+      continue;
+    }
+    if (node.type.isTextblock) {
+      ranges.push([start2 + 1, start2 + 1 + node.content.size]);
+      continue;
+    }
+    node.forEach((child, offset) => {
+      stack.push([start2 + offset + 1, child]);
+    });
+  }
+  return ranges;
+}
+function getInlineTextRange($from, $to) {
+  return [$from.start(), $to.end()];
+}
+function getTextRanges(doc, from, to) {
+  const $from = doc.resolve(from);
+  const $to = doc.resolve(to);
+  if ($from.sameParent($to) && $from.parent.isTextblock) {
+    return [getInlineTextRange($from, $to)];
+  } else {
+    const nodeRange = $from.blockRange($to);
+    if (!nodeRange) {
+      return [];
+    }
+    return getSpanTextRanges($from, $to);
+  }
+}
+function getMapRange(transactions, oldState, newState) {
+  let lo = oldState.selection.from;
+  let hi = oldState.selection.to;
+  for (const tr of transactions) {
+    for (const map of tr.mapping.maps) {
+      lo = map.map(lo);
+      hi = map.map(hi);
+      map.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+        lo = Math.min(lo, hi, newStart);
+        hi = Math.max(lo, hi, newEnd);
+      });
+    }
+  }
+  lo = Math.min(lo, hi, newState.selection.from);
+  hi = Math.min(lo, hi, newState.selection.to);
+  return [lo, hi];
+}
+function getCheckRanges(transactions, oldState, newState) {
+  const [from, to] = getMapRange(transactions, oldState, newState);
+  return getTextRanges(newState.doc, from, to);
+}
+
+// src/mark-rule/apply.ts
+function getExpectedMarkings(rules, doc, from, to) {
+  const text = doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER);
+  const ranges = [];
+  for (const rule of rules) {
+    rule.regex.lastIndex = 0;
+    const matches = text.matchAll(rule.regex);
+    const markType = getMarkType(doc.type.schema, rule.type);
+    for (const match of matches) {
+      const index = match.index;
+      if (index == null) continue;
+      const attrs = maybeRun(rule.attrs, match);
+      const mark = markType.create(attrs);
+      ranges.push([from + index, from + index + match[0].length, mark]);
+    }
+  }
+  ranges.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
+  const result = [];
+  let freeIndex = 0;
+  for (const range of ranges) {
+    if (range[0] >= freeIndex) {
+      result.push(range);
+      freeIndex = range[1];
+    }
+  }
+  return result;
+}
+function getReceivedMarkings(rules, doc, from, to) {
+  const result = [];
+  const schema = doc.type.schema;
+  const markTypes = rules.map((rule) => getMarkType(schema, rule.type));
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isInline) {
+      return;
+    }
+    for (const markType of markTypes) {
+      const mark = node.marks.find((mark2) => mark2.type === markType);
+      if (mark) {
+        result.push([pos, pos + node.nodeSize, mark]);
+      }
+    }
+  });
+  return result;
+}
+function markRangeEquals(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2].eq(b[2]);
+}
+function markRangeDiffs(a, b) {
+  return a.filter((x) => !b.some((y) => markRangeEquals(x, y)));
+}
+function applyMarkRules(rules, transactions, oldState, newState) {
+  if (transactions.length === 0 || transactions.every((tr2) => !tr2.docChanged)) {
+    return null;
+  }
+  const ranges = getCheckRanges(transactions, oldState, newState);
+  const toRemove = [];
+  const toCreate = [];
+  for (const [from, to] of ranges) {
+    const expected = getExpectedMarkings(rules, newState.doc, from, to);
+    const received = getReceivedMarkings(rules, newState.doc, from, to);
+    toRemove.push(...markRangeDiffs(received, expected));
+    toCreate.push(...markRangeDiffs(expected, received));
+  }
+  if (toCreate.length === 0 && toRemove.length === 0) {
+    return null;
+  }
+  const tr = newState.tr;
+  for (const [from, to, mark] of toRemove) {
+    tr.removeMark(from, to, mark);
+  }
+  for (const [from, to, mark] of toCreate) {
+    tr.addMark(from, to, mark);
+  }
+  return tr;
+}
+
+// src/mark-rule/extension.ts
+function defineMarkRule(options) {
+  return defineFacetPayload(markRuleFacet, [options]);
+}
+var markRuleFacet = defineFacet({
+  reduce: () => {
+    let rules = [];
+    const plugin = new ProseMirrorPlugin({
+      key: new PluginKey("prosekit-mark-rule"),
+      appendTransaction: (transactions, oldState, newState) => {
+        return applyMarkRules(rules, transactions, oldState, newState);
+      }
+    });
+    return function reducer(input) {
+      rules = input;
+      return plugin;
+    };
+  },
+  parent: pluginFacet
+});
+
+export {
+  defineMarkRule
+};

package/dist/{chunk-PYT3MOTF.js → chunk-LVMTQOWG.js}

@@ -24,20 +24,35 @@ function createMarkInputRule({
   type,
   attrs = null
 }) {
-  return new InputRule(regex, (state, match, start, end) => {
+  const rule = new InputRule(regex, (state, match, start, end) => {
     var _a;
-    let { tr, schema } = state, [fullText, markText] = match;
-    if (!markText)
+    const { tr, schema } = state;
+    const [fullText, markText] = match;
+    if (!markText) {
       return null;
-    let markStart = start + fullText.indexOf(markText), markEnd = markStart + markText.length;
-    if (!(start <= markStart && markStart < markEnd && markEnd <= end))
+    }
+    const markStart = start + fullText.indexOf(markText);
+    const markEnd = markStart + markText.length;
+    if (!(start <= markStart && markStart < markEnd && markEnd <= end)) {
       return null;
-    let markType = getMarkType(schema, type), mark = markType.create(maybeRun(attrs, match));
-    if (!isMarkAbsent(tr.doc, markStart, markEnd, markType, attrs))
+    }
+    const markType = getMarkType(schema, type);
+    const mark = markType.create(maybeRun(attrs, match));
+    if (!isMarkAbsent(tr.doc, markStart, markEnd, markType, attrs)) {
       return null;
-    let initialStoredMarks = (_a = tr.storedMarks) != null ? _a : [];
-    return tr.addMark(markStart, markEnd, mark), markEnd < end && tr.delete(markEnd, end), start < markStart && tr.delete(start, markStart), tr.setStoredMarks(initialStoredMarks), tr;
+    }
+    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));
@@ -49,7 +64,7 @@ function defineTextBlockInputRule({
 }) {
   return defineFacetPayload(inputRuleFacet, [
     ({ schema }) => {
-      let nodeType = getNodeType(schema, type);
+      const nodeType = getNodeType(schema, type);
       return textblockTypeInputRule(regex, nodeType, attrs);
     }
   ]);
@@ -62,15 +77,17 @@ function defineWrappingInputRule({
 }) {
   return defineFacetPayload(inputRuleFacet, [
     ({ schema }) => {
-      let nodeType = getNodeType(schema, type);
+      const nodeType = getNodeType(schema, type);
       return wrappingInputRule(regex, nodeType, attrs, join);
     }
   ]);
 }
 var inputRuleFacet = defineFacet({
-  reducer: (inputs) => (context) => {
-    let rules = inputs.flatMap((callback) => callback(context));
-    return [inputRules({ rules })];
+  reducer: (inputs) => {
+    return (context) => {
+      const rules = inputs.flatMap((callback) => callback(context));
+      return [inputRules({ rules })];
+    };
   },
   parent: pluginFacet
 });