@witchcraft/editor 0.0.5 → 0.0.7

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

@@ -0,0 +1,51 @@
+import type { Editor } from "@tiptap/core";
+import { type EditorState, PluginKey } from "@tiptap/pm/state";
+import type { Component, InjectionKey, Ref } from "vue";
+export interface MenuCloseCommands {
+}
+/**
+ * Menus describe how to close them again with this key.
+ *
+ * It can be used by other menus to close any open menus before opening itself (see {@link closeOtherMenus}).
+ *
+ * The close command must not need to take any arguments.
+ *
+ * You can extend the `MenuCloseCommands` interface to add more commands.
+ */
+export declare const menusPluginKey: PluginKey<MenusPluginState>;
+export type MenusPluginState = {
+    state: boolean;
+    menu?: OpenMenuInfo;
+    pin: boolean;
+    canShow: boolean;
+};
+export interface BaseMenu<T extends PluginKey<any> | undefined = PluginKey<any> | undefined> {
+    name: string;
+    closeCommand: keyof MenuCloseCommands | undefined;
+    type: "context" | "floating" | "mark";
+    pluginKey: T extends PluginKey<any> ? T : never;
+    priority?: number;
+    canShow: T extends PluginKey<any> ? (state: EditorState, pluginState: ReturnType<T["getState"]>) => boolean : never;
+}
+export type OpenMenuInfo = Omit<BaseMenu, "pluginKey" | "canShow">;
+export interface ContextMenu<T extends PluginKey<any> | undefined = PluginKey<any> | undefined> extends BaseMenu<T> {
+    type: "context";
+}
+export interface FloatingMenu<T extends PluginKey<any> | undefined = PluginKey<any> | undefined> extends BaseMenu<T> {
+    type: "floating";
+}
+export interface MarkMenu<T extends PluginKey<any> = PluginKey<any>> extends BaseMenu<T> {
+    type: "mark";
+}
+export type Menu<T extends PluginKey<any> = PluginKey<any>> = MarkMenu<T> | FloatingMenu<T> | ContextMenu<T>;
+export type MenuRenderInfo = {
+    props?: (editor: Editor) => Record<string, any>;
+    component: Component;
+    popupOptions?: {
+        /**
+         * Attempts to pin the mark menu to the top of the item if the cursor is this close or less to it. Set to a number greater than zero or return a number greater than 0 to enable it.
+         */
+        pinToItemDistance?: number | ((state: EditorState) => number);
+    };
+};
+export declare const menusInjectionKey: InjectionKey<(Ref<Record<string, MenuRenderInfo>>)>;

package/dist/runtime/pm/features/Menus/types.js

@@ -0,0 +1,3 @@
+import { PluginKey } from "@tiptap/pm/state";
+export const menusPluginKey = new PluginKey("menus");
+export const menusInjectionKey = Symbol("menusInjectionKey");

package/dist/runtime/pm/features/Menus/utils/isMarkMenu.d.ts

@@ -0,0 +1,2 @@
+import type { MarkMenu, Menu } from "../types.js";
+export declare function isMarkMenu(menu: Menu): menu is MarkMenu;

package/dist/runtime/pm/features/Menus/utils/isMarkMenu.js

@@ -0,0 +1,3 @@
+export function isMarkMenu(menu) {
+  return menu.type === "mark";
+}

package/dist/runtime/pm/features/Tables/commands/tableEnter.d.ts

@@ -0,0 +1,15 @@
+import { type Command } from "@tiptap/core";
+import type { NodeType } from "@tiptap/pm/model";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        tableEnter: {
+            /**
+             * Handles enter in a table. Splits the table at the next row, inserting a default item, or if it can't, after the table. Does not delete the selection as it's just weird since delete in a table just clears them.
+             *
+             * @redirectable
+             */
+            tableEnter: (pos?: number) => ReturnType;
+        };
+    }
+}
+export declare const tableEnter: (tableTypesOrNames?: (string | NodeType)[], itemTypeOrName?: string | NodeType) => (pos?: number) => Command;

package/dist/runtime/pm/features/Tables/commands/tableEnter.js

