@witchcraft/editor 0.0.1

package/dist/runtime/pm/features/FileLoader/FileLoaderHandler/TestFileLoaderHandler.js

@@ -0,0 +1,49 @@
+import { delay } from "@alanscodelog/utils/delay";
+import mime from "mime/lite";
+import { FileLoaderHandler } from "./FileLoaderHandler.js";
+import { findLoadingNodePos } from "../utils/findLoadingNodePos.js";
+import { readAsDataUrl } from "../utils/readAsDataUrl.js";
+export const testFileLoaderDelay = 2e3;
+export const TestFileLoaderHandler = new FileLoaderHandler({
+  filterFile: (file) => {
+    const mimeExtension = mime.getExtension(file.type);
+    if (!mimeExtension) return void 0;
+    const normalizedMimeType = mime.getType(mimeExtension);
+    file.parsedMime = normalizedMimeType;
+    if (!normalizedMimeType?.startsWith("image")) return void 0;
+    return file;
+  },
+  replaceLoadingNode(editor, pos, res) {
+    const pm = editor.schema.nodes;
+    const parsedMime = res.file.parsedMime;
+    const returnVal = editor.commands.command(({ tr }) => {
+      if (parsedMime.startsWith("image")) {
+        tr.replaceWith(pos, pos + 1, pm.image.create({
+          src: res.result
+        }));
+        return true;
+      }
+      tr.delete(pos, pos + 1);
+      return false;
+    });
+    return returnVal;
+  },
+  loadFile: async (file, insertId, editor) => {
+    const result = await readAsDataUrl(file);
+    const replacePos = findLoadingNodePos(editor.state, insertId);
+    if (replacePos !== void 0) {
+      editor.commands.command(({ tr }) => {
+        tr.setNodeAttribute(replacePos, "preview", result);
+        return true;
+      });
+    }
+    if (file.parsedMime.startsWith("image")) {
+      await delay(testFileLoaderDelay * Math.random());
+      return {
+        file,
+        result
+      };
+    }
+    return void 0;
+  }
+});

package/dist/runtime/pm/features/FileLoader/commands/insertFile.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from "@tiptap/core";
+import type { IFileLoaderHandler } from "../types.js.js";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        fileLoader: {
+            /**
+             * Insert a file into the editor using the FileLoader extension. The configured {@link IFileLoaderHandler} determines where exactly it's inserted (in an item node after by default).
+             *
+             * You can technically test if this will work with `can` but it's not 100% accurate. We only check if at least one file passes the file filter, not everything else.
+             *
+             * @redirectable
+             */
+            insertFile(files: File[], pos?: number): ReturnType;
+        };
+    }
+}
+export declare const insertFile: (handler: IFileLoaderHandler<any, any>, debug?: boolean) => (files: File[], pos?: number) => Command;

package/dist/runtime/pm/features/FileLoader/commands/insertFile.js

@@ -0,0 +1,39 @@
+import { redirectFromEmbedded } from "../../EmbeddedDocument/utils/redirectFromEmbedded.js";
+import { findLoadingNodePos } from "../utils/findLoadingNodePos.js";
+export const insertFile = (handler, debug = false) => (files, pos) => ({ tr, editor, view, commands, dispatch }) => {
+  const redirect = redirectFromEmbedded(view, "insertFile", { args: [files, pos], view, commands });
+  if (redirect.redirected) {
+    return redirect.result;
+  }
+  if (dispatch) tr.setMeta("fileLoaderIgnore", true);
+  if (!dispatch) {
+    return files.some((file) => handler.filterFile?.(file) ?? true);
+  }
+  void Promise.allSettled(files.reverse().map(async (file) => {
+    if (debug) console.log(`insertFile for ${file.name}`, file);
+    const f = handler.filterFile ? handler.filterFile(file) : file;
+    if (!f) return;
+    if (debug) console.log(`filterFile for ${file.name}`, f);
+    const insertPosition = handler.insertPosition(f, editor, pos);
+    if (debug) console.log(`insertPosition for ${file.name}`, insertPosition);
+    if (insertPosition === void 0) return;
+    const insertLoadingNode = handler.insertLoadingNode;
+    const insertId = insertLoadingNode(f, editor, insertPosition, pos);
+    if (debug) console.log(`insertId for ${file.name}`, insertId);
+    if (!insertId) return;
+    const res = await handler.loadFile?.(f, insertId, editor);
+    if (debug) console.log(`result for ${file.name}`, res);
+    if (!res) {
+      return handler.onLoadError(f, editor, void 0, new Error("fileLoader returned nothing."), insertId);
+    }
+    const replacePos = findLoadingNodePos(editor.state, insertId);
+    if (debug) console.log(`replacePos for ${file.name}`, replacePos);
+    if (replacePos === void 0) {
+      return handler.onLoadError(f, editor, replacePos, new Error("Could not find node to replace."), insertId);
+    }
+    const replaceRes = handler.replaceLoadingNode(editor, replacePos, res, insertId);
+    if (debug) console.log(`called replaceLoadingNode for ${file.name}, replaced node:`, replaceRes);
+  })).then(() => {
+  });
+  return true;
+};

