@prosekit/extensions 0.8.0 → 0.9.0

package/dist/prosekit-extensions-heading.js

@@ -1,113 +1,139 @@
-import {
-  defineTextBlockInputRule
-} from "./chunk-I2UMHK3L.js";
+import { defineTextBlockInputRule } from "./input-rule-Gji4N7Oe.js";
+import { defineCommands, defineKeymap, defineNodeSpec, insertNode, isAtBlockStart, setBlockType, toggleNode, union, unsetBlockType, withSkipCodeBlock } from "@prosekit/core";
 
-// src/heading/heading.ts
-import {
-  union
-} from "@prosekit/core";
-
-// src/heading/heading-commands.ts
-import {
-  defineCommands,
-  insertNode,
-  setBlockType,
-  toggleNode
-} from "@prosekit/core";
+//#region src/heading/heading-commands.ts
+/**
+* @internal
+*/
 function defineHeadingCommands() {
-  return defineCommands({
-    setHeading: (attrs) => {
-      return setBlockType({ type: "heading", attrs });
-    },
-    insertHeading: (attrs) => {
-      return insertNode({ type: "heading", attrs });
-    },
-    toggleHeading: (attrs) => {
-      return toggleNode({ type: "heading", attrs });
-    }
-  });
+	return defineCommands({
+		setHeading: (attrs) => {
+			return setBlockType({
+				type: "heading",
+				attrs
+			});
+		},
+		insertHeading: (attrs) => {
+			return insertNode({
+				type: "heading",
+				attrs
+			});
+		},
+		toggleHeading: (attrs) => {
+			return toggleNode({
+				type: "heading",
+				attrs
+			});
+		}
+	});
 }
 
