@portabletext/plugin-input-rule 6.0.12 → 6.0.14

package/dist/index.d.ts

@@ -1,253 +1,117 @@
-import {Behavior} from '@portabletext/editor/behaviors'
-import type {BehaviorActionSet} from '@portabletext/editor/behaviors'
-import {BehaviorEvent} from '@portabletext/editor/behaviors'
-import type {BehaviorGuard} from '@portabletext/editor/behaviors'
-import {BlockOffset} from '@portabletext/editor'
-import type {BlockPath} from '@portabletext/editor'
-import {EditorSelection} from '@portabletext/editor'
-import type {PortableTextBlock} from '@portabletext/editor'
-
+import { BlockOffset, BlockPath, EditorSelection, PortableTextBlock } from "@portabletext/editor";
+import { BehaviorActionSet, BehaviorGuard } from "@portabletext/editor/behaviors";
 /**
  * @public
  */
-export declare function defineInputRule<TGuardResponse = true>(
-  config: InputRule<TGuardResponse>,
-): InputRule<TGuardResponse>
-
-/**
- * @public
- */
-export declare function defineInputRuleBehavior(config: {
-  rules: Array<InputRule<any>>
-  onApply?: ({
-    endOffsets,
-    endSelection,
-  }: {
-    endOffsets:
-      | {
-          start: BlockOffset
-          end: BlockOffset
-        }
-      | undefined
-    endSelection: EditorSelection
-  }) => void
-}): Behavior<
-  | '*'
-  | 'insert.text'
-  | 'annotation.add'
-  | 'annotation.remove'
-  | 'block.set'
-  | 'block.unset'
-  | 'child.set'
-  | 'child.unset'
-  | 'decorator.add'
-  | 'decorator.remove'
-  | 'delete'
-  | 'history.redo'
-  | 'history.undo'
-  | 'insert'
-  | 'insert.block'
-  | 'insert.child'
-  | 'move.backward'
-  | 'move.forward'
-  | 'remove.text'
-  | 'select'
-  | 'set'
-  | 'unset'
-  | 'annotation.set'
-  | 'annotation.toggle'
-  | 'decorator.toggle'
-  | 'delete.backward'
-  | 'delete.block'
-  | 'delete.child'
-  | 'delete.forward'
-  | 'delete.text'
-  | 'deserialize'
-  | 'deserialize.data'
-  | 'deserialization.success'
-  | 'deserialization.failure'
-  | 'insert.blocks'
-  | 'insert.break'
-  | 'insert.inline object'
-  | 'insert.soft break'
-  | 'insert.span'
-  | 'list item.add'
-  | 'list item.remove'
-  | 'list item.toggle'
-  | 'move.block'
-  | 'move.block down'
-  | 'move.block up'
-  | 'select.block'
-  | 'select.previous block'
-  | 'select.next block'
-  | 'serialize'
-  | 'serialize.data'
-  | 'serialization.success'
-  | 'serialization.failure'
-  | 'split'
-  | 'style.add'
-  | 'style.remove'
-  | 'style.toggle'
-  | 'clipboard.copy'
-  | 'clipboard.cut'
-  | 'clipboard.paste'
-  | 'drag.dragstart'
-  | 'drag.drag'
-  | 'drag.dragend'
-  | 'drag.dragenter'
-  | 'drag.dragover'
-  | 'drag.dragleave'
-  | 'drag.drop'
-  | 'input.*'
-  | 'keyboard.keydown'
-  | 'keyboard.keyup'
-  | 'mouse.click'
-  | 'delete.*'
-  | 'insert.*'
-  | 'select.*'
-  | 'set.*'
-  | 'unset.*'
-  | 'deserialize.*'
-  | 'serialize.*'
-  | 'split.*'
-  | 'annotation.*'
-  | 'remove.*'
-  | 'block.*'
-  | 'child.*'
-  | 'decorator.*'
-  | 'history.*'
-  | 'move.*'
-  | 'deserialization.*'
-  | 'list item.*'
-  | 'serialization.*'
-  | 'style.*'
-  | 'clipboard.*'
-  | 'drag.*'
-  | 'keyboard.*'
-  | 'mouse.*'
-  | `custom.${string}`,
-  true,
-  BehaviorEvent
->
-
-/**
- * Define an `InputRule` specifically designed to transform matched text into
- * some other text.
- *
- * @example
- * ```tsx
- * const transformRule = defineTextTransformRule({
- *   on: /--/,
- *   transform: () => '—',
- * })
- * ```
- *
- * @public
- */
-export declare function defineTextTransformRule<TGuardResponse = true>(
-  config: TextTransformRule<TGuardResponse>,
-): InputRule<TGuardResponse>
-
+type InputRuleMatchLocation = {
+  /**
+   * The matched text
+   */
+  text: string;
+  /**
+   * Estimated selection of where in the original text the match is located.
+   * The selection is estimated since the match is found in the text after
+   * insertion.
+   */
+  selection: NonNullable<EditorSelection>;
+  /**
+   * Block offsets of the match in the text after the insertion
+   */
+  targetOffsets: {
+    anchor: BlockOffset;
+    focus: BlockOffset;
+    backward: boolean;
+  };
+};
 /**
+ * Match found in the text after the insertion
  * @public
  */