@@ -0,0 +1,19 @@
+import { getNodeType } from "@tiptap/core";
+export const tableEnter = (tableTypesOrNames = ["table", "tableRow", "tableCell", "tableHeader"], itemTypeOrName = "item") => (pos) => ({ state, dispatch, tr }) => {
+  const itemType = getNodeType(itemTypeOrName, state.schema);
+  const tableType = tableTypesOrNames.map((name) => getNodeType(name, state.schema));
+  const { $from, empty } = state.selection;
+  const $pos = pos !== void 0 ? tr.doc.resolve(pos) : $from;
+  const parent = $pos.node(-1);
+  if (tableType.includes(parent.type)) {
+    const item = itemType.createAndFill();
+    if (!item) return false;
+    if (dispatch) {
+      if (pos === void 0 && !empty) {
+      }
+      tr.insert($from.after(-2), item);
+    }
+    return true;
+  }
+  return false;
+};

package/dist/runtime/pm/features/Tables/index.d.ts

@@ -0,0 +1,9 @@
+export declare const TableRow: import("@tiptap/core").Node<import("@tiptap/extension-table", { with: { "resolution-mode": "require" } }).TableRowOptions, any>;
+export declare const TableCell: import("@tiptap/core").Node<import("@tiptap/extension-table", { with: { "resolution-mode": "require" } }).TableCellOptions, any>;
+export declare const TableHeader: import("@tiptap/core").Node<import("@tiptap/extension-table", { with: { "resolution-mode": "require" } }).TableHeaderOptions, any>;
+export declare const Table: import("@tiptap/core").Node<import("@tiptap/extension-table", { with: { "resolution-mode": "require" } }).TableOptions, any>;
+export declare const TableExtensions: (import("@tiptap/core").Node<import("@tiptap/extension-table", { with: { "resolution-mode": "require" } }).TableRowOptions, any> | import("@tiptap/core").Node<import("@tiptap/extension-table", { with: { "resolution-mode": "require" } }).TableOptions, any>)[];
+export type NodeTableName = "table";
+export type NodeTableRowName = "tableRow";
+export type NodeTableCellName = "tableCell";
+export type NodeTableHeaderName = "tableHeader";

package/dist/runtime/pm/features/Tables/index.js

@@ -0,0 +1,44 @@
+import {
+  Table as TiptapTable,
+  TableCell as TiptapTableCell,
+  TableHeader as TiptapTableHeader,
+  TableRow as TiptapTableRow
+} from "@tiptap/extension-table";
+import { tableEnter } from "./commands/tableEnter.js";
+export const TableRow = TiptapTableRow.extend({
+  // force table rows to contain something, otherwise create and fill won't work as expected
+  content: "(tableCell | tableHeader)+",
+  addKeyboardShortcuts() {
+    return {};
+  }
+});
+export const TableCell = TiptapTableCell.extend({
+  content: "block",
+  addKeyboardShortcuts() {
+    return {};
+  }
+});
+export const TableHeader = TiptapTableHeader.extend({
+  content: "block",
+  addKeyboardShortcuts() {
+    return {};
+  }
+});
+export const Table = TiptapTable.extend({
+  addOptions() {
+    return {
+      ...this.parent?.(),
+      resizable: true,
+      lastColumnResizable: false
+    };
+  },
+  addCommands() {
+    return {
+      tableEnter: tableEnter()
+    };
+  },
+  addKeyboardShortcuts() {
+    return {};
+  }
+});
+export const TableExtensions = [Table, TableRow, TableCell, TableHeader];

package/dist/runtime/pm/generator.d.ts

