@witchcraft/editor 0.0.1

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.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/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.js";
+import { type schema as baseSchema } from "./schema.js.js";
+export declare const testExtensions: (import("@tiptap/core").AnyExtension | import("@tiptap/core").Node<import("./features/FileLoader/types.ts.js").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.js";
+import type { Point } from "../../types/index.js.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. */
+targetRect: DOMRect, 
+/**
+ * The indentation of the dragged item.
+ *
+ * Can be gotten with {@link getElPropertyAsInt}
+ */
+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,32 @@
+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
+      };
+    }
+  }
+  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;
+    }
+  };
+}

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

@@ -0,0 +1,56 @@
+import type { EnumLike } from "@alanscodelog/utils";
+import type { Point } from "../../types/index.js.js";
+/**
+ * Given a point (a mouse position), a box, and a possible indent, returns information regarding it's position.
+ *
+ * For example if we "zoom" in on a list section like this where the mouse is hovering at the level of B1 (not neccesarily inside it):
+ *
+ * ```
+ * ...
+ * 		- C1
+ * 	- B1
+ * - A1
+ * ...
+ * ```
+ * We are interested in the following:
+ * - In what y section we're in (outside-top, top, bottom, outside-bottom)
+ * - In what x section we're in (outside-left, inside, inside-indent, outside-right)
+ * ```
+ *     outside-left \ inside       \ inside-indent \ outside-right
+ *                  \              \               \
+ * outside-top      \              \               \
+ * -----------------┌──────────────┬───────────────┐
+ *                  │B1            │               │
+ *                  │              │               │
+ * top              │              │               │
+ * -----------------├──────────────┼───────────────┤
+ *                  │<---indent--->│               │
+ *                  │              │               │
+ * bottom           │              │               │
+ * -----------------└──────────────┴───────────────┘
+ * outside-bottom
+ * ```
+ * We can use this information to determine where we want to drop something.
+ */
+export declare function dropPointInfo(point: Point, box: Point & {
+    width: number;
+    height: number;
+}, indentX: number): DropInfo;
+export declare const DROP_Y: {
+    TOP: "TOP";
+    OUTSIDE_TOP: "OUTSIDE_TOP";
+    BOTTOM: "BOTTOM";
+    OUTSIDE_BOTTOM: "OUTSIDE_BOTTOM";
+};
+export type DropY = EnumLike<typeof DROP_Y>;
+export declare const DROP_X: {
+    INSIDE: "INSIDE";
+    OUTSIDE_LEFT: "OUTSIDE_LEFT";
+    INSIDE_INDENT: "INSIDE_INDENT";
+    OUTSIDE_RIGHT: "OUTSIDE_RIGHT";
+};
+export type DropX = EnumLike<typeof DROP_X>;
+export type DropInfo = {
+    x: DropX;
+    y: DropY;
+};

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

@@ -0,0 +1,28 @@
+import { enumFromArray } from "@alanscodelog/utils/enumFromArray";
+export function dropPointInfo(point, box, indentX) {
+  const info = {
+    x: "INSIDE",
+    y: "TOP"
+  };
+  if (point.y < box.y) info.y = DROP_Y.OUTSIDE_TOP;
+  else if (point.y < box.y + box.height / 2) info.y = DROP_Y.TOP;
+  else if (point.y < box.y + box.height) info.y = DROP_Y.BOTTOM;
+  else info.y = DROP_Y.OUTSIDE_BOTTOM;
+  if (point.x < box.x) info.x = DROP_X.OUTSIDE_LEFT;
+  else if (point.x < box.x + indentX) info.x = DROP_X.INSIDE;
+  else if (point.x < box.x + box.width) info.x = DROP_X.INSIDE_INDENT;
+  else info.x = DROP_X.OUTSIDE_RIGHT;
+  return info;
+}
+export const DROP_Y = enumFromArray([
+  "OUTSIDE_TOP",
+  "TOP",
+  "BOTTOM",
+  "OUTSIDE_BOTTOM"
+]);
+export const DROP_X = enumFromArray([
+  "OUTSIDE_LEFT",
+  "INSIDE",
+  "INSIDE_INDENT",
+  "OUTSIDE_RIGHT"
+]);

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