-export declare type InputRule<TGuardResponse = true> = {
-  on: RegExp
+type InputRuleMatch = InputRuleMatchLocation & {
   /**
-   * Named capture groups inside which an inline object may sit without
-   * dropping the match.
-   *
-   * Inline objects contribute nothing to the text the RegExp matches
-   * against, so a match can span one invisibly. By default any such match
-   * is dropped: rules commonly delete the matched range, and deleting
-   * across an inline object destroys it. Listing a group allows inline
-   * objects within that group's matched span (inclusive of its edges,
-   * so an object adjacent to the span does not drop the match); everything
-   * else in the match, unlisted groups and the text between groups, stays
-   * protected. To allow inline objects anywhere in the match, capture the
-   * whole pattern in a named group and list it.
+   * Locations of the match's named capture groups, keyed by group name.
+   * Only groups that participated in the match are present, and a capture
+   * group must be named (`(?<name>...)`) for its location to be exposed;
+   * unnamed groups remain usable for regex mechanics (alternation) but get
+   * no location.
    */
-  inlineObjects?: {
-    allow: Array<string>
-  }
-  guard?: InputRuleGuard<TGuardResponse>
-  actions: Array<BehaviorActionSet<InputRuleEvent, TGuardResponse>>
-}
-
+  groups: Record<string, InputRuleMatchLocation | undefined>;
+};
 /**
  * @public
  */
-export declare type InputRuleEvent = {
-  type: 'custom.input rule'
+type InputRuleEvent = {
+  type: 'custom.input rule';
   /**
    * Matches found by the input rule
    */
-  matches: Array<InputRuleMatch>
+  matches: Array<InputRuleMatch>;
   /**
    * The focus block's text from its start to the caret, as it was before
    * the insertion
    */
-  textBefore: string
+  textBefore: string;
   /**
    * The text carried by the triggering `insert.text` event
    */
-  textInserted: string
+  textInserted: string;
   /**
    * The block where the insertion takes place
    */
   focusBlock: {
-    path: BlockPath
-    node: PortableTextBlock
-  }
-}
-
+    path: BlockPath;
+    node: PortableTextBlock;
+  };
+};
 /**
  * @public
  */
-export declare type InputRuleGuard<TGuardResponse = true> = BehaviorGuard<
-  InputRuleEvent,
-  TGuardResponse
->
-
+type InputRuleGuard<TGuardResponse = true> = BehaviorGuard<InputRuleEvent, TGuardResponse>;
 /**
- * Match found in the text after the insertion
  * @public
  */