@@ -0,0 +1,82 @@
+import type { Mark, Node } from "@tiptap/pm/model";
+export declare const pm: {
+    schema: import("@tiptap/pm/model").Schema<"paragraph" | "item" | "codeBlock" | "heading" | "iframe" | "image" | "table" | "text" | "blockquote" | "cite" | "list" | "tableCell" | "doc" | "embeddedDoc" | "tableRow" | "tableHeader", "bold" | "code" | "italic" | "strike" | "subscript" | "superscript" | "underline" | "hardBreak" | "highlight">;
+} & {
+    readonly [x: string]: import("prosemirror-test-builder").NodeBuilder;
+    readonly paragraph: import("prosemirror-test-builder").NodeBuilder;
+    readonly item: import("prosemirror-test-builder").NodeBuilder;
+    readonly codeBlock: import("prosemirror-test-builder").NodeBuilder;
+    readonly heading: import("prosemirror-test-builder").NodeBuilder;
+    readonly iframe: import("prosemirror-test-builder").NodeBuilder;
+    readonly image: import("prosemirror-test-builder").NodeBuilder;
+    readonly table: import("prosemirror-test-builder").NodeBuilder;
+    readonly text: import("prosemirror-test-builder").NodeBuilder;
+    readonly blockquote: import("prosemirror-test-builder").NodeBuilder;
+    readonly cite: import("prosemirror-test-builder").NodeBuilder;
+    readonly list: import("prosemirror-test-builder").NodeBuilder;
+    readonly tableCell: import("prosemirror-test-builder").NodeBuilder;
+    readonly doc: import("prosemirror-test-builder").NodeBuilder;
+    readonly embeddedDoc: import("prosemirror-test-builder").NodeBuilder;
+    readonly tableRow: import("prosemirror-test-builder").NodeBuilder;
+    readonly tableHeader: import("prosemirror-test-builder").NodeBuilder;
+} & {
+    readonly [x: string]: import("prosemirror-test-builder").MarkBuilder;
+    readonly bold: import("prosemirror-test-builder").MarkBuilder;
+    readonly code: import("prosemirror-test-builder").MarkBuilder;
+    readonly italic: import("prosemirror-test-builder").MarkBuilder;
+    readonly strike: import("prosemirror-test-builder").MarkBuilder;
+    readonly subscript: import("prosemirror-test-builder").MarkBuilder;
+    readonly superscript: import("prosemirror-test-builder").MarkBuilder;
+    readonly underline: import("prosemirror-test-builder").MarkBuilder;
+    readonly hardBreak: import("prosemirror-test-builder").MarkBuilder;
+    readonly highlight: import("prosemirror-test-builder").MarkBuilder;
+} & {
+    [name: string]: import("prosemirror-test-builder").NodeBuilder | import("prosemirror-test-builder").MarkBuilder;
+};
+export type GeneratorConfigEntry<TChildrenType extends "node" | "text" = "node" | "text", TParentType extends "node" | "text" = "node" | "text", TChildren extends TChildrenType extends "node" ? Node : Mark | string = TChildrenType extends "node" ? Node : Mark | string, TParent extends TParentType extends "node" ? Node : Mark | string = TParentType extends "node" ? Node : Mark | string> = {
+    parents: {
+        /**
+         * The type of the parent (node or "text") where "text" is a string or mark.
+         * Determines the call signature of the create function.
+         */
+        type: TParentType;
+        /** Possible parent nodes that can have the given children. The children need not be direct descendants, see `ignoreValidation`. */
+        names: string[];
+    };
+    children: {
+        /**
+         * The type of children (node or "text") where "text" is a string or mark.
+         * Determines the call signature of the create function.
+         */
+        type: TChildrenType;
+        names?: string[];
+    };
+    /**
+     * Set to true to ignore all children mismatches, or set an array of children names to ignore.
+     *
+     * This is needed for creating "end" nodes that aren't valid names (e.g. `text` is not technically allowed since you can't do `builder.text()`).
+     *
+     * Or when the children are not direct children of the parent types as there is some in-between wrapper node that needs to be generated.
+     */
+    ignoreValidation?: boolean | string[];
+    isRoot?: boolean;
+    /**
+     * Creates the node. Can return undefined to "terminate" the branch being created, the node will be filtered out of the nodes passed to it's parent.
+     *
+     * If not set, a default `builder[parentType]({}, ...children)` will be used.
+     *
+     * Note also, it is not required to use the children. You can ignore them or use a subset or create a different one if needed (some node types *require* text and if your text not can return "" this can be a problem).
+     */
+    create?: (parent: string, children: TChildren[]) => TParent | undefined;
+};
+export declare function getTextOrMarkLength(textOrMark: string | Mark): number;
+export declare function createGeneratorConfig<TChildrenType extends "node" | "text" = "node" | "text", TParentType extends "node" | "text" = "node" | "text", TChildren extends TChildrenType extends "node" ? Node : Mark | string = TChildrenType extends "node" ? Node : Mark | string, TParent extends TParentType extends "node" ? Node : Mark | string = TParentType extends "node" ? Node : Mark | string>(config: GeneratorConfigEntry<TChildrenType, TParentType, TChildren, TParent>): GeneratorConfigEntry<TChildrenType, TParentType, TChildren, TParent>;
+export declare const generatorConfig: (GeneratorConfigEntry<"node", "node", Node, Node & {
+    tag: {
+        [tag: string]: number;
+    };
+}> | GeneratorConfigEntry<"text", "node", string | Mark, Node & {
+    tag: {
+        [tag: string]: number;
+    };
+}> | GeneratorConfigEntry<"text", "text", string | Mark, string | Mark>)[];

