@prosekit/extensions 0.5.2 → 0.5.3

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

@@ -22,6 +22,7 @@ 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 { Slice } from '@prosekit/pm/model';
 import type { SpecialLanguage } from 'shiki';
 import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
 import { Transaction } from '@prosekit/pm/state';
@@ -583,6 +584,33 @@ export declare function definePlaceholder(options: PlaceholderOptions): Extensio
  */
 export declare function defineReadonly(): Extension<any>;
 
+/**
+ * Defines commands for search and replace.
+ *
+ * @public
+ */
+export declare function defineSearchCommands(): Extension<    {
+Commands: {
+findNext: [];
+findPrev: [];
+findNextNoWrap: [];
+findPrevNoWrap: [];
+replaceNext: [];
+replaceNextNoWrap: [];
+replaceCurrent: [];
+replaceAll: [];
+};
+Nodes: never;
+Marks: never;
+}>;
+
+/**
+ * Defines an extension that stores a current search query and replace string.
+ *
+ * @public
+ */
+export declare function defineSearchQuery(options: SearchQueryOptions): Extension<any>;
+
 /**
  * @public
  */
@@ -890,12 +918,38 @@ export declare type EnterRuleOptions = {
  */
 export declare const exitTable: Command;
 
+declare const findNext: Command;
+export { findNext }
+export { findNext as findNext_alias_1 }
+
+declare const findNextNoWrap: Command;
+export { findNextNoWrap }
+export { findNextNoWrap as findNextNoWrap_alias_1 }
+
+declare const findPrev: Command;
+export { findPrev }
+export { findPrev as findPrev_alias_1 }
+
+declare const findPrevNoWrap: Command;
+export { findPrevNoWrap }
+export { findPrevNoWrap as findPrevNoWrap_alias_1 }
+
 export declare function getCheckRanges(transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Array<[number, number]>;
 
 export { getHighlighter }
 
 export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
 
+declare function getSearchState(state: EditorState): {
+    query: SearchQuery;
+    range: {
+        from: number;
+        to: number;
+    } | null;
+} | undefined;
+export { getSearchState }
+export { getSearchState as getSearchState_alias_1 }
+
 export declare function getTrMeta(tr: Transaction): PredictionPluginState;
 
 export declare interface HeadingAttrs {
@@ -1041,6 +1095,123 @@ export declare interface PredictionPluginState {
     } | null;
 }
 
+declare interface QueryImpl {
+    findNext(state: EditorState, from: number, to: number): SearchResult | null;
+    findPrev(state: EditorState, from: number, to: number): SearchResult | null;
+}
+
+declare const replaceAll: Command;
+export { replaceAll }
+export { replaceAll as replaceAll_alias_1 }
+
+declare const replaceCurrent: Command;
+export { replaceCurrent }
+export { replaceCurrent as replaceCurrent_alias_1 }
+
+declare const replaceNext: Command;
+export { replaceNext }
+export { replaceNext as replaceNext_alias_1 }
+
+declare const replaceNextNoWrap: Command;
+export { replaceNextNoWrap }
+export { replaceNextNoWrap as replaceNextNoWrap_alias_1 }
+
+declare function search(options?: {
+    initialQuery?: SearchQuery;
+    initialRange?: {
+        from: number;
+        to: number;
+    };
+}): Plugin_2;
+export { search }
+export { search as search_alias_1 }
+
+declare class SearchQuery {
+    readonly search: string;
+    readonly caseSensitive: boolean;
+    readonly literal: boolean;
+    readonly regexp: boolean;
+    readonly replace: string;
+    readonly valid: boolean;
+    readonly wholeWord: boolean;
+    impl: QueryImpl;
+    constructor(config: {
+        search: string;
+        caseSensitive?: boolean;
+        literal?: boolean;
+        regexp?: boolean;
+        replace?: string;
+        wholeWord?: boolean;
+    });
+    eq(other: SearchQuery): boolean;
+    findNext(state: EditorState, from?: number, to?: number): SearchResult | null;
+    findPrev(state: EditorState, from?: number, to?: number): SearchResult | null;
+    checkResult(state: EditorState, result: SearchResult): boolean;
+    unquote(string: string): string;
+    getReplacement(state: EditorState, result: SearchResult): Slice;
+}
+export { SearchQuery }
+export { SearchQuery as SearchQuery_alias_1 }
+export { SearchQuery as SearchQuery_alias_2 }
+
+/**
+ * Options for {@link defineSearchQuery}
+ *
+ * @public
+ */
+export declare interface SearchQueryOptions {
+    /**
+     * The search string (or regular expression).
+     */
+    search: string;
+    /**
+     * The replace text.
+     */
+    replace?: string;
+    /**
+     * 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
+     */
+    literal?: boolean;
+    /**
+     * When true, the search string is interpreted as a regular expression.
+     *
+     * @default false
+     */
+    regexp?: boolean;
+    /**
+     * Enable whole-word matching.
+     *
+     * @default false
+     */
+    wholeWord?: boolean;
+}
+
+declare interface SearchResult {
+    from: number;
+    to: number;
+    match: RegExpMatchArray | null;
+}
+export { SearchResult }
+export { SearchResult as SearchResult_alias_1 }
+export { SearchResult as SearchResult_alias_2 }
+
+declare function setSearchState(tr: Transaction, query: SearchQuery, range?: {
+    from: number;
+    to: number;
+} | null): Transaction;
+export { setSearchState }
+export { setSearchState as setSearchState_alias_1 }
+
 /**
  * @internal
  */
@@ -1095,4 +1266,6 @@ export declare type TextBlockEnterRuleOptions = {
     stop?: boolean;
 };
 
+export declare function validRegExp(source: string): boolean;
+
 export { }

package/dist/{chunk-DZAKXWWF.js → chunk-2JYT2MT7.js}

@@ -16,26 +16,24 @@ import {
 function defineEnterRule({
   regex,
   handler,
-  stop = false
+  stop = !1
 }) {
-  const rule = new EnterRule(regex, handler, stop);
+  let rule = new EnterRule(regex, handler, stop);
   return defineFacetPayload(enterRule, [rule]);
 }
 function defineTextBlockEnterRule({
   regex,
   type,
   attrs,
-  stop = true
+  stop = !0
 }) {
   return defineEnterRule({
     regex,
     handler: ({ state, from, to, match }) => {
-      const nodeType = getNodeType(state.schema, type);
-      const $start = state.doc.resolve(from);
-      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) {
+      let nodeType = getNodeType(state.schema, type), $start = state.doc.resolve(from);
+      if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType))
         return null;
-      }
-      const nodeAttrs = maybeRun(attrs, match);
+      let nodeAttrs = maybeRun(attrs, match);
       return state.tr.delete(from, to).setBlockType(from, from, nodeType, nodeAttrs);
     },
     stop
@@ -47,60 +45,42 @@ var EnterRule = class {
     this.handler = handler;
     this.stop = stop;
   }
-};
-var enterRule = defineFacet({
+}, enterRule = defineFacet({
   reduce: () => {
-    let rules = [];
-    const command = (state, dispatch, view) => {
-      if (!view)
-        return false;
-      return execRules(view, rules, dispatch);
-    };
-    const handler = keydownHandler({ Enter: command });
-    const plugin = new ProseMirrorPlugin({
+    let rules = [], handler = keydownHandler({ Enter: (state, dispatch, view) => view ? execRules(view, rules, dispatch) : !1 }), plugin = new ProseMirrorPlugin({
       key: new PluginKey("prosekit-enter-rule"),
       props: { handleKeyDown: handler }
     });
-    return function reducer(inputs) {
-      rules = inputs;
-      return plugin;
+    return function(inputs) {
+      return rules = inputs, plugin;
     };
   },
   parent: pluginFacet
 });
 function execRules(view, rules, dispatch) {
-  if (view.composing)
-    return false;
-  const state = view.state;
-  const selection = state.selection;
-  if (!isTextSelection(selection))
-    return false;
-  const $cursor = selection.$cursor;
-  if (!$cursor || $cursor.parent.type.spec.code)
-    return false;
-  const textBefore = $cursor.parent.textBetween(
+  if (view.composing) return !1;
+  let state = view.state, selection = state.selection;
+  if (!isTextSelection(selection)) return !1;
+  let $cursor = selection.$cursor;
+  if (!$cursor || $cursor.parent.type.spec.code) return !1;
+  let textBefore = $cursor.parent.textBetween(
     Math.max(0, $cursor.parentOffset - MAX_MATCH),
     $cursor.parentOffset,
     null,
     OBJECT_REPLACEMENT_CHARACTER
   );
-  for (const rule of rules) {
+  for (let rule of rules) {
     rule.regex.lastIndex = 0;
-    const match = rule.regex.exec(textBefore);
-    const tr = match && rule.handler({
+    let match = rule.regex.exec(textBefore), tr = match && rule.handler({
       state,
       from: $cursor.pos - match[0].length,
       to: $cursor.pos,
       match
     });
-    if (!tr)
-      continue;
-    dispatch == null ? void 0 : dispatch(tr);
-    if (rule.stop) {
-      return true;
-    }
+    if (tr && (dispatch == null || dispatch(tr), rule.stop))
+      return !0;
   }
-  return false;
+  return !1;
 }
 var MAX_MATCH = 200;
 

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

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

package/dist/chunk-ZPEMHYTU.js

@@ -0,0 +1,140 @@
+// 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) {
+  let nodeRange = $from.blockRange($to);
+  if (!nodeRange)
+    return [];
+  let stack = [], start = nodeRange.start;
+  for (let i = nodeRange.startIndex; i < nodeRange.endIndex; i++) {
+    let child = nodeRange.parent.child(i);
+    stack.push([start, child]), start += child.nodeSize;
+  }
+  let ranges = [];
+  for (; stack.length > 0; ) {
+    let [start2, node] = stack.pop();
+    if (!node.type.spec.code) {
+      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) {
+  let $from = doc.resolve(from), $to = doc.resolve(to);
+  return $from.sameParent($to) && $from.parent.isTextblock ? [getInlineTextRange($from, $to)] : $from.blockRange($to) ? getSpanTextRanges($from, $to) : [];
+}
+function getMapRange(transactions, oldState, newState) {
+  let lo = oldState.selection.from, hi = oldState.selection.to;
+  for (let tr of transactions)
+    for (let 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);
+      });
+  return lo = Math.min(lo, hi, newState.selection.from), hi = Math.min(lo, hi, newState.selection.to), [lo, hi];
+}
+function getCheckRanges(transactions, oldState, newState) {
+  let [from, to] = getMapRange(transactions, oldState, newState);
+  return getTextRanges(newState.doc, from, to);
+}
+
+// src/mark-rule/apply.ts
+function getExpectedMarkings(rules, doc, from, to) {
+  let text = doc.textBetween(from, to, null, OBJECT_REPLACEMENT_CHARACTER), ranges = [];
+  for (let rule of rules) {
+    rule.regex.lastIndex = 0;
+    let matches = text.matchAll(rule.regex), markType = getMarkType(doc.type.schema, rule.type);
+    for (let match of matches) {
+      let index = match.index;
+      if (index == null) continue;
+      let attrs = maybeRun(rule.attrs, match), 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]);
+  let result = [], freeIndex = 0;
+  for (let range of ranges)
+    range[0] >= freeIndex && (result.push(range), freeIndex = range[1]);
+  return result;
+}
+function getReceivedMarkings(rules, doc, from, to) {
+  let result = [], schema = doc.type.schema, markTypes = rules.map((rule) => getMarkType(schema, rule.type));
+  return doc.nodesBetween(from, to, (node, pos) => {
+    if (node.isInline)
+      for (let markType of markTypes) {
+        let mark = node.marks.find((mark2) => mark2.type === markType);
+        mark && result.push([pos, pos + node.nodeSize, mark]);
+      }
+  }), 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;
+  let ranges = getCheckRanges(transactions, oldState, newState), toRemove = [], toCreate = [];
+  for (let [from, to] of ranges) {
+    let expected = getExpectedMarkings(rules, newState.doc, from, to), 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;
+  let tr = newState.tr;
+  for (let [from, to, mark] of toRemove)
+    tr.removeMark(from, to, mark);
+  for (let [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 = [], plugin = new ProseMirrorPlugin({
+      key: new PluginKey("prosekit-mark-rule"),
+      appendTransaction: (transactions, oldState, newState) => applyMarkRules(rules, transactions, oldState, newState)
+    });
+    return function(input) {
+      return rules = input, plugin;
+    };
+  },
+  parent: pluginFacet
+});
+
+export {
+  defineMarkRule
+};

package/dist/list/style.css

@@ -2,7 +2,6 @@
 .prosemirror-flat-list {
   padding: 0;
   margin-top: 0;
-  margin-bottom: 0;
   margin-left: 32px;
   margin-bottom: 0;
   position: relative;
@@ -15,10 +14,7 @@
 .prosemirror-flat-list.ProseMirror-selectednode:after {
   content: "";
   position: absolute;
-  left: -32px;
-  right: -2px;
-  top: -2px;
-  bottom: -2px;
+  inset: -2px -2px -2px -32px;
   border: 2px solid #8cf;
   pointer-events: none;
 }
@@ -31,7 +27,7 @@
 .prosemirror-flat-list[data-list-kind=ordered] > * {
   contain: style;
 }
-.prosemirror-flat-list[data-list-kind=ordered]::before {
+.prosemirror-flat-list[data-list-kind=ordered]:before {
   position: absolute;
   right: 100%;
   font-variant-numeric: tabular-nums;
@@ -69,10 +65,10 @@
   width: 1.5em;
   width: 1lh;
 }
-.prosemirror-flat-list[data-list-kind=toggle] > .list-marker::before {
+.prosemirror-flat-list[data-list-kind=toggle] > .list-marker:before {
   content: "\23f7";
 }
-.prosemirror-flat-list[data-list-kind=toggle][data-list-collapsable][data-list-collapsed] > .list-marker::before {
+.prosemirror-flat-list[data-list-kind=toggle][data-list-collapsable][data-list-collapsed] > .list-marker:before {
   content: "\23f5";
 }
 .prosemirror-flat-list[data-list-kind=toggle][data-list-collapsable] > .list-marker {

package/dist/placeholder/style.css

@@ -1,5 +1,5 @@
 /* src/placeholder/style.css */
-.prosekit-placeholder::before {
+.prosekit-placeholder:before {
   position: absolute;
   opacity: 30%;
   pointer-events: none;