@prosekit/extensions 0.7.24 → 0.9.0

package/dist/prosekit-extensions-code-block.js

@@ -1,217 +1,234 @@
-import {
-  defineTextBlockEnterRule
-} from "./chunk-D54VSLLS.js";
-import {
-  defineTextBlockInputRule
-} from "./chunk-BV3SHIMW.js";
-
-// src/code-block/code-block.ts
-import {
-  union
-} from "@prosekit/core";
+import { defineTextBlockInputRule } from "./input-rule-Gji4N7Oe.js";
+import { defineTextBlockEnterRule } from "./enter-rule-RdhEA900.js";
+import { defaultBlockAt, defineCommands, defineKeymap, defineNodeSpec, definePlugin, insertNode, setBlockType, setNodeAttrs, toggleNode, union } from "@prosekit/core";
+import { TextSelection } from "@prosekit/pm/state";
+import { createHighlightPlugin } from "prosemirror-highlight";
+import { createParser } from "prosemirror-highlight/shiki";
+import { bundledLanguagesInfo as shikiBundledLanguagesInfo, bundledThemesInfo as shikiBundledThemesInfo } from "shiki";
 
-// src/code-block/code-block-commands.ts
-import {
-  defineCommands,
-  insertNode,
-  setBlockType,
-  setNodeAttrs,
-  toggleNode
-} from "@prosekit/core";
+//#region src/code-block/code-block-commands.ts
+/**
+* Adds commands for working with `codeBlock` nodes.
+*
+* @public
+*/
 function defineCodeBlockCommands() {
-  return defineCommands({
-    setCodeBlock: (attrs) => {
-      return setBlockType({ type: "codeBlock", attrs });
-    },
-    insertCodeBlock: (attrs) => {
-      return insertNode({ type: "codeBlock", attrs });
-    },
-    toggleCodeBlock: (attrs) => {
-      return toggleNode({ type: "codeBlock", attrs });
-    },
-    setCodeBlockAttrs: (attrs) => {
-      return setNodeAttrs({ type: "codeBlock", attrs });
-    }
-  });
+	return defineCommands({
+		setCodeBlock: (attrs) => {
+			return setBlockType({
+				type: "codeBlock",
+				attrs
+			});
+		},
+		insertCodeBlock: (attrs) => {
+			return insertNode({
+				type: "codeBlock",
+				attrs
+			});
+		},
+		toggleCodeBlock: (attrs) => {
+			return toggleNode({
+				type: "codeBlock",
+				attrs
+			});
+		},
+		setCodeBlockAttrs: (attrs) => {
+			return setNodeAttrs({
+				type: "codeBlock",
+				attrs
+			});
+		}
+	});
 }
 
-// src/code-block/code-block-input-rule.ts
+//#endregion
+//#region src/code-block/code-block-input-rule.ts
+/**
+* Adds input rules for `codeBlock` nodes.
+*
+* @public
+*/
 function defineCodeBlockInputRule() {
-  return defineTextBlockInputRule({
-    regex: /^```(\S*)\s$/,
-    type: "codeBlock",
-    attrs: getAttrs
-  });
+	return defineTextBlockInputRule({
+		regex: /^```(\S*)\s$/,
+		type: "codeBlock",
+		attrs: getAttrs
+	});
 }
+/**
+* Adds enter rules for `codeBlock` nodes.
+*
+* @public
+*/
 function defineCodeBlockEnterRule() {
-  return defineTextBlockEnterRule({
-    regex: /^```(\S*)$/,
-    type: "codeBlock",
-    attrs: getAttrs
-  });
+	return defineTextBlockEnterRule({
+		regex: /^```(\S*)$/,
+		type: "codeBlock",
+		attrs: getAttrs
+	});
 }
 function getAttrs(match) {
-  return { language: match[1] || "" };
+	return { language: match[1] || "" };
 }
 
-// src/code-block/code-block-keymap.ts
-import {
-  defaultBlockAt,
-  defineKeymap
-} from "@prosekit/core";
-import {
-  TextSelection
-} from "@prosekit/pm/state";
+//#endregion
+//#region src/code-block/code-block-keymap.ts
+/**
+* Defines the keymap for code blocks.
+*/
 function defineCodeBlockKeymap() {
-  return defineKeymap({
-    Enter: existCodeBlock
-  });
+	return defineKeymap({ Enter: existCodeBlock });
 }