-export declare type InputRuleMatch = InputRuleMatchLocation & {
+type InputRule<TGuardResponse = true> = {
+  on: RegExp;
   /**
-   * Locations of the match's named capture groups, keyed by group name.
-   * Only groups that participated in the match are present, and a capture
-   * group must be named (`(?<name>...)`) for its location to be exposed;
-   * unnamed groups remain usable for regex mechanics (alternation) but get
-   * no location.
+   * Named capture groups inside which an inline object may sit without
+   * dropping the match.
+   *
+   * Inline objects contribute nothing to the text the RegExp matches
+   * against, so a match can span one invisibly. By default any such match
+   * is dropped: rules commonly delete the matched range, and deleting
+   * across an inline object destroys it. Listing a group allows inline
+   * objects within that group's matched span (inclusive of its edges,
+   * so an object adjacent to the span does not drop the match); everything
+   * else in the match, unlisted groups and the text between groups, stays
+   * protected. To allow inline objects anywhere in the match, capture the
+   * whole pattern in a named group and list it.
    */
-  groups: Record<string, InputRuleMatchLocation | undefined>
-}
-
+  inlineObjects?: {
+    allow: Array<string>;
+  };
+  guard?: InputRuleGuard<TGuardResponse>;
+  actions: Array<BehaviorActionSet<InputRuleEvent, TGuardResponse>>;
+};
 /**
  * @public
  */
-export declare type InputRuleMatchLocation = {
-  /**
-   * The matched text
-   */
-  text: string
-  /**
-   * Estimated selection of where in the original text the match is located.
-   * The selection is estimated since the match is found in the text after
-   * insertion.
-   */
-  selection: NonNullable<EditorSelection>
-  /**
-   * Block offsets of the match in the text after the insertion
-   */
-  targetOffsets: {
-    anchor: BlockOffset
-    focus: BlockOffset
-    backward: boolean
-  }
-}
-
+declare function defineInputRule<TGuardResponse = true>(config: InputRule<TGuardResponse>): InputRule<TGuardResponse>;
+/**
+ * @public
+ */
+declare function defineInputRuleBehavior(config: {
+  rules: Array<InputRule<any>>;
+  onApply?: ({ endOffsets, endSelection }: {
+    endOffsets: {
+      start: BlockOffset;
+      end: BlockOffset;
+    } | undefined;
+    endSelection: EditorSelection;
+  }) => void;
+}): import("@portabletext/editor/behaviors").Behavior<"*" | "insert.text" | "annotation.add" | "annotation.remove" | "block.set" | "block.unset" | "child.set" | "child.unset" | "decorator.add" | "decorator.remove" | "delete" | "history.redo" | "history.undo" | "insert" | "insert.block" | "insert.child" | "move.backward" | "move.forward" | "remove.text" | "select" | "set" | "unset" | "annotation.set" | "annotation.toggle" | "decorator.toggle" | "delete.backward" | "delete.block" | "delete.child" | "delete.forward" | "delete.text" | "deserialize" | "deserialize.data" | "deserialization.success" | "deserialization.failure" | "insert.blocks" | "insert.break" | "insert.inline object" | "insert.soft break" | "insert.span" | "list item.add" | "list item.remove" | "list item.toggle" | "move.block" | "move.block down" | "move.block up" | "select.block" | "select.previous block" | "select.next block" | "serialize" | "serialize.data" | "serialization.success" | "serialization.failure" | "split" | "style.add" | "style.remove" | "style.toggle" | "clipboard.copy" | "clipboard.cut" | "clipboard.paste" | "drag.dragstart" | "drag.drag" | "drag.dragend" | "drag.dragenter" | "drag.dragover" | "drag.dragleave" | "drag.drop" | "input.*" | "keyboard.keydown" | "keyboard.keyup" | "mouse.click" | "delete.*" | "insert.*" | "select.*" | "set.*" | "unset.*" | "deserialize.*" | "serialize.*" | "split.*" | "annotation.*" | "remove.*" | "block.*" | "child.*" | "decorator.*" | "history.*" | "move.*" | "deserialization.*" | "list item.*" | "serialization.*" | "style.*" | "clipboard.*" | "drag.*" | "keyboard.*" | "mouse.*" | `custom.${string}`, true, import("@portabletext/editor/behaviors").BehaviorEvent>;
+type InputRulePluginProps = {
+  rules: Array<InputRule<any>>;
+};
 /**
  * Turn an array of `InputRule`s into a Behavior that can be used to apply the
  * rules to the editor.
@@ -262,30 +126,19 @@ export declare type InputRuleMatchLocation = {
  *
  * @public
  */
