@prosekit/extensions 0.8.0 → 0.9.1

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

@@ -1,8 +1,129 @@
-export { defineFileDropHandler_alias_1 as defineFileDropHandler } from './_tsup-dts-rollup.js';
-export { FileDropHandlerOptions_alias_1 as FileDropHandlerOptions } from './_tsup-dts-rollup.js';
-export { defineFilePasteHandler_alias_1 as defineFilePasteHandler } from './_tsup-dts-rollup.js';
-export { FilePasteHandlerOptions_alias_1 as FilePasteHandlerOptions } from './_tsup-dts-rollup.js';
-export { UploadTask_alias_1 as UploadTask } from './_tsup-dts-rollup.js';
-export { Uploader_alias_1 as Uploader } from './_tsup-dts-rollup.js';
-export { UploaderOptions_alias_1 as UploaderOptions } from './_tsup-dts-rollup.js';
-export { UploadProgress_alias_1 as UploadProgress } from './_tsup-dts-rollup.js';
+import { PlainExtension } from "@prosekit/core";
+import { EditorView } from "@prosekit/pm/view";
+
+//#region src/file/file-drop-handler.d.ts
+interface FileDropHandlerOptions {
+  /**
+  * The editor view.
+  */
+  view: EditorView;
+  /**
+  * The event that triggered the drop.
+  */
+  event: DragEvent;
+  /**
+  * The file that was dropped.
+  */
+  file: File;
+  /**
+  * The position of the document where the file was dropped.
+  */
+  pos: number;
+}
+/**
+* A function that handles one of the files in a drop event.
+*
+* Returns `true` if the file was handled and thus should not be handled by
+* other handlers.
+*/
+type FileDropHandler = (options: FileDropHandlerOptions) => boolean | void;
+declare function defineFileDropHandler(handler: FileDropHandler): PlainExtension;
+//#endregion
+//#region src/file/file-paste-handler.d.ts
+interface FilePasteHandlerOptions {
+  /**
+  * The editor view.
+  */
+  view: EditorView;
+  /**
+  * The event that triggered the paste.
+  */
+  event: ClipboardEvent;
+  /**
+  * The file that was pasted.
+  */
+  file: File;
+}
+/**
+* A function that handles one of the files in a paste event.
+*
+* Returns `true` if the file was handled and thus should not be handled by
+* other handlers.
+*/
+type FilePasteHandler = (options: FilePasteHandlerOptions) => boolean | void;
+declare function defineFilePasteHandler(handler: FilePasteHandler): PlainExtension;
+//#endregion
+//#region src/file/file-upload.d.ts
+/**
+* An interface representing the upload progress.
+*/
+interface UploadProgress {
+  // A number representing the amount of work already performed by the
+  // underlying process.
+  loaded: number;
+  // A number representing the total amount of work that the underlying
+  // process is in the progress of performing.
+  total: number;
+}
+interface UploaderOptions {
+  /**
+  * The file to be uploaded.
+  */
+  file: File;
+  /**
+  * A callback function that should be called with the upload progress updates.
+  */
+  onProgress: (progress: UploadProgress) => void;
+}
+/**
+* The implementation of the actual upload function. You need to implement this
+* function to upload files to your desired destination.
+*/
+type Uploader<Result> = (options: UploaderOptions) => Promise<Result>;
+/**
+* A class that represents a upload task.
+*/
+declare class UploadTask<Result> {
+  /**
+  * An [object URL](https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL)
+  * representing the file to be uploaded. This URL will be revoked once the
+  * upload is complete successfully.
+  */
+  readonly objectURL: string;
+  /**
+  * A boolean indicating whether the upload is complete (either successfully or with an error).
+  */
+  protected done: boolean;
+  /**
+  * A promise that fulfills once the upload is complete, or rejects if an error occurs.
+  */
+  readonly finished: Promise<Result>;
+  private subscribers;
+  /**
+  * Creates a new upload task. You can find the upload task by its object URL
+  * later using `UploadTask.get()`.
+  *
+  * @param options - The options for the upload task.
+  */
+  constructor({
+    file,
+    uploader
+  }: {
+    file: File;
+    uploader: Uploader<Result>;
+  });
+  /**
+  * Subscribes to progress updates. Returns a function to unsubscribe.
+  */
+  subscribeProgress(callback: (progress: UploadProgress) => void): VoidFunction;
+  /**
+  * Finds an upload task by its object URL.
+  */
+  static get<Result = unknown>(objectURL: string): UploadTask<Result> | undefined;
+  /**
+  * Deletes an upload task by its object URL.
+  */
+  static delete(objectURL: string): void;
+}
+//#endregion
+export { FileDropHandlerOptions, FilePasteHandlerOptions, UploadProgress, UploadTask, Uploader, UploaderOptions, defineFileDropHandler, defineFilePasteHandler };