package/dist/runtime/pm/generator.js

@@ -0,0 +1,205 @@
+import { faker } from "@faker-js/faker";
+import { nanoid } from "nanoid";
+import { builders } from "prosemirror-test-builder";
+import { schema } from "./schema.js";
+export const pm = builders(schema);
+export function getTextOrMarkLength(textOrMark) {
+  if (typeof textOrMark === "string") {
+    return textOrMark.length;
+  }
+  const textNodes = textOrMark.flat.map((_) => "text" in _ ? _.text.length : getTextOrMarkLength(_));
+  return textNodes.reduce((a, b) => a + b, 0);
+}
+export function createGeneratorConfig(config) {
+  return config;
+}
+function createPsuedoSentence() {
+  const sentenceLength = faker.number.int({ min: 0, max: 1e3 });
+  const sentence = Array.from(
+    { length: sentenceLength },
+    () => faker.string.sample({ min: 0, max: 1e3 })
+  ).join(" ");
+  return sentence;
+}
+export const generatorConfig = [
+  createGeneratorConfig({
+    isRoot: true,
+    parents: { type: "node", names: ["doc"] },
+    ignoreValidation: true,
+    children: { type: "node", names: ["item"] },
+    create: (_parent, children) => {
+      if (!children || children.length === 0) {
+        return pm.doc(pm.list(pm.item({ blockId: nanoid(10) }, pm.paragraph({}, ""))));
+      }
+      return pm.doc(pm.list(...children));
+    }
+  }),
+  createGeneratorConfig({
+    parents: { type: "node", names: ["list"] },
+    children: { type: "node", names: ["item"] },
+    create: (_parent, children) => {
+      if (!children || children.length === 0) {
+        return pm.list(pm.item({ blockId: nanoid(10) }, pm.paragraph("")));
+      }
+      return pm.list(...children);
+    }
+  }),
+  createGeneratorConfig({
+    parents: { type: "node", names: ["item"] },
+    children: { type: "node", names: [
+      "paragraph",
+      "heading",
+      "codeBlock",
+      "embeddedDoc",
+      "iframe",
+      "table",
+      "image",
+      "blockquote"
+    ] },
+    create: (_parent, children) => {
+      if (!children || children.length === 0) {
+        return pm.item({ blockId: nanoid(10) }, pm.paragraph(""));
+      }
+      return pm.item(
+        { blockId: nanoid(10) },
+        children[0],
+        ...children.length > 1 ? [pm.list(
+          {},
+          ...children.slice(1).map(
+            (_) => pm.item({ blockId: nanoid(10) }, _)
+          )
+        )] : []
+      );
+    }
+  }),
+  createGeneratorConfig({
+    parents: { type: "node", names: ["blockquote"] },
+    children: { type: "node", names: ["paragraph", "cite"] },
+    create: (_parent, children) => {
+      const parTypes = [];
+      const citeTypes = [];
+      for (const child of children) {
+        if (child.type.name === "cite") {
+          citeTypes.push(child);
+        } else {
+          parTypes.push(child);
+        }
+      }
+      if (parTypes.length === 0) {
+        return pm.blockquote({}, pm.paragraph(""));
+      } else {
+        const someCite = citeTypes.find((_) => _.textContent.length > 0) ?? pm.cite({}, createPsuedoSentence());
+        return pm.blockquote({}, ...parTypes, someCite);
+      }
+    }
+  }),
+  createGeneratorConfig({
+    parents: { type: "node", names: ["table"] },
+    children: { type: "node", names: [
+      "tableHeader",
+      "tableCell"
+    ] },
+    ignoreValidation: true,
+    // we're handling the in-between tableRow nodes
+    create: (_parent, children) => {
+      const headerType = [];
+      const cellType = [];
+      for (const child of children) {
+        if (child.type.name === "tableHeader") {
+          headerType.push(child);
+        } else if (child.type.name === "tableCell") {
+          cellType.push(child);
+        }
+      }
+      const colNum = headerType.length;
+      if (colNum === 0) {
+        return pm.table({}, pm.tableRow({}, pm.tableCell(pm.paragraph(""))));
+      }
+      const rowCount = Math.ceil(cellType.length / colNum);
+      const rows = [];
+      for (let i = 0; i < rowCount; i++) {
+        rows.push(pm.tableRow({}, ...cellType.slice(i * colNum, (i + 1) * colNum)));
+      }
+      return pm.table({}, pm.tableRow({}, ...headerType), ...rows);
+    }
+  }),
+  createGeneratorConfig({
+    parents: { type: "node", names: ["tableHeader", "tableCell"] },
+    children: { type: "node", names: ["paragraph"] },
+    create: (_parent, children) => {
+      if (!children || children.length === 0) {
+        return pm.tableCell(pm.paragraph(""));
+      }
+      return pm.tableCell(...children.slice(0, 1));
+    }
+  }),
+  createGeneratorConfig({
+    parents: { type: "node", names: ["paragraph", "heading", "codeBlock", "cite", "heading"] },
+    children: { type: "text", names: [
+      "bold",
+      "italic",
+      "underline",
+      "strike",
+      "subscript",
+      "superscript",
+      "code",
+      "link"
+    ] },
+    create(parent, children) {
+      if (parent === "heading") {
+        return pm[parent]({ level: 1 }, ...children);
+      }
+      if (parent === "cite") {
+        return pm[parent]({}, faker.lorem.sentence());
+      }
+      if (parent === "paragraph") {
+        const someIndex = faker.number.int({ min: 0, max: children.length });
+        children.splice(someIndex, 0, pm.hardBreak());
+      }
+      return pm[parent]({}, ...children);
+    }
+  }),
+  createGeneratorConfig({
+    parents: {
+      type: "text",
+      names: [
+        "bold",
+        "italic",
+        "underline",
+        "strike",
+        "subscript",
+        "superscript",
+        "link"
+      ]
+    },
+    // note the addition of text
+    children: { type: "text", names: [
+      "bold",
+      "italic",
+      "underline",
+      "strike",
+      "subscript",
+      "superscript",
+      "link",
+      "text"
+    ] },
+    ignoreValidation: ["text"]
+    // text is not a real node
+    // create: (parent, children) => {
+    // 	return pm[parent]({}, ...children as any) as any
+    // }
+  }),
+  createGeneratorConfig({
+    ignoreValidation: true,
+    // text is not a real node
+    parents: { type: "text", names: ["code"] },
+    children: { type: "text", names: ["text"] }
+  }),
+  createGeneratorConfig({
+    parents: { type: "text", names: ["text"] },
+    children: { type: "text" },
+    create: (_parent) => {
+      return createPsuedoSentence();
+    }
+  })
+];