package/dist/runtime/pm/features/FileLoader/components/FileLoaderNodeView.d.vue.ts

@@ -0,0 +1,92 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    editor: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["editor"]>;
+        required: true;
+    };
+    node: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["node"]>;
+        required: true;
+    };
+    decorations: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["decorations"]>;
+        required: true;
+    };
+    selected: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["selected"]>;
+        required: true;
+    };
+    extension: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["extension"]>;
+        required: true;
+    };
+    getPos: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["getPos"]>;
+        required: true;
+    };
+    updateAttributes: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["updateAttributes"]>;
+        required: true;
+    };
+    deleteNode: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["deleteNode"]>;
+        required: true;
+    };
+    view: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["view"]>;
+        required: true;
+    };
+    innerDecorations: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["innerDecorations"]>;
+        required: true;
+    };
+    HTMLAttributes: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["HTMLAttributes"]>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    editor: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["editor"]>;
+        required: true;
+    };
+    node: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["node"]>;
+        required: true;
+    };
+    decorations: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["decorations"]>;
+        required: true;
+    };
+    selected: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["selected"]>;
+        required: true;
+    };
+    extension: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["extension"]>;
+        required: true;
+    };
+    getPos: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["getPos"]>;
+        required: true;
+    };
+    updateAttributes: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["updateAttributes"]>;
+        required: true;
+    };
+    deleteNode: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["deleteNode"]>;
+        required: true;
+    };
+    view: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["view"]>;
+        required: true;
+    };
+    innerDecorations: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["innerDecorations"]>;
+        required: true;
+    };
+    HTMLAttributes: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["HTMLAttributes"]>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/pm/features/FileLoader/components/FileLoaderNodeView.vue

@@ -0,0 +1,38 @@
+<template>
+<!-- @vue-expect-error contenteditable exists -->
+<node-view-wrapper
+	:class="twMerge(
+  `
+		group/file-loader
+		rounded-sm
+		animate-pulse
+		bg-accent-200
+		text-accent-800
+		dark:bg-accent-700
+		dark:text-accent-300
+		px-2
+		flex
+		flex-col
+		items-center
+		gap-2
+	`
+)"
+	contenteditable="false"
+>
+	<div class="self-start">
+		{{ `Loading "${node.attrs.fileName ?? `Unknown`}" ...` }}
+	</div>
+	<img
+		v-if="node.attrs.preview"
+		class="!max-h-[200px] !max-w-[200px] mb-2"
+		:src="node.attrs.preview"
+		alt="Loading Image"
+	>
+</node-view-wrapper>
+</template>
+
+<script setup>
+import { nodeViewProps, NodeViewWrapper } from "@tiptap/vue-3";
+import { twMerge } from "tailwind-merge";
+defineProps(nodeViewProps);
+</script>

package/dist/runtime/pm/features/FileLoader/components/FileLoaderNodeView.vue.d.ts

