@prosekit/extensions 0.11.1 → 0.11.3

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

@@ -0,0 +1,93 @@
+import { PlainExtension } from "@prosekit/core";
+import { EditorView } from "@prosekit/pm/view";
+import { Attrs, MarkType, ProseMirrorNode, Slice } from "@prosekit/pm/model";
+
+//#region src/paste-rule/mark-paste-rule.d.ts
+
+/**
+ * The options for {@link defineMarkPasteRule}.
+ *
+ * @public
+ */
+interface MarkPasteRuleOptions {
+  /**
+   * The regular expression to match against. It must have a `g` flag to match
+   * all instances of the mark.
+   */
+  regex: RegExp;
+  /**
+   * The mark type to apply to the matched text.
+   */
+  type: string | MarkType;
+  /**
+   * A function used to compute attributes to set on the mark created by this
+   * rule. When it returns `false`, the rule won't match. When it returns `null`
+   * or `undefined`, that is interpreted as an empty/default set of attributes.
+   * @default null
+   */
+  getAttrs?: (match: RegExpExecArray) => Attrs | null | undefined | false;
+  /**
+   * Optional function to determine if a text node should be skipped.
+   * Default behavior: skip code nodes and nodes that already have the target mark.
+   */
+  shouldSkip?: (node: ProseMirrorNode) => boolean;
+}
+/**
+ * Defines a paste rule that applies marks based on regex patterns.
+ *
+ * @public
+ */
+declare function defineMarkPasteRule(options: MarkPasteRuleOptions): PlainExtension;
+//#endregion
+//#region src/paste-rule/paste-rule.d.ts
+/**
+ * @public
+ *
+ * Options for {@link PasteRuleHandler}.
+ */
+interface PasteRuleHandlerOptions {
+  /**
+   * The slice to be pasted.
+   */
+  slice: Slice;
+  /**
+   * The editor view.
+   */
+  view: EditorView;
+  /**
+   * Whether the pasted content is treated as plain text. This is true when the
+   * `Shift` key is held when pasting.
+   */
+  plain: boolean;
+}
+/**
+ * @public
+ *
+ * Can be used to transform pasted or dragged-and-dropped content before it is
+ * applied to the document.
+ */
+type PasteRuleHandler = (options: PasteRuleHandlerOptions) => Slice;
+/**
+ * Options for {@link definePasteRule}.
+ *
+ * @public
+ */
+interface PasteRuleOptions {
+  /**
+   * A function to be called when a paste rule is triggered.
+   */
+  handler: PasteRuleHandler;
+}
+/**
+ * Defines a paste rule. This rule allows you to modify pasted or dragged
+ * content before it is inserted into the document.
+ *
+ * @param options
+ *
+ * @public
+ */
+declare function definePasteRule({
+  handler
+}: PasteRuleOptions): PlainExtension;
+//#endregion
+export { type MarkPasteRuleOptions, type PasteRuleHandler, type PasteRuleHandlerOptions, type PasteRuleOptions, defineMarkPasteRule, definePasteRule };

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

@@ -0,0 +1,3 @@
+import { defineMarkPasteRule, definePasteRule } from "./paste-rule-Cca3n5TA.js";
+
+export { defineMarkPasteRule, definePasteRule };

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

@@ -4,30 +4,30 @@ import { EditorState } from "@prosekit/pm/state";
 //#region src/placeholder/index.d.ts
 interface PlaceholderOptions {
   /**
-  * The placeholder to use. It can be a static string or a function that
-  * receives the current editor state and returns a string.
-  */
+   * The placeholder to use. It can be a static string or a function that
+   * receives the current editor state and returns a string.
+   */
   placeholder: string | ((state: EditorState) => string);
   /**
-  * By default, the placeholder text will be shown whenever the current text
-  * cursor is in an empty text node and it's not inside a code block or a
-  * table node.
-  *
-  * If you only want to show the placeholder when the whole doc is empty, you
-  * can set this option to 'doc'.
-  *
-  * You can also pass a function that receives the current editor state and
-  * returns a boolean value to determine whether the placeholder should be
-  * shown.
-  *
-  * @default 'block'
-  */
-  strategy?: "doc" | "block" | ((state: EditorState) => boolean);
+   * By default, the placeholder text will be shown whenever the current text
+   * cursor is in an empty text node and it's not inside a code block or a
+   * table node.
+   *
+   * If you only want to show the placeholder when the whole doc is empty, you
+   * can set this option to 'doc'.
+   *
+   * You can also pass a function that receives the current editor state and
+   * returns a boolean value to determine whether the placeholder should be
+   * shown.
+   *
+   * @default 'block'
+   */
+  strategy?: 'doc' | 'block' | ((state: EditorState) => boolean);
 }
 /**
-* Add a placeholder text to the editor when the current block or document is
-* empty.
-*/
+ * Add a placeholder text to the editor when the current block or document is
+ * empty.
+ */
 declare function definePlaceholder(options: PlaceholderOptions): PlainExtension;
 //#endregion
 export { PlaceholderOptions, definePlaceholder };