package/dist/runtime/pm/schema.d.ts

@@ -0,0 +1,4 @@
+import { type EditorOptions } from "@tiptap/core";
+import type { Schema } from "@tiptap/pm/model";
+export declare const extensions: EditorOptions["extensions"];
+export declare const schema: Schema<"codeBlock" | "paragraph" | "item" | "heading" | "iframe" | "image" | "table" | "text" | "embeddedDoc" | "blockquote" | "cite" | "list" | "tableCell" | "doc" | "tableRow" | "tableHeader", "bold" | "code" | "italic" | "strike" | "subscript" | "superscript" | "underline" | "hardBreak" | "highlight">;

package/dist/runtime/pm/schema.js

@@ -0,0 +1,80 @@
+import { getSchema } from "@tiptap/core";
+import { Bold } from "@tiptap/extension-bold";
+import { Code } from "@tiptap/extension-code";
+import { Dropcursor } from "@tiptap/extension-dropcursor";
+import { Gapcursor } from "@tiptap/extension-gapcursor";
+import { Italic } from "@tiptap/extension-italic";
+import { Paragraph } from "@tiptap/extension-paragraph";
+import { Strike } from "@tiptap/extension-strike";
+import { Subscript } from "@tiptap/extension-subscript";
+import { Superscript } from "@tiptap/extension-superscript";
+import { Text } from "@tiptap/extension-text";
+import { Underline } from "@tiptap/extension-underline";
+import { Base } from "./features/Base/Base.js";
+import { Blockquote, Cite } from "./features/Blockquote/Blockquote.js";
+import { Item } from "./features/Blocks/Item.js";
+import { List } from "./features/Blocks/List.js";
+import { CodeBlock } from "./features/CodeBlock/CodeBlock.js";
+import { CommandBar } from "./features/CommandsMenus/CommandBar.js";
+import { Document } from "./features/Document/Document.js";
+import { EmbeddedDocument } from "./features/EmbeddedDocument/EmbeddedDocument.js";
+import { HardBreak } from "./features/HardBreak/HardBreak.js";
+import { Heading } from "./features/Heading/Heading.js";
+import { Highlight } from "./features/Highlight/Highlight.js";
+import { History } from "./features/History/History.js";
+import { Iframe } from "./features/Iframe/Iframe.js";
+import { Image } from "./features/Image/Image.js";
+import { Link } from "./features/Link/Link.js";
+import { Menus } from "./features/Menus/Menus.js";
+import { TableExtensions } from "./features/Tables/index.js";
+function stripShortcuts(c) {
+  return c.extend({
+    addKeyboardShortcuts() {
+      return {};
+    }
+  });
+}
+export const extensions = [
+  Document,
+  Gapcursor,
+  Dropcursor,
+  // custom
+  stripShortcuts(Paragraph.extend({
+    group: "block"
+  })),
+  CommandBar,
+  Base,
+  List,
+  Item,
+  Heading,
+  CodeBlock,
+  Iframe,
+  EmbeddedDocument,
+  Link,
+  // needs to be before other marks so we don't get link splitting
+  HardBreak,
+  Image,
+  Highlight,
+  ...TableExtensions,
+  ...[
+    // do not use configured extensions here
+    // see https://github.com/ueberdosis/tiptap/issues/4081
+    Text,
+    // styling
+    Blockquote,
+    Cite,
+    Code,
+    Italic,
+    Underline,
+    Strike,
+    Subscript,
+    Superscript,
+    Bold,
+    // embedding
+    // other
+    History
+  ].map((e) => stripShortcuts(e)),
+  Menus
+];
+const _schema = getSchema(extensions);
+export const schema = _schema;