@@ -0,0 +1,20 @@
+import type { Node, ResolvedPos } from "@tiptap/pm/model";
+/**
+ * Traverse the tree upwards (along parents, along the left) to find a position.
+ */
+export declare function findUpwards(
+/** Needed to resolve positions from. */
+node: Node, 
+/** Position to start searching from. */
+from: number, filter: ($pos: ResolvedPos, pos: number, loop: number) => boolean, { start, step, stop }?: {
+    /** Where to start searching, -1 would be current node (default), 0 the parent, and so on. */
+    start?: number;
+    step?: number;
+    stop?: number;
+}): {
+    $pos: ResolvedPos;
+    pos: number;
+} | {
+    $pos: undefined;
+    pos: undefined;
+};

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

@@ -0,0 +1,18 @@
+export function findUpwards(node, from, filter, {
+  start = -1,
+  step = 1,
+  stop
+} = {}) {
+  const $from = node.resolve(from);
+  let loops = 0;
+  for (let depth = start; depth < $from.depth; depth += step) {
+    const currentDepth = $from.depth - depth;
+    const newPos = $from.before(currentDepth);
+    const $pos = node.resolve(newPos);
+    if (!filter && stop === loops || filter($pos, newPos, loops)) {
+      return { $pos, pos: newPos };
+    }
+    loops++;
+  }
+  return { $pos: void 0, pos: void 0 };
+}

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

@@ -0,0 +1,3 @@
+import type { Node, NodeType } from "@tiptap/pm/model";
+import type { Selection } from "@tiptap/pm/state";
+export declare const getChildChunks: (doc: Node, itemType: NodeType, selection: Pick<Selection, "$from" | "$to">) => Pick<Selection, "$from" | "$to">[];

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

@@ -0,0 +1,15 @@
+import { nodesBetween } from "./nodesBetween.js";
+export const getChildChunks = (doc, itemType, selection) => {
+  const children = [];
+  nodesBetween(doc, selection, (node, pos) => {
+    if (node?.type === itemType) {
+      const $pos = doc.resolve(pos + 1);
+      if ($pos.depth > selection.$from.depth) {
+        children.push({ $from: $pos, $to: $pos });
+        return false;
+      }
+    }
+    return true;
+  });
+  return children;
+};

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

@@ -0,0 +1,20 @@
+import type { Node } from "@tiptap/pm/model";
+/**
+ * Given two different nodes, calculates the range that needs to be replaced with the latter node, to sync them.
+ *
+ * ```ts
+ * const offset = ... // the shared offset between the two nodes, if needed
+ * const diff = getDiffReplacementRange(existingNode, convertedNewNode)
+ * if (diff) {
+ * 	intTr.replace(offset + diff.start, offset + diff.end, convertedNewNode.slice(diff.start, diff.otherEnd))
+ * }
+ * ```
+ */
+export declare function getDiffReplacementRange(nodeA: Node, nodeB: Node, offset?: number): {
+    start: number;
+    end: number;
+    /** For slicing the latter node. */
+    sliceStart: number;
+    /** For slicing the latter node. */
+    sliceEnd: number;
+} | null;

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