@@ -0,0 +1,92 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    editor: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["editor"]>;
+        required: true;
+    };
+    node: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["node"]>;
+        required: true;
+    };
+    decorations: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["decorations"]>;
+        required: true;
+    };
+    selected: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["selected"]>;
+        required: true;
+    };
+    extension: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["extension"]>;
+        required: true;
+    };
+    getPos: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["getPos"]>;
+        required: true;
+    };
+    updateAttributes: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["updateAttributes"]>;
+        required: true;
+    };
+    deleteNode: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["deleteNode"]>;
+        required: true;
+    };
+    view: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["view"]>;
+        required: true;
+    };
+    innerDecorations: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["innerDecorations"]>;
+        required: true;
+    };
+    HTMLAttributes: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["HTMLAttributes"]>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    editor: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["editor"]>;
+        required: true;
+    };
+    node: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["node"]>;
+        required: true;
+    };
+    decorations: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["decorations"]>;
+        required: true;
+    };
+    selected: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["selected"]>;
+        required: true;
+    };
+    extension: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["extension"]>;
+        required: true;
+    };
+    getPos: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["getPos"]>;
+        required: true;
+    };
+    updateAttributes: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["updateAttributes"]>;
+        required: true;
+    };
+    deleteNode: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["deleteNode"]>;
+        required: true;
+    };
+    view: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["view"]>;
+        required: true;
+    };
+    innerDecorations: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["innerDecorations"]>;
+        required: true;
+    };
+    HTMLAttributes: {
+        type: import("vue").PropType<import("@tiptap/core").NodeViewProps["HTMLAttributes"]>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/pm/features/FileLoader/plugins/fileLoaderPlugin.d.ts

@@ -0,0 +1,5 @@
+import type { Editor } from "@tiptap/core";
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import type { FileLoaderExtensionOptions } from "../types.js.js";
+export declare const fileLoaderPluginKey: PluginKey<any>;
+export declare function fileLoaderPlugin(editor: Editor, options: Pick<FileLoaderExtensionOptions, "cleanupOnLoad">): Plugin<any>;

package/dist/runtime/pm/features/FileLoader/plugins/fileLoaderPlugin.js

@@ -0,0 +1,61 @@
+import { Plugin, PluginKey } from "@tiptap/pm/state";
+import { cleanupFileLoaderNodes } from "../utils/cleanupFileLoaderNodes.js";
+export const fileLoaderPluginKey = new PluginKey("fileLoader");
+export function fileLoaderPlugin(editor, options) {
+  let cleaned = false;
+  return new Plugin({
+    key: fileLoaderPluginKey,
+    /** See {@link DocumentApi} */
+    stateInit: (tr) => {
+      if (!options.cleanupOnLoad) return;
+      cleaned = true;
+      return cleanupFileLoaderNodes(
+        tr,
+        editor.schema,
+        editor.state.schema.nodes.fileLoader,
+        [
+          editor.state.schema.nodes.item,
+          editor.state.schema.nodes.list
+        ],
+        editor.state.schema.nodes.paragraph
+      );
+    },
+    // in case the documentApi isn't being used to load documents
+    appendTransaction: (_, _oldState, newState) => {
+      if (!newState.tr.getMeta("cleanFileLoaders") && (!options.cleanupOnLoad || cleaned)) return;
+      cleaned = true;
+      return cleanupFileLoaderNodes(
+        newState.tr,
+        editor.schema,
+        editor.state.schema.nodes.fileLoader,
+        [
+          editor.state.schema.nodes.item,
+          editor.state.schema.nodes.list
+        ],
+        editor.state.schema.nodes.paragraph
+      );
+    },
+    filterTransaction: (tr) => {
+      if (tr.getMeta("fileLoaderIgnore")) return false;
+      return true;
+    },
+    props: {
+      handleDOMEvents: {
+        drop: (view, event) => {
+          event.preventDefault();
+          const pos = view.posAtCoords({ left: event.clientX, top: event.clientY });
+          if (!pos) return;
+          const position = pos.inside > 0 ? pos.inside : pos.pos - 1;
+          const files = Array.from(event.dataTransfer?.files ?? []);
+          void editor.commands.insertFile(files, position);
+        },
+        paste: (_view, event) => {
+          const files = Array.from(event.clipboardData?.files ?? []);
+          const htmlContent = event.clipboardData?.getData("text/html");
+          if (htmlContent) return;
+          void editor.commands.insertFile(files);
+        }
+      }
+    }
+  });
+}

package/dist/runtime/pm/features/FileLoader/types.d.ts

@@ -0,0 +1,73 @@
+import type { Editor } from "@tiptap/core";
+import type { HTMLAttributesOptions } from "../../../types/index.js.js";
+import type { WithOnTriggerByEmbeddedBlockOptions } from "../EmbeddedDocument/types.js.js";
+export interface FileLoaderExtensionOptions extends HTMLAttributesOptions, WithOnTriggerByEmbeddedBlockOptions {
+    /**
+     * By default, the plugin removes fileLoader nodes using {@link cleanupFileLoaderNodes} when the document is loaded. This can happen if the user interrupts a file load/upload/save and the document is saved with a fileLoader node.
+     *
+     * We can't keep a reference to the file they wanted to load without external work, so the nodes are removed.
+     */
+    cleanupOnLoad?: boolean;
+    /** See {@link IFileLoaderHandler} */
+    handler: IFileLoaderHandler<File, any>;
+}
+/**
+ * Helps handle the loading of files. Provides a way to adjust the insert position and takes care of keeping track of loading vs loaded nodes.
+ *
+ * See {@link FileLoaderHandler} for a partial implementation you can customize to create the interface.
+ *
+ * The insert handlers are called with the files in reverse order so that you can more easily insert them one after the other without position mapping.
+ */
+export type IFileLoaderHandler<TFile extends File, T = {
+    file: TFile;
+    result: string | ArrayBuffer | null;
+}, TKey = string> = {
+    /**
+     * Should load/save/upload the file and return the information neccesary to create the loaded node.
+     *
+     * The `insertId` and `editor` are provided in case you're uploading the file or doing some other heavy operation and want to update the fileLoader node as soon as you can load the image.
+     *
+     * A `FileLoaderNodeView` is provided (but no pre-configured) for these purposes. If you set the node's `preview` property it will use it as the src for an image.
+     */
+    loadFile: (file: TFile, insertId: TKey, editor: Editor) => Promise<T | undefined>;
+    /**
+     * This can be used to remove the loading node on errors.
+     *
+     * The default {@link FileLoaderHandler.onLoadError} uses {@link cleanupFileLoaderNodes} to remove the parent item node if possible, otherwise it turns the fileLoader node into a paragraph.
+     */
+    onLoadError: (file: TFile, editor: Editor, pos: number | undefined, error: Error, loadingKey: TKey) => void;
+    /**
+     *
+     * Where to insert the fileLoader node.
+     *
+     * The default @{@link FileLoaderHandler.insertPosition} returns the position after the closest parent item node. The idea being one inserts a new item node there with a loading file node inside.
+     *
+     * You can override this by returning a different position. If no position is returned, no node is inserted.
+     */
+    insertPosition: (file: TFile, editor: Editor, pos?: number) => number | undefined;
+    /**
+     * Given a file, should insert a fileLoader node with the `loadingId` set to a unique key that the extension can then use to find the node again. It should return this key if it inserted the node.
+     *
+     * Using the file name is not a good idea as it's not guaranteed to be unique if the user inserts the same item twice.
+     *
+     * The default {@link FileLoaderHandler.insertLoadingNode} inserts a new item node with a fileLoader node inside after in the closest viable position after the insertPos. It uses a nanoid for the loading id.
+     */
+    insertLoadingNode: (file: TFile, editor: Editor, insertPos: number, originalPos?: number) => TKey | undefined;
+    /**
+     * After loading the file, if it's successful, this is passed the result and the position of the fileLoader node.
+     *
+     * Note that this position points at the node with those attributes, and not it's parent in the case of having inserted a wrapping node.
+     *
+     *
+     */
+    replaceLoadingNode: (editor: Editor, pos: number, res: T, loadingKey: TKey) => void;
+    /**
+     * Return the file (or whatever type you'd like) to allow the extension to handle it.
+     *
+     * If the function doesn't return anything, the file will be ignored.
+     * No fileLoader node will be created. The event will still be preventDefaulted.
+     *
+     * This can be used to filter out mime types you can't handle with a library like `mime`. Mime type filtering is not handled by the extension since it can be complicated.
+     */
+    filterFile: (file: File) => TFile | undefined;
+};

package/dist/runtime/pm/features/FileLoader/utils/cleanupFileLoaderNode.d.ts

@@ -0,0 +1,4 @@
+import type { NodeType } from "@tiptap/pm/model";
+import type { Transaction } from "@tiptap/pm/state";
+/** Like {@link cleanupFileLoaderNodes} but for single nodes when you already know the position. Returns true if it deleted a node. */
+export declare function cleanupFileLoaderNode(tr: Transaction, pos: number, fileLoaderType: NodeType, wrappingTypes: NodeType[], replaceType: NodeType): boolean;

package/dist/runtime/pm/features/FileLoader/utils/cleanupFileLoaderNode.js

@@ -0,0 +1,27 @@
+import { findUpwards } from "../../../utils/findUpwards.js";
+export function cleanupFileLoaderNode(tr, pos, fileLoaderType, wrappingTypes, replaceType) {
+  const node = tr.doc.nodeAt(pos);
+  if (!node) return false;
+  if (node.type === fileLoaderType) {
+    let $parent;
+    findUpwards(tr.doc, pos, ($pos) => {
+      if (wrappingTypes.includes($pos.parent.type)) {
+        if ($pos.parent.childCount === 1) {
+          $parent = $pos;
+        } else {
+          return true;
+        }
+      } else if ($parent) {
+        return true;
+      }
+      return false;
+    });
+    if ($parent) {
+      tr.delete($parent.start() - 1, $parent.end() + 1);
+    } else {
+      tr.replaceWith(pos, pos + node.nodeSize, replaceType.create());
+    }
+    return true;
+  }
+  return false;
+}

package/dist/runtime/pm/features/FileLoader/utils/cleanupFileLoaderNodes.d.ts

@@ -0,0 +1,9 @@
+import type { NodeType, Schema } from "@tiptap/pm/model";
+import type { Transaction } from "@tiptap/pm/state";
+import { cleanupFileLoaderNode } from "./cleanupFileLoaderNode.js.js";
+/**
+ * Removes all `fileLoader` nodes from the document.
+ *
+ * Searches up parent wrappers of the given `wrappingTypes`. If any exist and have no other children, they are removed.
+ */
+export declare function cleanupFileLoaderNodes(tr: Transaction, schema: Schema, fileLoaderTypeOrName: string | NodeType, wrappingTypesOrNames: (string | NodeType)[], replaceTypeOrName: string | NodeType, callback?: typeof cleanupFileLoaderNode): Transaction;

package/dist/runtime/pm/features/FileLoader/utils/cleanupFileLoaderNodes.js

@@ -0,0 +1,22 @@
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { getNodeType } from "@tiptap/core";
+import { cleanupFileLoaderNode } from "./cleanupFileLoaderNode.js";
+export function cleanupFileLoaderNodes(tr, schema, fileLoaderTypeOrName, wrappingTypesOrNames, replaceTypeOrName, callback = cleanupFileLoaderNode) {
+  const fileLoaderType = getNodeType(fileLoaderTypeOrName, schema);
+  const wrappingTypes = wrappingTypesOrNames.map((_) => getNodeType(_, schema));
+  const replaceType = getNodeType(replaceTypeOrName, schema);
+  const positions = [];
+  tr.doc.descendants((node, pos) => {
+    if (node.type === fileLoaderType) {
+      positions.push(pos);
+    }
+  });
+  for (const pos of positions.reverse()) {
+    const mappedPos = tr.mapping.map(pos);
+    if (mappedPos !== pos) unreachable();
+    callback(tr, mappedPos, fileLoaderType, wrappingTypes, replaceType);
+  }
+  tr.setMeta("preventClearDocument", true);
+  tr.setMeta("addToHistory", false);
+  return tr;
+}

package/dist/runtime/pm/features/FileLoader/utils/findLoadingNodePos.d.ts

@@ -0,0 +1,2 @@
+import type { EditorState } from "@tiptap/pm/state";
+export declare function findLoadingNodePos(state: EditorState, loadingId: string): number | undefined;

package/dist/runtime/pm/features/FileLoader/utils/findLoadingNodePos.js

@@ -0,0 +1,11 @@
+export function findLoadingNodePos(state, loadingId) {
+  let replacePos;
+  state.doc.nodesBetween(0, state.doc.content.size - 1, (node, position) => {
+    if (node.attrs.loadingId === loadingId) {
+      replacePos = position;
+      return false;
+    }
+    return true;
+  });
+  return replacePos;
+}

package/dist/runtime/pm/features/FileLoader/utils/optionsCheck.d.ts

@@ -0,0 +1,3 @@
+import type { Editor } from "@tiptap/core";
+import type { FileLoaderExtensionOptions } from "../types.js.js";
+export declare function optionsCheck(editor: Editor, options: FileLoaderExtensionOptions): void;

package/dist/runtime/pm/features/FileLoader/utils/optionsCheck.js

@@ -0,0 +1,8 @@
+export function optionsCheck(editor, options) {
+  if (!options.handler) {
+    throw new Error("The FileLoader needs to be configered with a handler (see FileLoaderHandler).");
+  }
+  if ((!options.handler.insertLoadingNode || !options.handler.onLoadError || !options.handler?.insertPosition) && editor.state.schema.nodes.item === void 0) {
+    throw new Error("Could not find item node in schema. Add the block extensions or specify a custom `handler.insertLoadingNode` function for the FileLoader.");
+  }
+}

package/dist/runtime/pm/features/FileLoader/utils/readAsDataUrl.d.ts

@@ -0,0 +1 @@
+export declare function readAsDataUrl(file: File): Promise<string>;

package/dist/runtime/pm/features/FileLoader/utils/readAsDataUrl.js

@@ -0,0 +1,12 @@
+export async function readAsDataUrl(file) {
+  return new Promise((resolve, reject) => {
+    const fileReader = new FileReader();
+    fileReader.readAsDataURL(file);
+    fileReader.onload = () => {
+      resolve(fileReader.result);
+    };
+    fileReader.onerror = (e) => {
+      reject(e);
+    };
+  });
+}

package/dist/runtime/pm/features/HardBreak/HardBreak.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Extends the tiptap hard break extension to set the linebreakReplacement option (which tiptap does not expose).
+ * This option tells prosemirror that when converting between blocks that can/can't show whitespace, it should use this node type to represent line breaks in node types that don't display them.
+ */
+export declare const HardBreak: import("@tiptap/core").Node<import("@tiptap/extension-hard-break", { with: { "resolution-mode": "require" } }).HardBreakOptions, any>;

package/dist/runtime/pm/features/HardBreak/HardBreak.js

@@ -0,0 +1,14 @@
+import { HardBreak as TipTapHardBreak } from "@tiptap/extension-hard-break";
+export const HardBreak = TipTapHardBreak.extend({
+  extendNodeSchema(extension) {
+    if (extension.name === "hardBreak") {
+      return {
+        linebreakReplacement: true
+      };
+    }
+    return {};
+  },
+  addKeyboardShortcuts() {
+    return {};
+  }
+});

package/dist/runtime/pm/features/Heading/Heading.d.ts

@@ -0,0 +1,24 @@
+import { Node } from "@tiptap/core";
+import type { HeadingNodeOptions } from "./types.js.js";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        heading: {
+            setHeading: (opts: {
+                level: HeadingNodeOptions["levels"][number];
+                onlyHeading: boolean;
+            }, pos?: number) => ReturnType;
+            toggleHeading: (opts: {
+                level: HeadingNodeOptions["levels"][number];
+            }) => ReturnType;
+        };
+    }
+}
+/**
+ * Like tiptap's Heading extension, but makes it easier to configure per-level html attributes.
+ *
+ * Also the setHeading command has an option to only change the heading level if the text is already a heading.
+ *
+ * This is useful for when you want to change the heading level of a heading that is already in the document.
+ */
+export declare const Heading: Node<HeadingNodeOptions<[1, 2, 3, 4, 5, 6]>, any>;
+export type NodeHeadingName = "heading";