package/dist/runtime/pm/testSchema.d.ts

@@ -0,0 +1,5 @@
+import type { Schema } from "@tiptap/pm/model";
+import { type NodeFileLoaderName } from "./features/FileLoader/FileLoader.js";
+import { type schema as baseSchema } from "./schema.js";
+export declare const testExtensions: (import("@tiptap/core").AnyExtension | import("@tiptap/core").Node<import("./features/FileLoader/types.ts").FileLoaderExtensionOptions, any>)[];
+export declare const testSchema: typeof baseSchema & Schema<NodeFileLoaderName & "itemNoId">;

package/dist/runtime/pm/testSchema.js

@@ -0,0 +1,30 @@
+import { getSchema } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import { BaseShortcuts } from "./features/BaseShortcuts/BaseShortcuts.js";
+import FileLoaderNodeView from "./features/FileLoader/components/FileLoaderNodeView.vue";
+import { FileLoader } from "./features/FileLoader/FileLoader.js";
+import { TestFileLoaderHandler } from "./features/FileLoader/FileLoaderHandler/TestFileLoaderHandler.js";
+import { extensions } from "./schema.js";
+export const testExtensions = [
+  FileLoader.extend({
+    addOptions() {
+      return {
+        ...this.parent?.(),
+        handler: TestFileLoaderHandler
+      };
+    },
+    addNodeView() {
+      return VueNodeViewRenderer(FileLoaderNodeView, {
+        stopEvent() {
+          return true;
+        },
+        ignoreMutation() {
+          return true;
+        }
+      });
+    }
+  }),
+  BaseShortcuts,
+  ...extensions
+];
+export const testSchema = getSchema(testExtensions);

