@prosekit/extensions 0.8.0 → 0.9.1

package/dist/prosekit-extensions-text-align.d.ts

@@ -1,8 +1,71 @@
-export { setTextAlign } from './_tsup-dts-rollup.js';
-export { defineTextAlignCommands } from './_tsup-dts-rollup.js';
-export { defineTextAlignKeymap } from './_tsup-dts-rollup.js';
-export { defineTextAlign } from './_tsup-dts-rollup.js';
-export { TextAlignOptions } from './_tsup-dts-rollup.js';
-export { TextAlignAttrsExtension } from './_tsup-dts-rollup.js';
-export { TextAlignCommandsExtension } from './_tsup-dts-rollup.js';
-export { TextAlignExtension } from './_tsup-dts-rollup.js';
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+import { Command } from "@prosekit/pm/state";
+
+//#region src/text-align/index.d.ts
+
+/**
+* @public
+*/
+interface TextAlignOptions<NodeName extends string = string> {
+  /**
+  * The names of node to add the attribute to.
+  *
+  * @example
+  *
+  * ["paragraph", "heading"]
+  */
+  types: NodeName[];
+  /**
+  * The default value for the attribute.
+  *
+  * @default "left"
+  */
+  default?: string;
+}
+/**
+* @internal
+*/
+type TextAlignAttrsExtension<NodeName extends string> = Extension<{
+  Nodes: { [K in NodeName]: {
+    textAlign: string | null;
+  } };
+}>;
+/**
+* @internal
+*/
+declare function setTextAlign({
+  types,
+  value
+}: {
+  types: string[];
+  value: string | null;
+}): Command;
+/**
+* @internal
+*/
+type TextAlignCommandsExtension = Extension<{
+  Commands: {
+    setTextAlign: [value: string | null];
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineTextAlignCommands(types: string[]): TextAlignCommandsExtension;
+/**
+* @internal
+*/
+declare function defineTextAlignKeymap(types: string[]): PlainExtension;
+/**
+* @internal
+*/
+type TextAlignExtension<NodeName extends string> = Union<[TextAlignAttrsExtension<NodeName>, TextAlignCommandsExtension]>;
+/**
+* Adds a `textAlign` attribute to the specified nodes. This will be rendered as
+* a CSS `text-align` style.
+*
+* @public
+*/
+declare function defineTextAlign<NodeName extends string = string>(options: TextAlignOptions<NodeName>): TextAlignExtension<NodeName>;
+//#endregion
+export { TextAlignAttrsExtension, TextAlignCommandsExtension, TextAlignExtension, TextAlignOptions, defineTextAlign, defineTextAlignCommands, defineTextAlignKeymap, setTextAlign };

package/dist/prosekit-extensions-text-align.js

@@ -1,55 +1,74 @@
-// src/text-align/index.ts
-import {
-  defineCommands,
-  defineKeymap,
-  defineNodeAttr,
-  setNodeAttrs,
-  union
-} from "@prosekit/core";
+import { defineCommands, defineKeymap, defineNodeAttr, setNodeAttrs, union } from "@prosekit/core";
+
+//#region src/text-align/index.ts
 function defineTextAlignAttr(type, defaultValue) {
-  return defineNodeAttr({
-    type,
-    attr: "textAlign",
-    default: defaultValue,
-    splittable: true,
-    toDOM: (value) => value ? ["style", `text-align:${value};`] : null,
-    parseDOM: (node) => {
-      return node.style.getPropertyValue("text-align") || null;
-    }
-  });
+	return defineNodeAttr({
+		type,
+		attr: "textAlign",
+		default: defaultValue,
+		splittable: true,
+		toDOM: (value) => value ? ["style", `text-align:${value};`] : null,
+		parseDOM: (node) => {
+			return node.style.getPropertyValue("text-align") || null;
+		}
+	});
 }
+/**
+* @internal
+*/
 function defineTextAlignAttrs(types, defaultValue) {
-  return union(types.map((type) => defineTextAlignAttr(type, defaultValue)));
+	return union(types.map((type) => defineTextAlignAttr(type, defaultValue)));
 }
-function setTextAlign({
-  types,
-  value
-}) {
-  return setNodeAttrs({ type: types, attrs: { textAlign: value } });
+/**
+* @internal
+*/
+function setTextAlign({ types, value }) {
+	return setNodeAttrs({
+		type: types,
+		attrs: { textAlign: value }
+	});
 }
+/**
+* @internal
+*/
 function defineTextAlignCommands(types) {
-  return defineCommands({
-    setTextAlign: (value) => setTextAlign({ types, value })
-  });
+	return defineCommands({ setTextAlign: (value) => setTextAlign({
+		types,
+		value
+	}) });
 }
+/**
+* @internal
+*/
 function defineTextAlignKeymap(types) {
-  return defineKeymap({
-    "mod-shift-l": setTextAlign({ types, value: "left" }),
-    "mod-shift-e": setTextAlign({ types, value: "center" }),
-    "mod-shift-r": setTextAlign({ types, value: "right" }),
-    "mod-shift-j": setTextAlign({ types, value: "justify" })
-  });
+	return defineKeymap({
+		"mod-shift-l": setTextAlign({
+			types,
+			value: "left"
+		}),
+		"mod-shift-e": setTextAlign({
+			types,
+			value: "center"
+		}),
+		"mod-shift-r": setTextAlign({
+			types,
+			value: "right"
+		}),
+		"mod-shift-j": setTextAlign({
+			types,
+			value: "justify"
+		})
+	});
 }
+/**
+* Adds a `textAlign` attribute to the specified nodes. This will be rendered as
+* a CSS `text-align` style.
+*
+* @public
+*/
 function defineTextAlign(options) {
-  return union(
-    defineTextAlignAttrs(options.types, options.default || "left"),
-    defineTextAlignKeymap(options.types),
-    defineTextAlignCommands(options.types)
-  );
+	return union(defineTextAlignAttrs(options.types, options.default || "left"), defineTextAlignKeymap(options.types), defineTextAlignCommands(options.types));
 }
-export {
-  defineTextAlign,
-  defineTextAlignCommands,
-  defineTextAlignKeymap,
-  setTextAlign
-};
+
+//#endregion
+export { defineTextAlign, defineTextAlignCommands, defineTextAlignKeymap, setTextAlign };

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

@@ -1,2 +1,19 @@
-export { defineText } from './_tsup-dts-rollup.js';
-export { TextExtension } from './_tsup-dts-rollup.js';
+import { Extension } from "@prosekit/core";
+import { Attrs } from "@prosekit/pm/model";
+
+//#region src/text/index.d.ts
+
+/**
+* @internal
+*/
+type TextExtension = Extension<{
+  Nodes: {
+    text: Attrs;
+  };
+}>;
+/**
+* @public
+*/
+declare function defineText(): TextExtension;
+//#endregion
+export { TextExtension, defineText };

package/dist/prosekit-extensions-text.js

@@ -1,13 +1,15 @@
-// src/text/index.ts
-import {
-  defineNodeSpec
-} from "@prosekit/core";
+import { defineNodeSpec } from "@prosekit/core";
+
+//#region src/text/index.ts
+/**
+* @public
+*/
 function defineText() {
-  return defineNodeSpec({
-    name: "text",
-    group: "inline"
-  });
+	return defineNodeSpec({
+		name: "text",
+		group: "inline"
+	});
 }
-export {
-  defineText
-};
+
+//#endregion
+export { defineText };

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

@@ -1,7 +1,43 @@
-export { defineUnderlineSpec } from './_tsup-dts-rollup.js';
-export { defineUnderlineCommands } from './_tsup-dts-rollup.js';
-export { defineUnderlineKeymap } from './_tsup-dts-rollup.js';
-export { defineUnderline } from './_tsup-dts-rollup.js';
-export { UnderlineSpecExtension } from './_tsup-dts-rollup.js';
-export { UnderlineCommandsExtension } from './_tsup-dts-rollup.js';
-export { UnderlineExtension } from './_tsup-dts-rollup.js';
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+import { Attrs } from "@prosekit/pm/model";
+
+//#region src/underline/index.d.ts
+
+/**
+* @internal
+*/
+type UnderlineSpecExtension = Extension<{
+  Marks: {
+    underline: Attrs;
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineUnderlineSpec(): UnderlineSpecExtension;
+/**
+* @internal
+*/
+type UnderlineCommandsExtension = Extension<{
+  Commands: {
+    toggleUnderline: [];
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineUnderlineCommands(): UnderlineCommandsExtension;
+/**
+* @internal
+*/
+declare function defineUnderlineKeymap(): PlainExtension;
+/**
+* @internal
+*/
+type UnderlineExtension = Union<[UnderlineSpecExtension, UnderlineCommandsExtension]>;
+/**
+* @public
+*/
+declare function defineUnderline(): UnderlineExtension;
+//#endregion
+export { UnderlineCommandsExtension, UnderlineExtension, UnderlineSpecExtension, defineUnderline, defineUnderlineCommands, defineUnderlineKeymap, defineUnderlineSpec };

package/dist/prosekit-extensions-underline.js

@@ -1,45 +1,41 @@
-// src/underline/index.ts
-import {
-  defineCommands,
-  defineKeymap,
-  defineMarkSpec,
-  toggleMark,
-  union
-} from "@prosekit/core";
+import { defineCommands, defineKeymap, defineMarkSpec, toggleMark, union } from "@prosekit/core";
+
+//#region src/underline/index.ts
+/**
+* @internal
+*/
 function defineUnderlineSpec() {
-  return defineMarkSpec({
-    name: "underline",
-    parseDOM: [
-      { tag: "u" },
-      { tag: "underline" },
-      { style: "text-decoration=underline" },
-      { style: "text-decoration-line=underline" }
-    ],
-    toDOM() {
-      return ["u", 0];
-    }
-  });
+	return defineMarkSpec({
+		name: "underline",
+		parseDOM: [
+			{ tag: "u" },
+			{ tag: "underline" },
+			{ style: "text-decoration=underline" },
+			{ style: "text-decoration-line=underline" }
+		],
+		toDOM() {
+			return ["u", 0];
+		}
+	});
 }
+/**
+* @internal
+*/
 function defineUnderlineCommands() {
-  return defineCommands({
-    toggleUnderline: () => toggleMark({ type: "underline" })
-  });
+	return defineCommands({ toggleUnderline: () => toggleMark({ type: "underline" }) });
 }
+/**
+* @internal
+*/
 function defineUnderlineKeymap() {
-  return defineKeymap({
-    "Mod-u": toggleMark({ type: "underline" })
-  });
+	return defineKeymap({ "Mod-u": toggleMark({ type: "underline" }) });
 }
+/**
+* @public
+*/
 function defineUnderline() {
-  return union(
-    defineUnderlineSpec(),
-    defineUnderlineCommands(),
-    defineUnderlineKeymap()
-  );
+	return union(defineUnderlineSpec(), defineUnderlineCommands(), defineUnderlineKeymap());
 }
-export {
-  defineUnderline,
-  defineUnderlineCommands,
-  defineUnderlineKeymap,
-  defineUnderlineSpec
-};
+
+//#endregion
+export { defineUnderline, defineUnderlineCommands, defineUnderlineKeymap, defineUnderlineSpec };

package/dist/prosekit-extensions-virtual-selection.d.ts

@@ -1,2 +1,21 @@
-export { defineVirtualSelection } from './_tsup-dts-rollup.js';
-export { VirtualSelectionExtension } from './_tsup-dts-rollup.js';
+import { PlainExtension } from "@prosekit/core";
+
+//#region src/virtual-selection/index.d.ts
+
+/**
+* @internal
+*/
+type VirtualSelectionExtension = PlainExtension;
+/**
+* Shows a virtual selection when the editor is not focused. When the editor is
+* not focused, the selected inline content will be wrapped in a `<span>`
+* element with the class `prosekit-virtual-selection`.
+*
+* This is useful when you want to move the focus to an element outside the
+* editor, but still want to show the selection.
+*
+* @public
+*/
+declare function defineVirtualSelection(): VirtualSelectionExtension;
+//#endregion
+export { VirtualSelectionExtension, defineVirtualSelection };

package/dist/prosekit-extensions-virtual-selection.js

@@ -1,61 +1,58 @@
-// src/virtual-selection/index.ts
-import {
-  definePlugin
-} from "@prosekit/core";
-import {
-  PluginKey,
-  ProseMirrorPlugin
-} from "@prosekit/pm/state";
-import {
-  Decoration,
-  DecorationSet
-} from "@prosekit/pm/view";
+import { definePlugin } from "@prosekit/core";
+import { PluginKey, ProseMirrorPlugin } from "@prosekit/pm/state";
+import { Decoration, DecorationSet } from "@prosekit/pm/view";
+
+//#region src/virtual-selection/index.ts
+/**
+* Shows a virtual selection when the editor is not focused. When the editor is
+* not focused, the selected inline content will be wrapped in a `<span>`
+* element with the class `prosekit-virtual-selection`.
+*
+* This is useful when you want to move the focus to an element outside the
+* editor, but still want to show the selection.
+*
+* @public
+*/
 function defineVirtualSelection() {
-  return definePlugin(virtualSelectionPlugin);
+	return definePlugin(virtualSelectionPlugin);
 }
-var key = new PluginKey("prosekit-virtual-selection");
+const key = new PluginKey("prosekit-virtual-selection");
 function getFocusMeta(tr) {
-  return tr.getMeta(key);
+	return tr.getMeta(key);
 }
 function setFocusMeta(tr, value) {
-  return tr.setMeta(key, value);
+	return tr.setMeta(key, value);
 }
 function getFocusState(state) {
-  return key.getState(state);
+	return key.getState(state);
 }
-var virtualSelectionPlugin = new ProseMirrorPlugin({
-  key,
-  state: {
-    init: () => false,
-    apply: (tr, value) => {
-      return getFocusMeta(tr) ?? value;
-    }
-  },
-  props: {
-    handleDOMEvents: {
-      focus: (view) => {
-        view.dispatch(setFocusMeta(view.state.tr, false));
-      },
-      blur: (view) => {
-        const { dom, root } = view;
-        const activeElement = root.activeElement;
-        if (activeElement === dom) return;
-        view.dispatch(setFocusMeta(view.state.tr, true));
-      }
-    },
-    decorations: (state) => {
-      const { selection, doc } = state;
-      if (selection.empty || !getFocusState(state)) {
-        return null;
-      }
-      return DecorationSet.create(doc, [
-        Decoration.inline(selection.from, selection.to, {
-          class: "prosekit-virtual-selection"
-        })
-      ]);
-    }
-  }
+const virtualSelectionPlugin = new ProseMirrorPlugin({
+	key,
+	state: {
+		init: () => false,
+		apply: (tr, value) => {
+			return getFocusMeta(tr) ?? value;
+		}
+	},
+	props: {
+		handleDOMEvents: {
+			focus: (view) => {
+				view.dispatch(setFocusMeta(view.state.tr, false));
+			},
+			blur: (view) => {
+				const { dom, root } = view;
+				const activeElement = root.activeElement;
+				if (activeElement === dom) return;
+				view.dispatch(setFocusMeta(view.state.tr, true));
+			}
+		},
+		decorations: (state) => {
+			const { selection, doc } = state;
+			if (selection.empty || !getFocusState(state)) return null;
+			return DecorationSet.create(doc, [Decoration.inline(selection.from, selection.to, { class: "prosekit-virtual-selection" })]);
+		}
+	}
 });
-export {
-  defineVirtualSelection
-};
+
+//#endregion
+export { defineVirtualSelection };

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

@@ -1,14 +1,90 @@
-export { defineYjs } from './_tsup-dts-rollup.js';
-export { YjsExtension } from './_tsup-dts-rollup.js';
-export { YjsOptions } from './_tsup-dts-rollup.js';
-export { defineYjsCommands } from './_tsup-dts-rollup.js';
-export { defineYjsCursorPlugin } from './_tsup-dts-rollup.js';
-export { YjsCursorOptions } from './_tsup-dts-rollup.js';
-export { YjsCursorPluginOptions } from './_tsup-dts-rollup.js';
-export { defineYjsKeymap } from './_tsup-dts-rollup.js';
-export { defineYjsSyncPlugin } from './_tsup-dts-rollup.js';
-export { YjsSyncOptions } from './_tsup-dts-rollup.js';
-export { YjsSyncPluginOptions } from './_tsup-dts-rollup.js';
-export { defineYjsUndoPlugin } from './_tsup-dts-rollup.js';
-export { YjsUndoOptions } from './_tsup-dts-rollup.js';
-export { YjsUndoPluginOptions } from './_tsup-dts-rollup.js';
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+import { yCursorPlugin, ySyncPlugin, yUndoPlugin } from "y-prosemirror";
+import { Awareness } from "y-protocols/awareness";
+import * as Y$1 from "yjs";
+import * as Y from "yjs";
+
+//#region src/yjs/yjs-commands.d.ts
+/**
+* @internal
+*/
+type YjsCommandsExtension = Extension<{
+  Commands: {
+    undo: [];
+    redo: [];
+  };
+}>;
+declare function defineYjsCommands(): YjsCommandsExtension;
+//#endregion
+//#region src/yjs/yjs-cursor-plugin.d.ts
+/**
+* Options for `y-prosemirror`'s `yCursorPlugin`.
+*/
+type YjsCursorPluginOptions = NonNullable<Parameters<typeof yCursorPlugin>[1]>;
+interface YjsCursorOptions extends YjsCursorPluginOptions {
+  awareness: Awareness;
+}
+declare function defineYjsCursorPlugin(options: YjsCursorOptions): PlainExtension;
+//#endregion
+//#region src/yjs/yjs-sync-plugin.d.ts
+/**
+* Options for `y-prosemirror`'s `ySyncPlugin`.
+*/
+type YjsSyncPluginOptions = NonNullable<Parameters<typeof ySyncPlugin>[1]>;
+interface YjsSyncOptions extends YjsSyncPluginOptions {
+  fragment: Y$1.XmlFragment;
+}
+declare function defineYjsSyncPlugin(options: YjsSyncOptions): PlainExtension;
+//#endregion
+//#region src/yjs/yjs-undo-plugin.d.ts
+/**
+* Options for the `y-prosemirror`'s `yUndoPlugin`.
+*/
+type YjsUndoPluginOptions = NonNullable<Parameters<typeof yUndoPlugin>[0]>;
+interface YjsUndoOptions extends YjsUndoPluginOptions {}
+/**
+* @internal
+*/
+declare function defineYjsUndoPlugin(options: YjsUndoOptions): PlainExtension;
+//#endregion
+//#region src/yjs/yjs.d.ts
+interface YjsOptions {
+  /**
+  * The Yjs instance handles the state of shared data.
+  */
+  doc: Y.Doc;
+  /**
+  * The Awareness instance.
+  */
+  awareness: Awareness;
+  /**
+  * The Yjs XmlFragment to use. If not provided,
+  * `doc.getXmlFragment('prosemirror')` will be used.
+  */
+  fragment?: Y.XmlFragment;
+  /**
+  * Options for `y-prosemirror`'s `ySyncPlugin`.
+  */
+  sync?: YjsSyncPluginOptions;
+  /**
+  * Options for the `y-prosemirror`'s `yUndoPlugin`.
+  */
+  undo?: YjsUndoPluginOptions;
+  /**
+  * Options for `y-prosemirror`'s `yCursorPlugin`.
+  */
+  cursor?: YjsCursorPluginOptions;
+}
+/**
+* @internal
+*/
+type YjsExtension = Union<[YjsCommandsExtension, PlainExtension]>;
+/**
+* @public
+*/
+declare function defineYjs(options: YjsOptions): YjsExtension;
+//#endregion
+//#region src/yjs/yjs-keymap.d.ts
+declare function defineYjsKeymap(): PlainExtension;
+//#endregion
+export { YjsCursorOptions, YjsCursorPluginOptions, YjsExtension, YjsOptions, YjsSyncOptions, YjsSyncPluginOptions, YjsUndoOptions, YjsUndoPluginOptions, defineYjs, defineYjsCommands, defineYjsCursorPlugin, defineYjsKeymap, defineYjsSyncPlugin, defineYjsUndoPlugin };