@prosekit/extensions 0.0.0-next-20230709090937 → 0.0.0-next-20231120040948

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

@@ -0,0 +1,459 @@
+import { CommandArgs } from '@prosekit/core';
+import { DedentListOptions } from 'prosemirror-flat-list';
+import { EditorState } from '@prosekit/pm/state';
+import { Extension } from '@prosekit/core';
+import { ExtensionTyping } from '@prosekit/core';
+import type { HLJSApi } from 'highlight.js';
+import { IndentListOptions } from 'prosemirror-flat-list';
+import { ListAttributes } from 'prosemirror-flat-list';
+import { NodeRange } from 'prosemirror-model';
+import { Options } from 'tsup';
+import { Plugin as Plugin_2 } from '@prosekit/pm/state';
+import { PluginKey } from '@prosekit/pm/state';
+import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
+import { Transaction } from '@prosekit/pm/state';
+import { UnwrapListOptions } from 'prosemirror-flat-list';
+import { UserProjectConfigExport } from 'vitest/dist/config.js';
+
+declare class AutocompleteRule {
+    readonly regex: RegExp;
+    readonly onMatch: MatchHandler;
+    readonly onLeave?: VoidFunction;
+    readonly canMatch: (options: {
+        state: EditorState;
+    }) => boolean;
+    constructor(options: {
+        regex: RegExp;
+        onEnter: MatchHandler;
+        onLeave?: VoidFunction;
+        canMatch?: (options: {
+            state: EditorState;
+        }) => boolean;
+    });
+}
+export { AutocompleteRule }
+export { AutocompleteRule as AutocompleteRule_alias_1 }
+
+declare interface CodeBlockAttrs {
+    language?: string;
+}
+export { CodeBlockAttrs }
+export { CodeBlockAttrs as CodeBlockAttrs_alias_1 }
+
+export declare function createAutocompletePlugin({ getRules, }: {
+    getRules: () => AutocompleteRule[];
+}): Plugin_2;
+
+export declare function createPredictionPlugin(options: SuggestionOptions): Plugin_2;
+
+export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_1: UserProjectConfigExport;
+
+export declare function defaultCanMatch({ state }: {
+    state: EditorState;
+}): boolean;
+
+export declare function defaultIsValid({ state }: {
+    state: EditorState;
+}): boolean;
+
+export declare function defineAutocomplete(rule: AutocompleteRule): Extension;
+
+/**
+ * @public
+ */
+export declare function defineBlockquote(): Extension<    {
+NODES: "blockquote";
+}>;
+
+export declare function defineBlockquoteSpec(): Extension<    {
+NODES: "blockquote";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineBold(): Extension<    {
+MARKS: "bold";
+COMMAND_ARGS: {
+toggleBold: [];
+};
+}>;
+
+export declare function defineBoldCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleBold: [];
+};
+}>;
+
+export declare function defineBoldKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineBoldSpec(): Extension<    {
+MARKS: "bold";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineCode(): Extension<    {
+MARKS: "code";
+COMMAND_ARGS: {
+toggleCode: [];
+};
+}>;
+
+/**
+ * @public
+ */
+export declare function defineCodeBlock(options?: {
+    hljs?: HLJSApi;
+}): Extension<    {
+NODES: "codeBlock";
+COMMAND_ARGS: {
+setCodeBlockLanguage: [language: string];
+};
+}>;
+
+export declare function defineCodeBlockCommands(): Extension<    {
+COMMAND_ARGS: {
+setCodeBlockLanguage: [language: string];
+};
+}>;
+
+export declare function defineCodeBlockHighlight(options: {
+    hljs?: HLJSApi;
+}): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineCodeBlockInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineCodeBlockSpec(): Extension<    {
+NODES: "codeBlock";
+}>;
+
+export declare function defineCodeCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleCode: [];
+};
+}>;
+
+/**
+ * @public
+ */
+export declare function defineCodeSpec(): Extension<    {
+MARKS: "code";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineHeading(): Extension<    {
+NODES: "heading";
+COMMAND_ARGS: {
+setHeading: [attrs?: HeadingAttrs | undefined];
+insertHeading: [attrs?: HeadingAttrs | undefined];
+toggleHeading: [attrs?: HeadingAttrs | undefined];
+};
+}>;
+
+export declare function defineHeadingCommands(): Extension<    {
+COMMAND_ARGS: {
+setHeading: [attrs?: HeadingAttrs | undefined];
+insertHeading: [attrs?: HeadingAttrs | undefined];
+toggleHeading: [attrs?: HeadingAttrs | undefined];
+};
+}>;
+
+export declare function defineHeadingInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineHeadingKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineHeadingSpec(): Extension<    {
+NODES: "heading";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineImage(): Extension<    {
+NODES: "image";
+COMMAND_ARGS: {
+insertImage: [attrs?: ImageAttrs | undefined];
+};
+}>;
+
+export declare function defineImageCommands(): Extension<    {
+COMMAND_ARGS: {
+insertImage: [attrs?: ImageAttrs | undefined];
+};
+}>;
+
+export declare function defineImageSpec(): Extension<    {
+NODES: "image";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineItalic(): Extension<    {
+MARKS: "italic";
+COMMAND_ARGS: {
+toggleItalic: [];
+};
+}>;
+
+export declare function defineItalicCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleItalic: [];
+};
+}>;
+
+export declare function defineItalicKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineItalicKeymap_alias_1(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineItalicSpec(): Extension<    {
+MARKS: "italic";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineLink(): Extension<    {
+MARKS: "link";
+COMMAND_ARGS: {
+addLink: [attrs: LinkAttrs];
+toggleLink: [attrs: LinkAttrs];
+};
+}>;
+
+export declare function defineLinkCommands(): Extension<    {
+COMMAND_ARGS: {
+addLink: [attrs: LinkAttrs];
+toggleLink: [attrs: LinkAttrs];
+};
+}>;
+
+export declare function defineLinkSpec(): Extension<    {
+MARKS: "link";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineList(): Extension<    {
+NODES: "list";
+COMMAND_ARGS: {
+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];
+};
+}>;
+
+export declare function defineListCommands(): Extension<    {
+COMMAND_ARGS: {
+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];
+};
+}>;
+
+export declare function defineListInputRules(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * Returns a extension that adds key bindings for list.
+ *
+ * @public
+ */
+export declare function defineListKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineListPlugins(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineListSpec(): Extension<    {
+NODES: "list";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineMention(): Extension<    {
+NODES: "mention";
+}>;
+
+/**
+ * @public
+ */
+export declare function defineMentionSpec(): Extension<    {
+NODES: "mention";
+}>;
+
+/**
+ * Add a placeholder text to the editor when the current block or document is
+ * empty.
+ */
+export declare function definePlaceholder(options: PlaceholderOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * @public
+ */
+export declare function defineStrike(): Extension<    {
+MARKS: "strike";
+COMMAND_ARGS: {
+toggleStrike: [];
+};
+}>;
+
+export declare function defineStrikeCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleStrike: [];
+};
+}>;
+
+export declare function defineStrikeKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineStrikeSpec(): Extension<    {
+MARKS: "strike";
+}>;
+
+export declare function defineSuggestion(options: SuggestionOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * @public
+ */
+export declare function defineUnderline(): Extension<    {
+MARKS: "underline";
+COMMAND_ARGS: {
+toggleUnderline: [];
+};
+}>;
+
+export declare function defineUnderlineCommands(): Extension<    {
+COMMAND_ARGS: {
+toggleUnderline: [];
+};
+}>;
+
+export declare function defineUnderlineKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineUnderlineSpec(): Extension<    {
+MARKS: "underline";
+}>;
+
+export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
+
+export declare function getTrMeta(tr: Transaction): PredictionPluginState;
+
+export declare interface HeadingAttrs {
+    level: number;
+}
+
+export declare interface ImageAttrs {
+    src?: string | null;
+}
+
+/**
+ * @public
+ */
+export declare interface LinkAttrs {
+    href: string;
+}
+
+declare type MatchHandler = (options: {
+    state: EditorState;
+    match: RegExpExecArray;
+    from: number;
+    to: number;
+    ignoreMatch: () => void;
+    deleteMatch: () => void;
+}) => Transaction | null | void;
+export { MatchHandler }
+export { MatchHandler as MatchHandler_alias_1 }
+
+/**
+ * @returns Return a Transaction object if you want to append a transaction to current state (using )
+ */
+declare type MatchHandler_2 = (options: {
+    rule: PredictionRule;
+    match: RegExpMatchArray;
+    matchAfter: RegExpMatchArray | null;
+    state: EditorState;
+    dismiss: VoidFunction;
+    deleteMatch: VoidFunction;
+}) => void;
+
+export declare interface MentionAttrs {
+    id: string;
+    kind: string;
+    value: string;
+}
+
+export declare const OBJECT_REPLACEMENT = "\uFFFC";
+
+export declare interface PlaceholderOptions {
+    /**
+     * The placeholder text to use.
+     */
+    placeholder: string;
+    /**
+     * By default, the placeholder text will be shown whenever the current text
+     * cursor is in an empty node. If you only want to show the placeholder when
+     * the whole doc is empty, you can set this option to 'doc'.
+     *
+     * @default 'block'
+     */
+    strategy?: 'doc' | 'block';
+}
+
+export declare const pluginKey: PluginKey<PredictionPluginState>;
+
+export declare interface PredictionPluginState {
+    active: boolean;
+    ignore: number | null;
+    matching: {
+        rule: AutocompleteRule;
+        from: number;
+        to: number;
+        match: RegExpExecArray;
+    } | null;
+}
+
+declare interface PredictionRule {
+    match: RegExp;
+    matchAfter?: RegExp;
+}
+export { PredictionRule }
+export { PredictionRule as PredictionRule_alias_1 }
+
+export declare function setTrMeta(tr: Transaction, meta: PredictionPluginState): Transaction;
+
+declare interface SuggestionOptions {
+    rules: PredictionRule[];
+    onMatch: MatchHandler_2;
+    onDeactivate: VoidFunction;
+    /**
+     * You can pass this function if you want to skip the matching in some cases.
+     * By default, the plugin will only run the matching if the current selection
+     * is empty, and the selection is not inside a
+     * [code](https://prosemirror.net/docs/ref/#model.NodeSpec.code) node nor
+     * inside a mark with the name as `code`.
+     */
+    isValid?: (options: {
+        state: EditorState;
+    }) => boolean;
+}
+export { SuggestionOptions }
+export { SuggestionOptions as SuggestionOptions_alias_1 }
+
+export { }

package/dist/list/style.css

@@ -1,4 +1,4 @@
-/* ../../node_modules/.pnpm/prosemirror-flat-list@0.3.15/node_modules/prosemirror-flat-list/dist/style.css */
+/* ../../node_modules/.pnpm/prosemirror-flat-list@0.4.3/node_modules/prosemirror-flat-list/dist/style.css */
 .prosemirror-flat-list {
   padding: 0;
   margin-top: 0;
@@ -77,7 +77,7 @@
   opacity: 40%;
   pointer-events: none;
 }
-.prosemirror-flat-list[data-list-kind=toggle][data-list-collapsable][data-list-collapsed] > .list-content > *:nth-child(n + 2) {
+.prosemirror-flat-list[data-list-kind=toggle][data-list-collapsable][data-list-collapsed] > .list-content > *:nth-child(n+2) {
   display: none;
 }
 

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

@@ -0,0 +1,3 @@
+export { defineAutocomplete } from './_tsup-dts-rollup';
+export { AutocompleteRule } from './_tsup-dts-rollup';
+export { MatchHandler } from './_tsup-dts-rollup';

package/dist/prosekit-extensions-autocomplete.js

@@ -0,0 +1,190 @@
+// src/autocomplete/index.ts
+import {
+  Facet,
+  pluginFacet
+} from "@prosekit/core";
+
+// src/autocomplete/plugin.ts
+import { Plugin } from "@prosekit/pm/state";
+import { Decoration, DecorationSet } from "@prosekit/pm/view";
+
+// src/autocomplete/helpers.ts
+import "@prosekit/pm/model";
+import { PluginKey } from "@prosekit/pm/state";
+function defaultCanMatch({ state }) {
+  return state.selection.empty && !isInsideCode(state.selection.$from);
+}
+function isInsideCode($pos) {
+  for (let d = $pos.depth; d > 0; d--) {
+    if ($pos.node(d).type.spec.code) {
+      return true;
+    }
+  }
+  return $pos.marks().some((mark) => mark.type.name === "code");
+}
+var OBJECT_REPLACEMENT = "\uFFFC";
+function getPluginState(state) {
+  return pluginKey.getState(state);
+}
+function getTrMeta(tr) {
+  return tr.getMeta(pluginKey);
+}
+function setTrMeta(tr, meta) {
+  return tr.setMeta(pluginKey, meta);
+}
+var pluginKey = new PluginKey(
+  "prosekit-autocomplete"
+);
+
+// src/autocomplete/plugin.ts
+function createAutocompletePlugin({
+  getRules
+}) {
+  return new Plugin({
+    key: pluginKey,
+    state: {
+      init: () => {
+        return { active: false, ignore: null, matching: null };
+      },
+      apply: (tr, prevValue, oldState, newState) => {
+        var _a;
+        const meta = getTrMeta(tr);
+        if (!tr.docChanged && oldState.selection.eq(newState.selection) && !meta) {
+          return prevValue;
+        }
+        if (meta) {
+          return meta;
+        }
+        const nextValue = calcPluginState(newState, getRules());
+        if (nextValue.active && prevValue.ignore != null && ((_a = nextValue.matching) == null ? void 0 : _a.from) === prevValue.ignore) {
+          return prevValue;
+        }
+        return nextValue;
+      }
+    },
+    view: () => ({
+      update: (view, prevState) => {
+        var _a, _b, _c;
+        const prevValue = getPluginState(prevState);
+        const currValue = getPluginState(view.state);
+        if ((prevValue == null ? void 0 : prevValue.active) && prevValue.matching && prevValue.matching.rule !== ((_a = currValue == null ? void 0 : currValue.matching) == null ? void 0 : _a.rule)) {
+          (_c = (_b = prevValue.matching.rule).onLeave) == null ? void 0 : _c.call(_b);
+        }
+        if ((currValue == null ? void 0 : currValue.active) && currValue.matching && currValue.matching.from !== currValue.ignore) {
+          const { from, to, match, rule } = currValue.matching;
+          const textContent = view.state.doc.textBetween(
+            from,
+            to,
+            OBJECT_REPLACEMENT
+          );
+          const deleteMatch = () => {
+            if (view.state.doc.textBetween(from, to, OBJECT_REPLACEMENT) === textContent) {
+              view.dispatch(view.state.tr.delete(from, to));
+            }
+          };
+          const ignoreMatch = () => {
+            view.dispatch(
+              setTrMeta(view.state.tr, {
+                active: false,
+                ignore: from,
+                matching: null
+              })
+            );
+          };
+          rule.onMatch({
+            state: view.state,
+            match,
+            from,
+            to,
+            deleteMatch,
+            ignoreMatch
+          });
+        }
+      }
+    }),
+    props: {
+      decorations: (state) => {
+        const pluginState = getPluginState(state);
+        if ((pluginState == null ? void 0 : pluginState.active) && pluginState.matching) {
+          const { from, to } = pluginState.matching;
+          const deco = Decoration.inline(from, to, {
+            class: "prosemirror-prediction-match"
+          });
+          return DecorationSet.create(state.doc, [deco]);
+        }
+        return null;
+      }
+    }
+  });
+}
+var MAX_MATCH = 200;
+function calcPluginState(state, rules) {
+  const $pos = state.selection.$from;
+  const parentOffset = $pos.parentOffset;
+  const textBefore = $pos.parent.textBetween(
+    Math.max(0, parentOffset - MAX_MATCH),
+    parentOffset,
+    null,
+    OBJECT_REPLACEMENT
+  );
+  for (const rule of rules) {
+    if (!rule.canMatch({ state })) {
+      continue;
+    }
+    rule.regex.lastIndex = 0;
+    const match = rule.regex.exec(textBefore);
+    if (!match) {
+      continue;
+    }
+    const from = $pos.pos - textBefore.length + match.index;
+    return {
+      active: true,
+      ignore: null,
+      matching: {
+        rule,
+        match,
+        from,
+        to: $pos.pos
+      }
+    };
+  }
+  return { active: false, ignore: null, matching: null };
+}
+
+// src/autocomplete/rule.ts
+var AutocompleteRule = class {
+  constructor(options) {
+    var _a;
+    this.regex = options.regex;
+    this.onMatch = options.onEnter;
+    this.onLeave = options.onLeave;
+    this.canMatch = (_a = options.canMatch) != null ? _a : defaultCanMatch;
+  }
+};
+
+// src/autocomplete/index.ts
+function defineAutocomplete(rule) {
+  return autocompleteFacet.extension([rule]);
+}
+var autocompleteFacet = Facet.define({
+  converter: () => {
+    let localRules = [];
+    const getRules = () => localRules;
+    return {
+      create: (rules) => {
+        localRules = rules;
+        const plugin = createAutocompletePlugin({ getRules });
+        return () => [plugin];
+      },
+      update: (rules) => {
+        localRules = rules;
+        return null;
+      }
+    };
+  },
+  next: pluginFacet
+});
+export {
+  AutocompleteRule,
+  defineAutocomplete
+};

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

@@ -1,11 +1,2 @@
-import * as _prosekit_core from '@prosekit/core';
-
-declare function addBlockquoteSpec(): _prosekit_core.Extension<{
-    NODES: "blockquote";
-}>;
-/** @public */
-declare function addBlockquote(): _prosekit_core.Extension<{
-    NODES: "blockquote";
-}>;
-
-export { addBlockquote, addBlockquoteSpec };
+export { defineBlockquoteSpec } from './_tsup-dts-rollup';
+export { defineBlockquote } from './_tsup-dts-rollup';