package/dist/prosekit-extensions-placeholder.js

@@ -1,4 +1,4 @@
-import { findTable } from "./table-3rDWFyBH.js";
+import { findTable } from "./table-C_qAMj5-.js";
 import { definePlugin, isInCodeBlock, maybeRun } from "@prosekit/core";
 import { Plugin, PluginKey } from "@prosekit/pm/state";
 import { Decoration, DecorationSet } from "@prosekit/pm/view";

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

@@ -3,8 +3,8 @@ import { PlainExtension } from "@prosekit/core";
 //#region src/readonly/index.d.ts
 
 /**
-* Make the editor read-only.
-*/
+ * Make the editor read-only.
+ */
 declare function defineReadonly(): PlainExtension;
 //#endregion
 export { defineReadonly };

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

@@ -3,55 +3,55 @@ import { Extension, PlainExtension } from "@prosekit/core";
 //#region src/search/index.d.ts
 
 /**
-* Options for {@link defineSearchQuery}
-*
-* @public
-*/
+ * Options for {@link defineSearchQuery}
+ *
+ * @public
+ */
 interface SearchQueryOptions {
   /**
-  * The search string (or regular expression).
-  */
+   * The search string (or regular expression).
+   */
   search: string;
   /**
-  * The replace text.
-  */
+   * The replace text.
+   */
   replace?: string;
   /**
-  * Indicates whether the search is case-sensitive
-  *
-  * @default false
-  */
+   * Indicates whether the search is case-sensitive
+   *
+   * @default false
+   */
   caseSensitive?: boolean;
   /**
-  * By default, string search will replace `\n`, `\r`, and `\t` in the query
-  * with newline, return, and tab characters. When this is set to true, that
-  * behavior is disabled.
-  *
-  * @default false
-  */
+   * By default, string search will replace `\n`, `\r`, and `\t` in the query
+   * with newline, return, and tab characters. When this is set to true, that
+   * behavior is disabled.
+   *
+   * @default false
+   */
   literal?: boolean;
   /**
-  * When true, the search string is interpreted as a regular expression.
-  *
-  * @default false
-  */
+   * When true, the search string is interpreted as a regular expression.
+   *
+   * @default false
+   */
   regexp?: boolean;
   /**
-  * Enable whole-word matching.
-  *
-  * @default false
-  */
+   * Enable whole-word matching.
+   *
+   * @default false
+   */
   wholeWord?: boolean;
 }
 /**
-* Defines an extension that stores a current search query and replace string.
-*
-* @public
-*/
+ * Defines an extension that stores a current search query and replace string.
+ *
+ * @public
+ */
 declare function defineSearchQuery(options: SearchQueryOptions): PlainExtension;
 /**
-* @internal
-*/
+ * @internal
+ */
 type SearchCommandsExtension = Extension<{
   Commands: {
     findNext: [];
@@ -65,10 +65,10 @@ type SearchCommandsExtension = Extension<{
   };
 }>;
 /**
-* Defines commands for search and replace.
-*
-* @public
-*/
+ * Defines commands for search and replace.
+ *
+ * @public
+ */
 declare function defineSearchCommands(): SearchCommandsExtension;
 //#endregion
 export { SearchCommandsExtension, SearchQueryOptions, defineSearchCommands, defineSearchQuery };

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

@@ -4,44 +4,44 @@ import { Attrs } from "@prosekit/pm/model";
 //#region src/strike/index.d.ts
 
 /**
-* @internal
-*/
+ * @internal
+ */
 type StrikeSpecExtension = Extension<{
   Marks: {
     strike: Attrs;
   };
 }>;
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineStrikeSpec(): StrikeSpecExtension;
 /**
-* @internal
-*/
+ * @internal
+ */
 type StrikeCommandsExtension = Extension<{
   Commands: {
     toggleStrike: [];
   };
 }>;
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineStrikeCommands(): StrikeCommandsExtension;
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineStrikeKeymap(): PlainExtension;
 /**
-* @internal
-*/
+ * @internal
+ */
 declare function defineStrikeInputRule(): PlainExtension;
 /**
-* @internal
-*/
+ * @internal
+ */
 type StrikeExtension = Union<[StrikeSpecExtension, StrikeCommandsExtension]>;
 /**
-* @public
-*/
+ * @public
+ */
 declare function defineStrike(): StrikeExtension;
 //#endregion
 export { StrikeCommandsExtension, StrikeExtension, StrikeSpecExtension, defineStrike, defineStrikeCommands, defineStrikeInputRule, defineStrikeKeymap, defineStrikeSpec };