package/dist/prosekit-extensions-file.js

@@ -1,149 +1,141 @@
-// src/file/file-drop-handler.ts
-import {
-  defineFacet,
-  defineFacetPayload,
-  editorEventFacet
-} from "@prosekit/core";
+import { defineFacet, defineFacetPayload, editorEventFacet } from "@prosekit/core";
 
-// src/file/helpers.ts
+//#region src/file/helpers.ts
 function handleFile(view, event, file, handlers) {
-  for (let i = handlers.length - 1; i >= 0; i--) {
-    const handler = handlers[i];
-    if (handler({ view, event, file })) {
-      return true;
-    }
-  }
-  return false;
+	for (let i = handlers.length - 1; i >= 0; i--) {
+		const handler = handlers[i];
+		if (handler({
+			view,
+			event,
+			file
+		})) return true;
+	}
+	return false;
 }
-function handleEvent(view, event, handlers, getFiles3) {
-  const files = getFiles3(event);
-  let handled = false;
-  for (const file of files) {
-    if (handleFile(view, event, file, handlers)) {
-      handled = true;
-    }
-  }
-  return handled;
+function handleEvent(view, event, handlers, getFiles$2) {
+	const files = getFiles$2(event);
+	let handled = false;
+	for (const file of files) if (handleFile(view, event, file, handlers)) handled = true;
+	return handled;
 }
 
-// src/file/file-drop-handler.ts
+//#endregion
+//#region src/file/file-drop-handler.ts
 function defineFileDropHandler(handler) {
-  return defineFacetPayload(facet, [handler]);
+	return defineFacetPayload(facet$1, [handler]);
 }
-function getFiles(event) {
-  return Array.from(event.dataTransfer?.files ?? []);
+function getFiles$1(event) {
+	return Array.from(event.dataTransfer?.files ?? []);
 }
-var facet = defineFacet({
-  parent: editorEventFacet,
-  singleton: true,
-  reducer: (handlers) => {
-    const dropHandler = (view, event) => {
-      const position = view.posAtCoords({ left: event.x, top: event.y });
-      if (!position) {
-        return false;
-      }
-      const pos = position.inside > 0 ? position.inside : position.pos;
-      return handleEvent(
-        view,
-        event,
-        handlers.map((handler) => (options) => handler({ ...options, pos })),
-        getFiles
-      );
-    };
-    return ["drop", dropHandler];
-  }
+const facet$1 = defineFacet({
+	parent: editorEventFacet,
+	singleton: true,
+	reducer: (handlers) => {
+		const dropHandler = (view, event) => {
+			const position = view.posAtCoords({
+				left: event.x,
+				top: event.y
+			});
+			if (!position) return false;
+			const pos = position.inside > 0 ? position.inside : position.pos;
+			return handleEvent(view, event, handlers.map((handler) => (options) => handler({
+				...options,
+				pos
+			})), getFiles$1);
+		};
+		return ["drop", dropHandler];
+	}
 });
 
-// src/file/file-paste-handler.ts
-import {
-  defineFacet as defineFacet2,
-  defineFacetPayload as defineFacetPayload2,
-  editorEventFacet as editorEventFacet2
-} from "@prosekit/core";
+//#endregion
+//#region src/file/file-paste-handler.ts
 function defineFilePasteHandler(handler) {
-  return defineFacetPayload2(facet2, [handler]);
+	return defineFacetPayload(facet, [handler]);
 }
-function getFiles2(event) {
-  return Array.from(event.clipboardData?.files ?? []);
+function getFiles(event) {
+	return Array.from(event.clipboardData?.files ?? []);
 }
-var facet2 = defineFacet2({
-  parent: editorEventFacet2,
-  singleton: true,
-  reducer: (handlers) => {
-    const pasteHandler = (view, event) => {
-      return handleEvent(view, event, handlers, getFiles2);
-    };
-    return ["paste", pasteHandler];
-  }
+const facet = defineFacet({
+	parent: editorEventFacet,
+	singleton: true,
+	reducer: (handlers) => {
+		const pasteHandler = (view, event) => {
+			return handleEvent(view, event, handlers, getFiles);
+		};
+		return ["paste", pasteHandler];
+	}
 });
 
-// src/file/file-upload.ts
+//#endregion
+//#region src/file/file-upload.ts
+/**
+* A class that represents a upload task.
+*/
 var UploadTask = class {
-  /**
-   * Creates a new upload task. You can find the upload task by its object URL
-   * later using `UploadTask.get()`.
-   *
-   * @param options - The options for the upload task.
-   */
-  constructor({ file, uploader }) {
-    /**
-     * A boolean indicating whether the upload is complete (either successfully or with an error).
-     */
-    this.done = false;
-    this.subscribers = [];
-    this.objectURL = URL.createObjectURL(file);
-    this.finished = new Promise((resolve, reject) => {
-      const maybePromise = uploader({
-        file,
-        onProgress: (progress) => {
-          for (const subscriber of this.subscribers) {
-            subscriber(progress);
-          }
-        }
-      });
-      Promise.resolve(maybePromise).then(
-        (result) => {
-          this.done = true;
-          URL.revokeObjectURL(this.objectURL);
-          resolve(result);
-        },
-        (error) => {
-          this.done = true;
-          reject(
-            new Error("[prosekit] Failed to upload file", { cause: error })
-          );
-        }
-      );
-    });
-    store.set(this.objectURL, this);
-  }
-  /**
-   * Subscribes to progress updates. Returns a function to unsubscribe.
-   */
-  subscribeProgress(callback) {
-    this.subscribers.push(callback);
-    return () => {
-      this.subscribers = this.subscribers.filter(
-        (subscriber) => subscriber !== callback
-      );
-    };
-  }
-  /**
-   * Finds an upload task by its object URL.
-   */
-  static get(objectURL) {
-    return store.get(objectURL);
-  }
-  /**
-   * Deletes an upload task by its object URL.
-   */
-  static delete(objectURL) {
-    store.delete(objectURL);
-  }
-};
-var store = /* @__PURE__ */ new Map();
-export {
-  UploadTask,
-  defineFileDropHandler,
-  defineFilePasteHandler
+	/**
+	* An [object URL](https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL)
+	* representing the file to be uploaded. This URL will be revoked once the
+	* upload is complete successfully.
+	*/
+	objectURL;
+	/**
+	* A boolean indicating whether the upload is complete (either successfully or with an error).
+	*/
+	done = false;
+	/**
+	* A promise that fulfills once the upload is complete, or rejects if an error occurs.
+	*/
+	finished;
+	subscribers = [];
+	/**
+	* Creates a new upload task. You can find the upload task by its object URL
+	* later using `UploadTask.get()`.
+	*
+	* @param options - The options for the upload task.
+	*/
+	constructor({ file, uploader }) {
+		this.objectURL = URL.createObjectURL(file);
+		this.finished = new Promise((resolve, reject) => {
+			const maybePromise = uploader({
+				file,
+				onProgress: (progress) => {
+					for (const subscriber of this.subscribers) subscriber(progress);
+				}
+			});
+			Promise.resolve(maybePromise).then((result) => {
+				this.done = true;
+				URL.revokeObjectURL(this.objectURL);
+				resolve(result);
+			}, (error) => {
+				this.done = true;
+				reject(new Error("[prosekit] Failed to upload file", { cause: error }));
+			});
+		});
+		store.set(this.objectURL, this);
+	}
+	/**
+	* Subscribes to progress updates. Returns a function to unsubscribe.
+	*/
+	subscribeProgress(callback) {
+		this.subscribers.push(callback);
+		return () => {
+			this.subscribers = this.subscribers.filter((subscriber) => subscriber !== callback);
+		};
+	}
+	/**
+	* Finds an upload task by its object URL.
+	*/
+	static get(objectURL) {
+		return store.get(objectURL);
+	}
+	/**
+	* Deletes an upload task by its object URL.
+	*/
+	static delete(objectURL) {
+		store.delete(objectURL);
+	}
 };
+const store = new Map();
+
+//#endregion
+export { UploadTask, defineFileDropHandler, defineFilePasteHandler };

package/dist/prosekit-extensions-gap-cursor.d.ts

@@ -1,2 +1,26 @@
-export { defineGapCursor_alias_1 as defineGapCursor } from './_tsup-dts-rollup.js';
-export { GapCursorExtension_alias_1 as GapCursorExtension } from './_tsup-dts-rollup.js';
+import { PlainExtension } from "@prosekit/core";
+import "prosemirror-gapcursor";
+
+//#region src/gap-cursor/gap-cursor.d.ts
+
+/**
+* @internal
+*/
+type GapCursorExtension = PlainExtension;
+/**
+* Capture clicks near and arrow-key-motion past places that don't have a
+* normally selectable position nearby, and create a gap cursor selection for
+* them. The cursor is drawn as an element with class `ProseMirror-gapcursor`.
+*
+* You can either include `prosekit/extensions/gap-cursor.css` or add your own
+* styles to make it visible.
+*
+* See
+* [prosemirror-gapcursor](https://github.com/ProseMirror/prosemirror-gapcursor)
+* for more information.
+*
+* @public
+*/
+declare function defineGapCursor(): GapCursorExtension;
+//#endregion
+export { GapCursorExtension, defineGapCursor };

package/dist/prosekit-extensions-gap-cursor.js

@@ -1,12 +1,24 @@
-// src/gap-cursor/gap-cursor.ts
-import {
-  definePlugin
-} from "@prosekit/core";
+import { definePlugin } from "@prosekit/core";
 import { gapCursor } from "prosemirror-gapcursor";
-import { GapCursor } from "prosemirror-gapcursor";
+
+//#region src/gap-cursor/gap-cursor.ts
+/**
+* Capture clicks near and arrow-key-motion past places that don't have a
+* normally selectable position nearby, and create a gap cursor selection for
+* them. The cursor is drawn as an element with class `ProseMirror-gapcursor`.
+*
+* You can either include `prosekit/extensions/gap-cursor.css` or add your own
+* styles to make it visible.
+*
+* See
+* [prosemirror-gapcursor](https://github.com/ProseMirror/prosemirror-gapcursor)
+* for more information.
+*
+* @public
+*/
 function defineGapCursor() {
-  return definePlugin(() => gapCursor());
+	return definePlugin(() => gapCursor());
 }
-export {
-  defineGapCursor
-};
+
+//#endregion
+export { defineGapCursor };

package/dist/prosekit-extensions-hard-break.d.ts

@@ -0,0 +1,53 @@
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+import { Command } from "@prosekit/pm/state";
+import { Attrs } from "@prosekit/pm/model";
+
+//#region src/hard-break/hard-break-commands.d.ts
+/**
+* @internal
+*/
+type HardBreakCommandsExtension = Extension<{
+  Commands: {
+    insertHardBreak: [];
+  };
+}>;
+/**
+* @internal
+*/
+
+/**
+* @internal
+*/
+declare function defineHardBreakCommands(): HardBreakCommandsExtension;
+//#endregion
+//#region src/hard-break/hard-break-spec.d.ts
+/**
+* @internal
+*/
+type HardBreakSpecExtension = Extension<{
+  Nodes: {
+    hardBreak: Attrs;
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineHardBreakSpec(): HardBreakSpecExtension;
+//#endregion
+//#region src/hard-break/hard-break.d.ts
+/**
+* @internal
+*/
+type HardBreakExtension = Union<[HardBreakSpecExtension, HardBreakCommandsExtension]>;
+/**
+* @public
+*/
+declare function defineHardBreak(): HardBreakExtension;
+//#endregion
+//#region src/hard-break/hard-break-keymap.d.ts
+/**
+* @internal
+*/
+declare function defineHardBreakKeymap(): PlainExtension;
+//#endregion
+export { HardBreakCommandsExtension, HardBreakExtension, HardBreakSpecExtension, defineHardBreak, defineHardBreakCommands, defineHardBreakKeymap, defineHardBreakSpec };

package/dist/prosekit-extensions-hard-break.js

@@ -0,0 +1,58 @@
+import { defineCommands, defineKeymap, defineNodeSpec, insertNode, union } from "@prosekit/core";
+
+//#region src/hard-break/hard-break-commands.ts
+/**
+* @internal
+*/
+function insertHardBreak() {
+	return insertNode({ type: "hardBreak" });
+}
+/**
+* @internal
+*/
+function defineHardBreakCommands() {
+	return defineCommands({ insertHardBreak });
+}
+
+//#endregion
+//#region src/hard-break/hard-break-keymap.ts
+/**
+* @internal
+*/
+function defineHardBreakKeymap() {
+	return defineKeymap({
+		"Mod-Enter": insertHardBreak(),
+		"Shift-Enter": insertHardBreak()
+	});
+}
+
+//#endregion
+//#region src/hard-break/hard-break-spec.ts
+/**
+* @internal
+*/
+function defineHardBreakSpec() {
+	return defineNodeSpec({
+		name: "hardBreak",
+		inline: true,
+		selectable: false,
+		leafText: () => "\n",
+		group: "inline",
+		parseDOM: [{ tag: "br" }],
+		toDOM() {
+			return ["br"];
+		}
+	});
+}
+
+//#endregion
+//#region src/hard-break/hard-break.ts
+/**
+* @public
+*/
+function defineHardBreak() {
+	return union(defineHardBreakSpec(), defineHardBreakKeymap(), defineHardBreakCommands());
+}
+
+//#endregion
+export { defineHardBreak, defineHardBreakCommands, defineHardBreakKeymap, defineHardBreakSpec };

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

@@ -1,9 +1,63 @@
-export { defineHeading_alias_1 as defineHeading } from './_tsup-dts-rollup.js';
-export { HeadingExtension_alias_1 as HeadingExtension } from './_tsup-dts-rollup.js';
-export { defineHeadingCommands_alias_1 as defineHeadingCommands } from './_tsup-dts-rollup.js';
-export { HeadingCommandsExtension_alias_1 as HeadingCommandsExtension } from './_tsup-dts-rollup.js';
-export { defineHeadingInputRule_alias_1 as defineHeadingInputRule } from './_tsup-dts-rollup.js';
-export { defineHeadingKeymap_alias_1 as defineHeadingKeymap } from './_tsup-dts-rollup.js';
-export { defineHeadingSpec_alias_1 as defineHeadingSpec } from './_tsup-dts-rollup.js';
-export { HeadingSpecExtension_alias_1 as HeadingSpecExtension } from './_tsup-dts-rollup.js';
-export { HeadingAttrs_alias_1 as HeadingAttrs } from './_tsup-dts-rollup.js';
+import { Extension, PlainExtension, Union } from "@prosekit/core";
+
+//#region src/heading/heading-types.d.ts
+interface HeadingAttrs {
+  level: number;
+}
+//#endregion
+//#region src/heading/heading-commands.d.ts
+/**
+* @internal
+*/
+type HeadingCommandsExtension = Extension<{
+  Commands: {
+    setHeading: [attrs?: HeadingAttrs | undefined];
+    insertHeading: [attrs?: HeadingAttrs | undefined];
+    toggleHeading: [attrs?: HeadingAttrs | undefined];
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineHeadingCommands(): HeadingCommandsExtension;
+//#endregion
+//#region src/heading/heading-spec.d.ts
+/**
+* @internal
+*/
+type HeadingSpecExtension = Extension<{
+  Nodes: {
+    heading: HeadingAttrs;
+  };
+}>;
+/**
+* @internal
+*/
+declare function defineHeadingSpec(): HeadingSpecExtension;
+//#endregion
+//#region src/heading/heading.d.ts
+/**
+* @internal
+*/
+type HeadingExtension = Union<[HeadingSpecExtension, HeadingCommandsExtension]>;
+/**
+* @public
+*/
+declare function defineHeading(): HeadingExtension;
+//#endregion
+//#region src/heading/heading-input-rule.d.ts
+/**
+* Converts the text block to a heading when `#` is typed at the start of a new
+* line followed by a space.
+*
+* @internal
+*/
+declare function defineHeadingInputRule(): PlainExtension;
+//#endregion
+//#region src/heading/heading-keymap.d.ts
+/**
+* @internal
+*/
+declare function defineHeadingKeymap(): PlainExtension;
+//#endregion
+export { HeadingAttrs, HeadingCommandsExtension, HeadingExtension, HeadingSpecExtension, defineHeading, defineHeadingCommands, defineHeadingInputRule, defineHeadingKeymap, defineHeadingSpec };