-export declare function InputRulePlugin(props: InputRulePluginProps): null
-
-declare type InputRulePluginProps = {
-  rules: Array<InputRule<any>>
-}
-
+declare function InputRulePlugin(props: InputRulePluginProps): null;
 /**
  * @public
  */
-export declare type TextTransform<TGuardResponse = true> = (
-  {
-    location,
-  }: {
-    location: InputRuleMatchLocation
-  },
-  guardResponse: TGuardResponse,
-) => string
-
+type TextTransform<TGuardResponse = true> = ({ location }: {
+  location: InputRuleMatchLocation;
+}, guardResponse: TGuardResponse) => string;
 /**
  * @public
  */
-export declare type TextTransformRule<TGuardResponse = true> = {
-  on: RegExp
-  guard?: InputRuleGuard<TGuardResponse>
+type TextTransformRule<TGuardResponse = true> = {
+  on: RegExp;
+  guard?: InputRuleGuard<TGuardResponse>;
   /**
    * What to replace, and with what.
    *
@@ -303,9 +156,22 @@ export declare type TextTransformRule<TGuardResponse = true> = {
    * `defineTextTransformRule` throws otherwise. A match in which none of
    * the keys participated has nothing to replace and is skipped.
    */
-  transform:
-    | TextTransform<TGuardResponse>
-    | Record<string, TextTransform<TGuardResponse>>
-}
-
-export {}
+  transform: TextTransform<TGuardResponse> | Record<string, TextTransform<TGuardResponse>>;
+};
+/**
+ * Define an `InputRule` specifically designed to transform matched text into
+ * some other text.
+ *
+ * @example
+ * ```tsx
+ * const transformRule = defineTextTransformRule({
+ *   on: /--/,
+ *   transform: () => '—',
+ * })
+ * ```
+ *
+ * @public
+ */
+declare function defineTextTransformRule<TGuardResponse = true>(config: TextTransformRule<TGuardResponse>): InputRule<TGuardResponse>;
+export { InputRule, InputRuleEvent, InputRuleGuard, InputRuleMatch, type InputRuleMatchLocation, InputRulePlugin, TextTransform, TextTransformRule, defineInputRule, defineInputRuleBehavior, defineTextTransformRule };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/input-rule-match-location.ts","../src/input-rule.ts","../src/plugin.input-rule.tsx","../src/text-transform-rule.ts"],"mappings":";;;;;KAkBY;;;;EAIV;;;;;;EAMA,WAAW,YAAY;;;;EAIvB;IACE,QAAQ;IACR,OAAO;IACP;;;;;;;KCxBQ,iBAAiB;;;;;;;;EAQ3B,QAAQ,eAAe;;;;;KAMb;EACV;;;;EAIA,SAAS,MAAM;;;;;EAKf;;;;EAIA;;;;EAIA;IACE,MAAM;IACN,MAAM;;;;;;KAOE,eAAe,yBAAyB,cAClD,gBACA;;;;KAMU,UAAU;EACpB,IAAI;;;;;;;;;;;;;;;EAeJ;IAAiB,OAAO;;EACxB,QAAQ,eAAe;EACvB,SAAS,MAAM,kBAAkB,gBAAgB;;;;;iBAMnC,gBAAgB,uBAC9B,QAAQ,UAAU,kBACjB,UAAU;;;;iBC/CG,wBAAwB;EACtC,OAAO,MAAM;EACb,aACE,YACA;IAEA;MAAa,OAAO;MAAa,KAAK;;IACtC,cAAc;;6CAEjB,0mDAAA;KAmOI;EACH,OAAO,MAAM;;;;;;;;;;;;;;;;iBAiBC,gBAAgB,OAAO;;;;KC7R3B,cAAc,4BACvB;EAAY,UAAU;GACvB,eAAe;;;;KAML,kBAAkB;EAC5B,IAAI;EACJ,QAAQ,eAAe;;;;;;;;;;;;;;;;;;EAkBvB,WACI,cAAc,kBACd,eAAe,cAAc;;;;;;;;;;;;;;;;iBAiBnB,wBAAwB,uBACtC,QAAQ,kBAAkB,kBACzB,UAAU"}