package/dist/runtime/pm/utils/createDropIndicator.d.ts

@@ -0,0 +1,23 @@
+import { type DropInfo } from "./dropPointInfo.js";
+import type { Point } from "../../types/index.js";
+export interface DropIndicator extends Point {
+    width: number;
+    type: "child" | "before" | "after";
+}
+/**
+ * Calculates the position and type of the drop indicator based on the pointer coordinates
+ * and the target element's bounding rectangle.
+ */
+export declare function createDropIndicator(
+/** The drop point information object. */
+dropInfo: DropInfo, 
+/** The bounding rectangle of the element being dragged over. It will be used for positioning the indicator and constraining it's width `(target.x < indicator < target.right)`. */
+targetRect: DOMRect, 
+/**
+ * Determines the additional indentation to add when indicating a child drop operation. You normally want this to be the indentation of the dragged item.
+ *
+ * Can be gotten with {@link getElPropertyAsInt}, see it for details.
+ */
+indentX: number, 
+/** Maximum width of the drop indicator. See {@link getElMaxVisualSize}. */
+maxWidth: number): DropIndicator | undefined;

package/dist/runtime/pm/utils/createDropIndicator.js

@@ -0,0 +1,36 @@
+import { DROP_X, DROP_Y } from "./dropPointInfo.js";
+export function createDropIndicator(dropInfo, targetRect, indentX, maxWidth) {
+  const d = dropInfo;
+  let dropIndicator;
+  const inBottomHalf = d.y === DROP_Y.BOTTOM || d.y === DROP_Y.OUTSIDE_BOTTOM;
+  const toRightOfIndent = d.x === DROP_X.INSIDE_INDENT || d.x === DROP_X.OUTSIDE_RIGHT;
+  if (toRightOfIndent && inBottomHalf) {
+    dropIndicator = {
+      type: "child",
+      x: targetRect.x + indentX,
+      y: targetRect.y + targetRect.height,
+      width: maxWidth
+    };
+  } else {
+    if (inBottomHalf) {
+      dropIndicator = {
+        type: "after",
+        x: targetRect.x,
+        y: targetRect.y + targetRect.height,
+        width: maxWidth
+      };
+    } else {
+      dropIndicator = {
+        type: "before",
+        x: targetRect.x,
+        y: targetRect.y,
+        width: maxWidth
+      };
+    }
+  }
+  const rightDiff = dropIndicator.x + dropIndicator.width - targetRect.right;
+  if (rightDiff > 0) {
+    dropIndicator.width -= rightDiff;
+  }
+  return dropIndicator;
+}

package/dist/runtime/pm/utils/createStateOnlyPluginApply.d.ts

@@ -0,0 +1,2 @@
+import type { PluginKey, Transaction } from "@tiptap/pm/state";
+export declare function createStateOnlyPluginApply<T extends PluginKey<any>>(key: T): (tr: Transaction, value: ReturnType<T["getState"]>) => any;

package/dist/runtime/pm/utils/createStateOnlyPluginApply.js

@@ -0,0 +1,9 @@
+export function createStateOnlyPluginApply(key) {
+  return function(tr, value) {
+    const trValue = tr.getMeta(key);
+    if (trValue !== void 0) {
+      return trValue;
+    }
+    return value;
+  };
+}

package/dist/runtime/pm/utils/createStateOnlyPluginObjApply.d.ts

@@ -0,0 +1,2 @@
+import type { PluginKey, Transaction } from "@tiptap/pm/state";
+export declare function createStateOnlyPluginObjApply<T extends PluginKey<any>>(key: T): (tr: Transaction, value: ReturnType<T["getState"]>) => any;

package/dist/runtime/pm/utils/createStateOnlyPluginObjApply.js

@@ -0,0 +1,14 @@
+export function createStateOnlyPluginObjApply(key) {
+  return function(tr, value) {
+    const trValue = tr.getMeta(key);
+    if (trValue) {
+      const newVal = {
+        ...value,
+        ...trValue
+      };
+      return newVal;
+    } else {
+      return value;
+    }
+  };
+}