-var existCodeBlock = (state, dispatch) => {
-  if (!state.selection.empty) {
-    return false;
-  }
-  const { $head } = state.selection;
-  const parent = $head.parent;
-  if (parent.isTextblock && parent.type.spec.code && $head.parentOffset === parent.content.size && parent.textContent.endsWith("\n\n")) {
-    const grandParent = $head.node(-1);
-    const insertIndex = $head.indexAfter(-1);
-    const type = defaultBlockAt(grandParent.contentMatchAt(insertIndex));
-    if (!type || !grandParent.canReplaceWith(insertIndex, insertIndex, type)) {
-      return false;
-    }
-    if (dispatch) {
-      const { tr } = state;
-      tr.delete($head.pos - 2, $head.pos);
-      const pos = tr.selection.$head.after();
-      const node = type.createAndFill();
-      if (node) {
-        tr.replaceWith(pos, pos, node);
-        tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1));
-        dispatch(tr.scrollIntoView());
-      }
-    }
-    return true;
-  }
-  return false;
+/**
+* Exit a code block and insert a default block below if the cursor is at the
+* end of the code block and the code block is ended with two new lines.
+*/
+const existCodeBlock = (state, dispatch) => {
+	if (!state.selection.empty) return false;
+	const { $head } = state.selection;
+	const parent = $head.parent;
+	if (parent.isTextblock && parent.type.spec.code && $head.parentOffset === parent.content.size && parent.textContent.endsWith("\n\n")) {
+		const grandParent = $head.node(-1);
+		const insertIndex = $head.indexAfter(-1);
+		const type = defaultBlockAt(grandParent.contentMatchAt(insertIndex));
+		if (!type || !grandParent.canReplaceWith(insertIndex, insertIndex, type)) return false;
+		if (dispatch) {
+			const { tr } = state;
+			tr.delete($head.pos - 2, $head.pos);
+			const pos = tr.selection.$head.after();
+			const node = type.createAndFill();
+			if (node) {
+				tr.replaceWith(pos, pos, node);
+				tr.setSelection(TextSelection.near(tr.doc.resolve(pos), 1));
+				dispatch(tr.scrollIntoView());
+			}
+		}
+		return true;
+	}
+	return false;
 };
 
-// src/code-block/code-block-spec.ts
-import {
-  defineNodeSpec
-} from "@prosekit/core";
+//#endregion
+//#region src/code-block/code-block-spec.ts
+/**
+* Defines the `codeBlock` node spec.
+*
+* @public
+*/
 function defineCodeBlockSpec() {
-  return defineNodeSpec({
-    name: "codeBlock",
-    content: "text*",
-    group: "block",
-    code: true,
-    defining: true,
-    marks: "",
-    attrs: { language: { default: "" } },
-    parseDOM: [
-      {
-        tag: "pre",
-        preserveWhitespace: "full",
-        getAttrs: (node) => ({
-          language: node.getAttribute("data-language") || ""
-        })
-      }
-    ],
-    toDOM(node) {
-      const attrs = node.attrs;
-      return ["pre", { "data-language": attrs.language }, ["code", 0]];
-    }
-  });
+	return defineNodeSpec({
+		name: "codeBlock",
+		content: "text*",
+		group: "block",
+		code: true,
+		defining: true,
+		marks: "",
+		attrs: { language: {
+			default: "",
+			validate: "string"
+		} },
+		parseDOM: [{
+			tag: "pre",
+			preserveWhitespace: "full",
+			getAttrs: (node) => ({ language: node.getAttribute("data-language") || "" })
+		}],
+		toDOM(node) {
+			const attrs = node.attrs;
+			return [
+				"pre",
+				{ "data-language": attrs.language },
+				["code", 0]
+			];
+		}
+	});
 }
 