@@ -0,0 +1,9 @@
+export function getDiffReplacementRange(nodeA, nodeB, offset = 0) {
+  const diffStart = nodeA.content.findDiffStart(nodeB.content);
+  const diffEnd = nodeA.content.findDiffEnd(nodeB.content);
+  if (diffStart === null || diffEnd === null) return null;
+  const nodeStart = Math.min(diffStart, diffEnd.a);
+  const start = nodeStart + offset;
+  const end = diffEnd.a + offset;
+  return { start, end, sliceStart: nodeStart, sliceEnd: diffEnd.b };
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Gets the visual width and height of an element (el.getBoundingClientRect().width/height - scrollbarWidth/Height).
+ *
+ * Useful for creating drop indicators that don't go outside the element.
+ */
+export declare function getElMaxVisualSize(el: HTMLElement): {
+    width: number;
+    height: number;
+};

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

@@ -0,0 +1,7 @@
+export function getElMaxVisualSize(el) {
+  const scrollBarWidth = el.offsetWidth - el.clientWidth;
+  const width = el.getBoundingClientRect().width - scrollBarWidth;
+  const scrollBarHeight = el.offsetHeight - el.clientHeight;
+  const height = el.getBoundingClientRect().height - scrollBarHeight;
+  return { width, height };
+}

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

@@ -0,0 +1 @@
+export declare function getElPropertyAsInt(el: HTMLElement, prop: string): number;

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

@@ -0,0 +1,8 @@
+const pxRegex = /([0-9.]+)px/g;
+export function getElPropertyAsInt(el, prop) {
+  const value = window.getComputedStyle(el).getPropertyValue(prop);
+  if (!pxRegex.test(value)) {
+    throw new Error(`Component must set property ${prop} in pixels for getElPropertyAsInt to be able to extract the value.`);
+  }
+  return Number.parseInt(value.replace(pxRegex, "$1"), 10);
+}

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

@@ -0,0 +1,2 @@
+import type { Schema } from "@tiptap/pm/model";
+export declare function getGroupNodeNames(schema: Schema, groups: string[]): string[];

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

@@ -0,0 +1,7 @@
+export function getGroupNodeNames(schema, groups) {
+  const res = [];
+  schema.spec.nodes.forEach((key, val) => {
+    if (val.group && groups.includes(val.group)) res.push(key);
+  });
+  return res;
+}

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

@@ -0,0 +1,11 @@
+import type { MarkType } from "@tiptap/pm/model";
+import type { EditorState } from "@tiptap/pm/state";
+/**
+ * Get the position of any mark of the given type touching the given position.
+ *
+ * Basically searches outwards from the position until it finds a text node without the given mark type.
+ */
+export declare function getMarkPosition(state: EditorState, markTypeOrName: MarkType | string, pos: number): {
+    from: number;
+    to: number;
+} | null;

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

@@ -0,0 +1,34 @@
+import { getMarkType } from "@tiptap/core";
+export function getMarkPosition(state, markTypeOrName, pos) {
+  const markType = getMarkType(markTypeOrName, state.schema);
+  const $pos = state.doc.resolve(pos);
+  const isAtEnd = $pos.parentOffset === $pos.parent.nodeSize - 2;
+  const startOffset = isAtEnd ? $pos.parentOffset - 1 : $pos.parentOffset;
+  const start = $pos.parent.childAfter(startOffset);
+  if (!start) return null;
+  function hasMark(node) {
+    const marks = node.marks;
+    for (const mark of marks) {
+      if (mark.type === markType) return true;
+    }
+    return false;
+  }
+  const parent = $pos.parent;
+  let fromIndex = $pos.index() - (isAtEnd ? 1 : 0) - 1;
+  let fromPos = $pos.start() + (start?.offset ?? 0);
+  let toPos = fromPos;
+  let toIndex = fromIndex + 1;
+  while (fromIndex > 0 && hasMark(parent.child(fromIndex))) {
+    const child = parent.child(fromIndex);
+    const childSize = child.nodeSize;
+    fromIndex -= 1;
+    fromPos -= childSize;
+  }
+  while (toIndex < parent.childCount && hasMark(parent.child(toIndex))) {
+    const child = parent.child(toIndex);
+    const childSize = child.nodeSize;
+    toIndex += 1;
+    toPos += childSize;
+  }
+  return { from: fromPos, to: toPos };
+}

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

@@ -0,0 +1,3 @@
+import type { Mark } from "@tiptap/pm/model";
+import type { EditorState } from "@tiptap/pm/state";
+export declare function getMarksInSelection(state: EditorState): Mark[];