-// src/heading/heading-input-rule.ts
+//#endregion
+//#region src/heading/heading-input-rule.ts
+/**
+* Converts the text block to a heading when `#` is typed at the start of a new
+* line followed by a space.
+*
+* @internal
+*/
 function defineHeadingInputRule() {
-  return defineTextBlockInputRule({
-    regex: /^(#{1,6})\s$/,
-    type: "heading",
-    attrs: (match) => {
-      const level = match[1]?.length ?? 1;
-      return { level };
-    }
-  });
+	return defineTextBlockInputRule({
+		regex: /^(#{1,6})\s$/,
+		type: "heading",
+		attrs: (match) => {
+			const level = match[1]?.length ?? 1;
+			return { level };
+		}
+	});
 }
 
-// src/heading/heading-keymap.ts
-import {
-  defineKeymap,
-  isAtBlockStart,
-  toggleNode as toggleNode2,
-  unsetBlockType,
-  withSkipCodeBlock
-} from "@prosekit/core";
+//#endregion
+//#region src/heading/heading-keymap.ts
 function toggleHeadingKeybinding(level) {
-  return withSkipCodeBlock(toggleNode2({ type: "heading", attrs: { level } }));
+	return withSkipCodeBlock(toggleNode({
+		type: "heading",
+		attrs: { level }
+	}));
 }
-var backspaceUnsetHeading = (state, dispatch, view) => {
-  const $pos = isAtBlockStart(state, view);
-  if ($pos?.parent.type.name === "heading") {
-    return unsetBlockType()(state, dispatch, view);
-  }
-  return false;
+/**
+* Set the block type to default (usually `paragraph`) when pressing Backspace at
+* the start of a heading block.
+*/
+const backspaceUnsetHeading = (state, dispatch, view) => {
+	const $pos = isAtBlockStart(state, view);
+	if ($pos?.parent.type.name === "heading") return unsetBlockType()(state, dispatch, view);
+	return false;
 };
+/**
+* @internal
+*/
 function defineHeadingKeymap() {
-  return defineKeymap({
-    "mod-alt-1": toggleHeadingKeybinding(1),
-    "mod-alt-2": toggleHeadingKeybinding(2),
-    "mod-alt-3": toggleHeadingKeybinding(3),
-    "mod-alt-4": toggleHeadingKeybinding(4),
-    "mod-alt-5": toggleHeadingKeybinding(5),
-    "mod-alt-6": toggleHeadingKeybinding(6),
-    "Backspace": backspaceUnsetHeading
-  });
+	return defineKeymap({
+		"mod-alt-1": toggleHeadingKeybinding(1),
+		"mod-alt-2": toggleHeadingKeybinding(2),
+		"mod-alt-3": toggleHeadingKeybinding(3),
+		"mod-alt-4": toggleHeadingKeybinding(4),
+		"mod-alt-5": toggleHeadingKeybinding(5),
+		"mod-alt-6": toggleHeadingKeybinding(6),
+		"Backspace": backspaceUnsetHeading
+	});
 }
 
-// src/heading/heading-spec.ts
-import {
-  defineNodeSpec
-} from "@prosekit/core";
+//#endregion
+//#region src/heading/heading-spec.ts
+/**
+* @internal
+*/
 function defineHeadingSpec() {
-  return defineNodeSpec({
-    name: "heading",
-    attrs: { level: { default: 1 } },
-    content: "inline*",
-    group: "block",
-    defining: true,
-    parseDOM: [
-      { tag: "h1", attrs: { level: 1 } },
-      { tag: "h2", attrs: { level: 2 } },
-      { tag: "h3", attrs: { level: 3 } },
-      { tag: "h4", attrs: { level: 4 } },
-      { tag: "h5", attrs: { level: 5 } },
-      { tag: "h6", attrs: { level: 6 } }
-    ],
-    toDOM(node) {
-      return [`h${node.attrs.level}`, 0];
-    }
-  });
+	return defineNodeSpec({
+		name: "heading",
+		attrs: { level: {
+			default: 1,
+			validate: "number"
+		} },
+		content: "inline*",
+		group: "block",
+		defining: true,
+		parseDOM: [
+			{
+				tag: "h1",
+				attrs: { level: 1 }
+			},
+			{
+				tag: "h2",
+				attrs: { level: 2 }
+			},
+			{
+				tag: "h3",
+				attrs: { level: 3 }
+			},
+			{
+				tag: "h4",
+				attrs: { level: 4 }
+			},
+			{
+				tag: "h5",
+				attrs: { level: 5 }
+			},
+			{
+				tag: "h6",
+				attrs: { level: 6 }
+			}
+		],
+		toDOM(node) {
+			return [`h${node.attrs.level}`, 0];
+		}
+	});
 }
 
-// src/heading/heading.ts
+//#endregion
+//#region src/heading/heading.ts
+/**
+* @public
+*/
 function defineHeading() {
-  return union(
-    defineHeadingSpec(),
-    defineHeadingInputRule(),
-    defineHeadingKeymap(),
-    defineHeadingCommands()
-  );
+	return union(defineHeadingSpec(), defineHeadingInputRule(), defineHeadingKeymap(), defineHeadingCommands());
 }
-export {
-  defineHeading,
-  defineHeadingCommands,
-  defineHeadingInputRule,
-  defineHeadingKeymap,
-  defineHeadingSpec
-};
+
+//#endregion
+export { defineHeading, defineHeadingCommands, defineHeadingInputRule, defineHeadingKeymap, defineHeadingSpec };

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

@@ -1,8 +1,41 @@
-export { defineHorizontalRule_alias_1 as defineHorizontalRule } from './_tsup-dts-rollup.js';
-export { HorizontalRuleExtension_alias_1 as HorizontalRuleExtension } from './_tsup-dts-rollup.js';
-export { defineHorizontalRuleCommands_alias_1 as defineHorizontalRuleCommands } from './_tsup-dts-rollup.js';
-export { insertHorizontalRule_alias_1 as insertHorizontalRule } from './_tsup-dts-rollup.js';
-export { HorizontalRuleCommandsExtension_alias_1 as HorizontalRuleCommandsExtension } from './_tsup-dts-rollup.js';
-export { defineHorizontalRuleInputRule_alias_1 as defineHorizontalRuleInputRule } from './_tsup-dts-rollup.js';
-export { defineHorizontalRuleSpec_alias_1 as defineHorizontalRuleSpec } from './_tsup-dts-rollup.js';
-export { HorizontalRuleSpecExtension_alias_1 as HorizontalRuleSpecExtension } from './_tsup-dts-rollup.js';
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+import { Command } from "@prosekit/pm/state";
+import { Attrs } from "@prosekit/pm/model";
+
+//#region src/horizontal-rule/horizontal-rule-commands.d.ts
+type HorizontalRuleCommandsExtension = Extension<{
+  Commands: {
+    insertHorizontalRule: [];
+  };
+}>;
+/**
+* Returns a command that inserts a horizontal rule at the current selection.
+*/
+declare function insertHorizontalRule(): Command;
+declare function defineHorizontalRuleCommands(): HorizontalRuleCommandsExtension;
+//#endregion
+//#region src/horizontal-rule/horizontal-rule-spec.d.ts
+type HorizontalRuleSpecExtension = Extension<{
+  Nodes: {
+    horizontalRule: Attrs;
+  };
+}>;
+declare function defineHorizontalRuleSpec(): HorizontalRuleSpecExtension;
+
+//#endregion
+//#region src/horizontal-rule/horizontal-rule.d.ts
+type HorizontalRuleExtension = Union<[HorizontalRuleSpecExtension, HorizontalRuleCommandsExtension]>;
+/**
+* @public
+*/
+declare function defineHorizontalRule(): HorizontalRuleExtension;
+
+//#endregion
+//#region src/horizontal-rule/horizontal-rule-input-rule.d.ts
+/**
+* @public
+*/
+declare function defineHorizontalRuleInputRule(): PlainExtension;
+
+//#endregion
+export { HorizontalRuleCommandsExtension, HorizontalRuleExtension, HorizontalRuleSpecExtension, defineHorizontalRule, defineHorizontalRuleCommands, defineHorizontalRuleInputRule, defineHorizontalRuleSpec, insertHorizontalRule };

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

@@ -1,85 +1,67 @@
-import {
-  defineInputRule
-} from "./chunk-I2UMHK3L.js";
-
-// src/horizontal-rule/horizontal-rule.ts
-import {
-  union as union2
-} from "@prosekit/core";
+import { defineInputRule } from "./input-rule-Gji4N7Oe.js";
+import { defineCommands, defineNodeSpec, getNodeType, union } from "@prosekit/core";
+import { InputRule } from "@prosekit/pm/inputrules";
+import { Fragment, Slice } from "@prosekit/pm/model";
 
-// src/horizontal-rule/horizontal-rule-commands.ts
-import {
-  defineCommands,
-  getNodeType
-} from "@prosekit/core";
-import {
-  Fragment,
-  Slice
-} from "@prosekit/pm/model";
-import "@prosekit/pm/state";
+//#region src/horizontal-rule/horizontal-rule-commands.ts
+/**
+* Returns a command that inserts a horizontal rule at the current selection.
+*/
 function insertHorizontalRule() {
-  return (state, dispatch) => {
-    if (!dispatch) return true;
-    const { schema, tr } = state;
-    const type = getNodeType(schema, "horizontalRule");
-    const node = type.createChecked();
-    const pos = tr.selection.anchor;
-    tr.replaceRange(pos, pos, new Slice(Fragment.from(node), 0, 0));
-    dispatch(tr);
-    return true;
-  };
+	return (state, dispatch) => {
+		if (!dispatch) return true;
+		const { schema, tr } = state;
+		const type = getNodeType(schema, "horizontalRule");
+		const node = type.createChecked();
+		const pos = tr.selection.anchor;
+		tr.replaceRange(pos, pos, new Slice(Fragment.from(node), 0, 0));
+		dispatch(tr);
+		return true;
+	};
 }
 function defineHorizontalRuleCommands() {
-  return defineCommands({ insertHorizontalRule });
+	return defineCommands({ insertHorizontalRule });
 }
 
-// src/horizontal-rule/horizontal-rule-input-rule.ts
-import {
-  getNodeType as getNodeType2,
-  union
-} from "@prosekit/core";
-import { InputRule } from "@prosekit/pm/inputrules";
+//#endregion
+//#region src/horizontal-rule/horizontal-rule-input-rule.ts
+/**
+* @public
+*/
 function defineHorizontalRuleInputRule() {
-  return union(
-    defineInputRule(
-      new InputRule(/^---$/, (state, match, start, end) => {
-        const { schema } = state;
-        const { tr } = state;
-        const type = getNodeType2(schema, "horizontalRule");
-        const node = type.createChecked();
-        tr.delete(start, end).insert(start - 1, node);
-        return tr.scrollIntoView();
-      })
-    )
-  );
+	return union(defineInputRule(new InputRule(/^---$/, (state, match, start, end) => {
+		const { schema } = state;
+		const { tr } = state;
+		const type = getNodeType(schema, "horizontalRule");
+		const node = type.createChecked();
+		tr.delete(start, end).insert(start - 1, node);
+		return tr.scrollIntoView();
+	})));
 }
 
-// src/horizontal-rule/horizontal-rule-spec.ts
-import {
-  defineNodeSpec
-} from "@prosekit/core";
+//#endregion
+//#region src/horizontal-rule/horizontal-rule-spec.ts
 function defineHorizontalRuleSpec() {
-  return defineNodeSpec({
-    name: "horizontalRule",
-    group: "block",
-    parseDOM: [{ tag: "hr" }],
-    // Wrap the `<hr>` in a `<div>` so that we can make it taller and easier to click.
-    toDOM: () => ["div", { class: "prosekit-horizontal-rule" }, ["hr"]]
-  });
+	return defineNodeSpec({
+		name: "horizontalRule",
+		group: "block",
+		parseDOM: [{ tag: "hr" }],
+		toDOM: () => [
+			"div",
+			{ class: "prosekit-horizontal-rule" },
+			["hr"]
+		]
+	});
 }
 
-// src/horizontal-rule/horizontal-rule.ts
+//#endregion
+//#region src/horizontal-rule/horizontal-rule.ts
+/**
+* @public
+*/
 function defineHorizontalRule() {
-  return union2(
-    defineHorizontalRuleSpec(),
-    defineHorizontalRuleInputRule(),
-    defineHorizontalRuleCommands()
-  );
+	return union(defineHorizontalRuleSpec(), defineHorizontalRuleInputRule(), defineHorizontalRuleCommands());
 }
-export {
-  defineHorizontalRule,
-  defineHorizontalRuleCommands,
-  defineHorizontalRuleInputRule,
-  defineHorizontalRuleSpec,
-  insertHorizontalRule
-};
+
+//#endregion
+export { defineHorizontalRule, defineHorizontalRuleCommands, defineHorizontalRuleInputRule, defineHorizontalRuleSpec, insertHorizontalRule };

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

@@ -1,7 +1,53 @@
-export { defineImage_alias_1 as defineImage } from './_tsup-dts-rollup.js';
-export { ImageExtension_alias_1 as ImageExtension } from './_tsup-dts-rollup.js';
-export { defineImageCommands_alias_1 as defineImageCommands } from './_tsup-dts-rollup.js';
-export { ImageCommandsExtension_alias_1 as ImageCommandsExtension } from './_tsup-dts-rollup.js';
-export { defineImageSpec_alias_1 as defineImageSpec } from './_tsup-dts-rollup.js';
-export { ImageAttrs_alias_1 as ImageAttrs } from './_tsup-dts-rollup.js';
-export { ImageSpecExtension_alias_1 as ImageSpecExtension } from './_tsup-dts-rollup.js';
+import { Extension, Union } from "@prosekit/core";
+
+//#region src/image/image-spec.d.ts
+/**
+* @public
+*/
+/**
+* @public
+*/
+interface ImageAttrs {
+  src?: string | null;
+  width?: number | null;
+  height?: number | null;
+}
+/**
+* @internal
+*/
+type ImageSpecExtension = Extension<{
+  Nodes: {
+    image: ImageAttrs;
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineImageSpec(): ImageSpecExtension; //#endregion
+//#region src/image/image-commands.d.ts
+/**
+* @internal
+*/
+type ImageCommandsExtension = Extension<{
+  Commands: {
+    insertImage: [attrs?: ImageAttrs];
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineImageCommands(): ImageCommandsExtension;
+
+//#endregion
+//#region src/image/image.d.ts
+/**
+* @internal
+*/
+type ImageExtension = Union<[ImageSpecExtension, ImageCommandsExtension]>;
+/**
+* @public
+*/
+declare function defineImage(): ImageExtension;
+
+//#endregion
+export { ImageAttrs, ImageCommandsExtension, ImageExtension, ImageSpecExtension, defineImage, defineImageCommands, defineImageSpec };

package/dist/prosekit-extensions-image.js

@@ -1,71 +1,80 @@
-// src/image/image.ts
-import {
-  union
-} from "@prosekit/core";
+import { defineCommands, defineNodeSpec, insertNode, union } from "@prosekit/core";
 
-// src/image/image-commands.ts
-import {
-  defineCommands,
-  insertNode
-} from "@prosekit/core";
+//#region src/image/image-commands.ts
+/**
+* @internal
+*/
 function defineImageCommands() {
-  return defineCommands({
-    insertImage: (attrs) => {
-      return insertNode({ type: "image", attrs });
-    }
-  });
+	return defineCommands({ insertImage: (attrs) => {
+		return insertNode({
+			type: "image",
+			attrs
+		});
+	} });
 }
 
-// src/image/image-spec.ts
-import {
-  defineNodeSpec
-} from "@prosekit/core";
+//#endregion
+//#region src/image/image-spec.ts
+/**
+* @internal
+*/
 function defineImageSpec() {
-  return defineNodeSpec({
-    name: "image",
-    attrs: {
-      src: { default: null },
-      width: { default: null },
-      height: { default: null }
-    },
-    group: "block",
-    defining: true,
-    draggable: true,
-    parseDOM: [
-      {
-        tag: "img[src]",
-        getAttrs: (element) => {
-          if (typeof element === "string") {
-            return { src: null };
-          }
-          const src = element.getAttribute("src") || null;
-          let width = null;
-          let height = null;
-          const rect = element.getBoundingClientRect();
-          if (rect.width > 0 && rect.height > 0) {
-            width = rect.width;
-            height = rect.height;
-          } else if (element instanceof HTMLImageElement && element.naturalWidth > 0 && element.naturalHeight > 0) {
-            width = element.naturalWidth;
-            height = element.naturalHeight;
-          }
-          return { src, width, height };
-        }
-      }
-    ],
-    toDOM(node) {
-      const attrs = node.attrs;
-      return ["img", attrs];
-    }
-  });
+	return defineNodeSpec({
+		name: "image",
+		attrs: {
+			src: {
+				default: null,
+				validate: "string|null"
+			},
+			width: {
+				default: null,
+				validate: "number|null"
+			},
+			height: {
+				default: null,
+				validate: "number|null"
+			}
+		},
+		group: "block",
+		defining: true,
+		draggable: true,
+		parseDOM: [{
+			tag: "img[src]",
+			getAttrs: (element) => {
+				if (typeof element === "string") return { src: null };
+				const src = element.getAttribute("src") || null;
+				let width = null;
+				let height = null;
+				const rect = element.getBoundingClientRect();
+				if (rect.width > 0 && rect.height > 0) {
+					width = rect.width;
+					height = rect.height;
+				} else if (element instanceof HTMLImageElement && element.naturalWidth > 0 && element.naturalHeight > 0) {
+					width = element.naturalWidth;
+					height = element.naturalHeight;
+				}
+				return {
+					src,
+					width,
+					height
+				};
+			}
+		}],
+		toDOM(node) {
+			const attrs = node.attrs;
+			return ["img", attrs];
+		}
+	});
 }
 
-// src/image/image.ts
+//#endregion
+//#region src/image/image.ts
+/**
+* @public
+*/
 function defineImage() {
-  return union(defineImageSpec(), defineImageCommands());
+	return union(defineImageSpec(), defineImageCommands());
 }
-export {
-  defineImage,
-  defineImageCommands,
-  defineImageSpec
-};
+
+//#endregion
+export { defineImage, defineImageCommands, defineImageSpec };