-// src/code-block/code-block.ts
+//#endregion
+//#region src/code-block/code-block.ts
+/**
+* Adds `codeBlock` nodes to the editor. This includes the following extensions:
+*
+* - {@link defineCodeBlockSpec}
+* - {@link defineCodeBlockInputRule}
+* - {@link defineCodeBlockEnterRule}
+* - {@link defineCodeBlockKeymap}
+* - {@link defineCodeBlockCommands}.
+*
+* @public
+*/
 function defineCodeBlock() {
-  return union(
-    defineCodeBlockSpec(),
-    defineCodeBlockInputRule(),
-    defineCodeBlockEnterRule(),
-    defineCodeBlockKeymap(),
-    defineCodeBlockCommands()
-  );
+	return union(defineCodeBlockSpec(), defineCodeBlockInputRule(), defineCodeBlockEnterRule(), defineCodeBlockKeymap(), defineCodeBlockCommands());
 }
 
-// src/code-block/code-block-highlight.ts
-import {
-  definePlugin
-} from "@prosekit/core";
-import {
-  createHighlightPlugin
-} from "prosemirror-highlight";
-function defineCodeBlockHighlight({
-  parser
-}) {
-  return definePlugin(
-    createHighlightPlugin({ parser })
-  );
+//#endregion
+//#region src/code-block/code-block-highlight.ts
+/**
+* Adds syntax highlighting to code blocks. This function requires a `Parser`
+* instance from the `prosemirror-highlight` package. See the
+* [documentation](https://github.com/ocavue/prosemirror-highlight) for more
+* information.
+*
+* @param options
+*
+* @public
+*/
+function defineCodeBlockHighlight({ parser }) {
+	return definePlugin(createHighlightPlugin({ parser }));
 }
 
-// src/code-block/shiki-parser.ts
-import { createParser } from "prosemirror-highlight/shiki";
-
-// src/code-block/shiki-highlighter.ts
-var loaded;
+//#endregion
+//#region src/code-block/shiki-highlighter.ts
+let loaded;
 async function load() {
-  const { createOrGetHighlighter: createOrGetHighlighter2 } = await import("./shiki-highlighter-chunk.js");
-  loaded = createOrGetHighlighter2;
+	const { createOrGetHighlighter: createOrGetHighlighter$1 } = await import("./shiki-highlighter-chunk.js");
+	loaded = createOrGetHighlighter$1;
 }
 function createOrGetHighlighter(options) {
-  if (!loaded) {
-    return { promise: load() };
-  }
-  return loaded(options);
+	if (!loaded) return { promise: load() };
+	return loaded(options);
 }
 
-// src/code-block/shiki-parser.ts
+//#endregion
+//#region src/code-block/shiki-parser.ts
+/**
+* @internal
+*/
 function createLazyParser(highlighterOptions) {
-  let parser;
-  return function lazyParser(options) {
-    const language = options.language || "";
-    const { highlighter, promise } = createOrGetHighlighter({
-      ...highlighterOptions,
-      langs: [language]
-    });
-    if (!highlighter) {
-      return promise;
-    }
-    if (!parser) {
-      parser = createParser(highlighter, {
-        theme: highlighterOptions.themes[0]
-      });
-    }
-    return parser(options);
-  };
+	let parser;
+	return function lazyParser(options) {
+		const language = options.language || "";
+		const { highlighter, promise } = createOrGetHighlighter({
+			...highlighterOptions,
+			langs: [language]
+		});
+		if (!highlighter) return promise;
+		if (!parser) parser = createParser(highlighter, { theme: highlighterOptions.themes[0] });
+		return parser(options);
+	};
 }
 
-// src/code-block/code-block-shiki.ts
-function defineCodeBlockShiki({
-  themes = ["one-dark-pro"],
-  langs = ["text"],
-  ...rest
-} = {}) {
-  const parser = createLazyParser({ themes, langs, ...rest });
-  return defineCodeBlockHighlight({ parser });
+//#endregion
+//#region src/code-block/code-block-shiki.ts
+/**
+* Adds syntax highlighting to code blocks using the [Shiki](https://github.com/shikijs/shiki) package.
+*
+* It will set two CSS variables on the code block elements:
+*
+* - `--prosemirror-highlight`: sets text color
+* - `--prosemirror-highlight-bg`: sets background color
+*
+* @param options - The options to configure the Shiki highlighter.
+*
+* @public
+*/
+function defineCodeBlockShiki({ themes = ["one-dark-pro"], langs = ["text"],...rest } = {}) {
+	const parser = createLazyParser({
+		themes,
+		langs,
+		...rest
+	});
+	return defineCodeBlockHighlight({ parser });
 }
 
-// src/code-block/shiki-bundle.ts
-import {
-  bundledLanguagesInfo,
-  bundledThemesInfo
-} from "shiki";
-export {
-  defineCodeBlock,
-  defineCodeBlockCommands,
-  defineCodeBlockEnterRule,
-  defineCodeBlockHighlight,
-  defineCodeBlockInputRule,
-  defineCodeBlockKeymap,
-  defineCodeBlockShiki,
-  defineCodeBlockSpec,
-  bundledLanguagesInfo as shikiBundledLanguagesInfo,
-  bundledThemesInfo as shikiBundledThemesInfo
-};
+//#endregion
+export { defineCodeBlock, defineCodeBlockCommands, defineCodeBlockEnterRule, defineCodeBlockHighlight, defineCodeBlockInputRule, defineCodeBlockKeymap, defineCodeBlockShiki, defineCodeBlockSpec, shikiBundledLanguagesInfo, shikiBundledThemesInfo };

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

@@ -1,8 +1,61 @@
-export { defineCode_alias_1 as defineCode } from './_tsup-dts-rollup.js';
-export { CodeExtension_alias_1 as CodeExtension } from './_tsup-dts-rollup.js';
-export { defineCodeCommands_alias_1 as defineCodeCommands } from './_tsup-dts-rollup.js';
-export { CodeCommandsExtension_alias_1 as CodeCommandsExtension } from './_tsup-dts-rollup.js';
-export { defineCodeInputRule_alias_1 as defineCodeInputRule } from './_tsup-dts-rollup.js';
-export { defineCodeKeymap_alias_1 as defineCodeKeymap } from './_tsup-dts-rollup.js';
-export { defineCodeSpec_alias_1 as defineCodeSpec } from './_tsup-dts-rollup.js';
-export { CodeSpecExtension_alias_1 as CodeSpecExtension } from './_tsup-dts-rollup.js';
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+import { Attrs } from "@prosekit/pm/model";
+
+//#region src/code/code-commands.d.ts
+/**
+* @internal
+*/
+/**
+* @internal
+*/
+type CodeCommandsExtension = Extension<{
+  Commands: {
+    toggleCode: [];
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineCodeCommands(): CodeCommandsExtension;
+//#endregion
+//#region src/code/code-spec.d.ts
+/**
+* @internal
+*/
+type CodeSpecExtension = Extension<{
+  Marks: {
+    code: Attrs;
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineCodeSpec(): CodeSpecExtension;
+
+//#endregion
+//#region src/code/code.d.ts
+/**
+* @internal
+*/
+type CodeExtension = Union<[CodeSpecExtension, CodeCommandsExtension]>;
+/**
+* @public
+*/
+declare function defineCode(): CodeExtension;
+
+//#endregion
+//#region src/code/code-input-rule.d.ts
+/**
+* @internal
+*/
+declare function defineCodeInputRule(): PlainExtension;
+
+//#endregion
+//#region src/code/code-keymap.d.ts
+/**
+* @internal
+*/
+declare function defineCodeKeymap(): PlainExtension;
+
+//#endregion
+export { CodeCommandsExtension, CodeExtension, CodeSpecExtension, defineCode, defineCodeCommands, defineCodeInputRule, defineCodeKeymap, defineCodeSpec };

package/dist/prosekit-extensions-code.js

@@ -1,70 +1,59 @@
-import {
-  defineMarkInputRule
-} from "./chunk-BV3SHIMW.js";
+import { defineMarkInputRule } from "./input-rule-Gji4N7Oe.js";
+import { canUseRegexLookbehind, defineCommands, defineKeymap, defineMarkSpec, toggleMark, union } from "@prosekit/core";
 
-// src/code/code.ts
-import {
-  union
-} from "@prosekit/core";
-
-// src/code/code-commands.ts
-import {
-  defineCommands,
-  toggleMark
-} from "@prosekit/core";
+//#region src/code/code-commands.ts
+/**
+* @internal
+*/
 function defineCodeCommands() {
-  return defineCommands({
-    toggleCode: () => toggleMark({ type: "code" })
-  });
+	return defineCommands({ toggleCode: () => toggleMark({ type: "code" }) });
 }
 
-// src/code/code-input-rule.ts
-import { canUseRegexLookbehind } from "@prosekit/core";
+//#endregion
+//#region src/code/code-input-rule.ts
+/**
+* @internal
+*/
 function defineCodeInputRule() {
-  return defineMarkInputRule({
-    regex: canUseRegexLookbehind() ? /(?<=\s|^)`([^\s`]|[^\s`][^`]*[^\s`])`$/ : /`([^\s`]|[^\s`][^`]*[^\s`])`$/,
-    type: "code"
-  });
+	return defineMarkInputRule({
+		regex: canUseRegexLookbehind() ? /(?<=\s|^)`([^\s`]|[^\s`][^`]*[^\s`])`$/ : /`([^\s`]|[^\s`][^`]*[^\s`])`$/,
+		type: "code"
+	});
 }
 
-// src/code/code-keymap.ts
-import {
-  defineKeymap,
-  toggleMark as toggleMark2
-} from "@prosekit/core";
+//#endregion
+//#region src/code/code-keymap.ts
+/**
+* @internal
+*/
 function defineCodeKeymap() {
-  return defineKeymap({
-    "Mod-e": toggleMark2({ type: "code" })
-  });
+	return defineKeymap({ "Mod-e": toggleMark({ type: "code" }) });
 }
 
-// src/code/code-spec.ts
-import {
-  defineMarkSpec
-} from "@prosekit/core";
+//#endregion
+//#region src/code/code-spec.ts
+/**
+* @internal
+*/
 function defineCodeSpec() {
-  return defineMarkSpec({
-    name: "code",
-    parseDOM: [{ tag: "code" }],
-    toDOM() {
-      return ["code", 0];
-    }
-  });
+	return defineMarkSpec({
+		name: "code",
+		parseDOM: [{ tag: "code" }],
+		code: true,
+		toDOM() {
+			return ["code", 0];
+		}
+	});
 }
 
-// src/code/code.ts
+//#endregion
+//#region src/code/code.ts
+/**
+* @public
+*/
 function defineCode() {
-  return union(
-    defineCodeSpec(),
-    defineCodeCommands(),
-    defineCodeKeymap(),
-    defineCodeInputRule()
-  );
+	return union(defineCodeSpec(), defineCodeCommands(), defineCodeKeymap(), defineCodeInputRule());
 }
-export {
-  defineCode,
-  defineCodeCommands,
-  defineCodeInputRule,
-  defineCodeKeymap,
-  defineCodeSpec
-};
+
+//#endregion
+export { defineCode, defineCodeCommands, defineCodeInputRule, defineCodeKeymap, defineCodeSpec };

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

@@ -1,4 +1,53 @@
-export { CommitRecorder } from './_tsup-dts-rollup.js';
-export { defineCommitRecorder } from './_tsup-dts-rollup.js';
-export { defineCommitViewer } from './_tsup-dts-rollup.js';
-export { Commit } from './_tsup-dts-rollup.js';
+import { NodeJSON, PlainExtension, StepJSON } from "@prosekit/core";
+import { Transaction } from "@prosekit/pm/state";
+import { ProseMirrorNode } from "@prosekit/pm/model";
+
+//#region src/commit/index.d.ts
+/**
+* A JSON representation of a commit.
+*/
+/**
+* A JSON representation of a commit.
+*/
+interface Commit {
+  /**
+  * The current doc node in the JSON format
+  */
+  doc: NodeJSON;
+  /**
+  * The parent node in the JSON format
+  */
+  parent: NodeJSON;
+  /**
+  * An array of steps in the JSON format that transform the parent node to the
+  * current doc node.
+  */
+  steps: StepJSON[];
+}
+/**
+* Define an extension to display the changes from the given commit in the editor.
+*/
+declare function defineCommitViewer(commit: Commit): PlainExtension;
+declare class CommitRecorder {
+  private parent;
+  private doc;
+  private steps;
+  /**
+  * Return a commit object including all changes since the last commit. `null`
+  * will be returned if there is no change.
+  */
+  commit(): Commit | null;
+  /**
+  * @internal
+  */
+  init(doc: ProseMirrorNode): void;
+  /**
+  * @internal
+  */
+  apply(tr: Transaction): void;
+}
+/**
+* Define an extension that can record the changes in the editor.
+*/
+declare function defineCommitRecorder(commitRecorder: CommitRecorder): PlainExtension; //#endregion
+export { Commit, CommitRecorder, defineCommitRecorder, defineCommitViewer };