@witchcraft/editor 0.0.5 → 0.0.7

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";
+/**
+ * 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/generateRandomDoc.d.ts

@@ -0,0 +1,23 @@
+import type { Node } from "@tiptap/pm/model";
+import type { builders } from "prosemirror-test-builder";
+import { generateRandomTree } from "./generateRandomTree.js";
+import type { GeneratorConfigEntry } from "../generator.js";
+/**
+ * Generates a random doc using faker js.
+ *
+ * A config describing how to create the doc is required. One is available under `pm/generator`.
+ *
+ * @experimental
+ */
+export declare function generateRandomDoc<TBuilder extends ReturnType<typeof builders>, TData extends string>(builder: TBuilder, config?: GeneratorConfigEntry<any, any, any, any>[], treeOptions?: Parameters<typeof generateRandomTree>[1], { checkAfterNodeCreation }?: {
+    /**
+     * Checks if every returned node is valid for debugging invalid generator configs.
+     *
+     * A check is always done on the root node at the end regardless of this option.
+     *
+     * It is very slow (each check, rechecks children).
+     *
+     * @default false
+     */
+    checkAfterNodeCreation?: boolean;
+}): Node;

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

@@ -0,0 +1,83 @@
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { faker } from "@faker-js/faker";
+import { generateRandomTree } from "./generateRandomTree.js";
+import { generatorConfig } from "../generator.js";
+export function generateRandomDoc(builder, config = generatorConfig, treeOptions, {
+  checkAfterNodeCreation = false
+} = {}) {
+  const schema = builder.schema;
+  const map = {};
+  function schemaFilter(name) {
+    return name !== "text" && name !== schema.topNodeType.name;
+  }
+  for (const entry of config) {
+    for (const node of entry.parents.names) {
+      if (node === "") throw new Error(`Empty node name ""`);
+      const type = entry.parents.type === "node" ? schema.nodes[node] : schema.marks[node];
+      if (type === void 0 && node !== "text") {
+        throw new Error(`${node} (on entry of type ${entry.parents.type}) not found in schema. Valid names are ${Object.keys(entry.parents.type === "node" ? schema.nodes : schema.marks)}`);
+      }
+      for (const node2 of entry.parents.names) {
+        const subEntry = { ...entry };
+        if (entry.ignoreValidation === void 0 || entry.ignoreValidation !== true) {
+          const childrenToValidate = (entry.children.names ?? []).filter((_) => !Array.isArray(entry.ignoreValidation) || !entry.ignoreValidation.includes(_));
+          for (const child of childrenToValidate) {
+            if (child === "") throw new Error(`Empty node name ""`);
+            if (entry.children.type === "node") {
+              const childType = schema.nodes[child];
+              const possibleNames = [childType.name, ...(childType.spec.group ?? "").split(" ").filter((e) => e !== "")];
+              const isAllowedChild = type.spec.content && possibleNames.some((n) => type.spec.content.includes(n));
+              if (!(isAllowedChild && schemaFilter(childType.name))) {
+                throw new Error(`Node ${node2} cannot contain child of type ${child}`);
+              }
+            } else {
+              const childType = schema.marks[child];
+              if (entry.parents.type === "node") {
+              } else {
+                const possibleNames = [childType.name, ...(childType.spec.group ?? "").split(" ").filter((e) => e !== "")];
+                const t = type;
+                const isExcluded = t.spec.excludes !== void 0 && possibleNames.some((n) => {
+                  return t.spec.excludes.includes(n) || t.spec.excludes.includes("_");
+                });
+                if (isExcluded) {
+                  throw new Error(`Mark ${node2} cannot contain mark child of type ${child}`);
+                }
+              }
+            }
+          }
+        }
+        map[node2] = { ...subEntry };
+      }
+    }
+  }
+  const children = generateRandomTree({
+    parentData: (data) => {
+      if (data === "") return "";
+      if (!data) unreachable();
+      if (!map[data] || !map[data].children.names || map[data].children.names.length === 0) {
+        return "";
+      } else {
+        const picked = faker.helpers.arrayElement(map[data].children.names);
+        return picked;
+      }
+    },
+    createNode: (children2, _isLeaf, data) => {
+      if (data === "") return void 0;
+      if (!data) unreachable();
+      const type = schema.nodes[data];
+      if (!type) return void 0;
+      const parent = map[data]?.create?.(data, children2) ?? builder[data]({}, ...children2);
+      if (checkAfterNodeCreation) {
+        ;
+        parent?.check?.();
+      }
+      return parent;
+    }
+  }, {
+    ...treeOptions,
+    initialData: schema.topNodeType.name
+  });
+  const doc = map[schema.topNodeType.name]?.create?.(schema.topNodeType.name, children) ?? builder[schema.topNodeType.name]({}, ...children);
+  doc.check?.();
+  return doc;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Generates a random tree structure where the probability of generating children
+ * decreases linearly with depth, resulting in a tree that is bushy at the top
+ * and sparse towards the maximum depth.
+ *
+ * This function is agnostic to the actual node structure, relying on the caller-provided
+ * callbacks to create and link nodes.
+ *
+ * It uses faker.js for randomness (even on the option parameters).
+ *
+ * See {@link generateRandomDoc} for an example of how to use it.
+ *
+ * @experimental
+ */
+export declare function generateRandomTree<T, TData>({ createNode, parentData }: {
+    /** A function that creates a new node (type T) given its depth. */
+    createNode: (children: T[], isLeaf: boolean, parentData?: TData) => T | undefined;
+    /**
+     * A function that is called before creating a a node or it's children whose result is passed to both. This allows creating children that will be compatible with the parent (via this same function, it is passed it's parent).
+     *
+     * For example, we could randomly generate a parent type. It's then passed both to the children, to limit the types of children nodes, and to the parent so it can actually create it.
+     */
+    parentData?: (parentData?: TData) => TData;
+}, { rootNodes: rootNodes, depth, minChildren, maxInitialChildren, initialData }?: {
+    /**
+     * The exact number of nodes at depth 0.
+     *
+     * @default faker.number.int({ min: 0, max: 5 })
+     */
+    rootNodes?: number;
+    /**
+     * The maximum depth of the tree (0-indexed). Nodes at this depth will have 0 children.
+     *
+     * @default faker.number.int({ min: 0, max: 5 })
+     */
+    depth?: number;
+    /**
+     * The absolute minimum number of children any node can have.
+     *
+     * @default 0
+     */
+    minChildren?: number;
+    /**
+     * The maximum children a node can have at depth 0. This value scales down as depth increases.
+     *
+     * @default 10
+     */
+    maxInitialChildren?: number;
+    initialData?: TData;
+}): T[];

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

@@ -0,0 +1,38 @@
+import { faker } from "@faker-js/faker";
+export function generateRandomTree({
+  createNode,
+  parentData
+}, {
+  rootNodes = faker.number.int({ min: 0, max: 5 }),
+  depth = faker.number.int({ min: 0, max: 5 }),
+  minChildren = 0,
+  maxInitialChildren = 10,
+  initialData
+} = {}) {
+  const generateChildren = (currentDepth, childCount, pData) => {
+    const res = [];
+    for (let i = 0; i < childCount; i++) {
+      const numChildren = calculateNumChildren(depth, currentDepth, minChildren, maxInitialChildren);
+      const data = parentData?.(pData) ?? void 0;
+      const parent = createNode(
+        generateChildren(currentDepth + 1, numChildren, data),
+        numChildren === 0,
+        data
+      );
+      if (parent === void 0) continue;
+      res.push(parent);
+    }
+    return res;
+  };
+  return generateChildren(0, rootNodes, initialData);
+}
+function calculateNumChildren(depth, currentDepth, minChildren, maxInitialChildren) {
+  const decayFactor = depth > 0 ? (depth - currentDepth) / depth : 0;
+  const maxAtDepth = minChildren + (maxInitialChildren - minChildren) * decayFactor;
+  const maxChildrenAtDepth = Math.max(minChildren, Math.floor(maxAtDepth));
+  let numChildren = 0;
+  if (currentDepth < depth) {
+    numChildren = faker.number.int({ min: minChildren, max: maxChildrenAtDepth });
+  }
+  return numChildren;
+}

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,4 @@
+/**
+ * Returns any **pixel** css property as an integer.
+ */
+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[];

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

@@ -0,0 +1,16 @@
+export function getMarksInSelection(state) {
+  const sel = state.selection;
+  const marks = [];
+  const isAtEnd = sel.$from.parentOffset === sel.$to.parent.nodeSize - 2;
+  const start = isAtEnd ? sel.from - 1 : sel.from;
+  const end = sel.empty ? sel.from + 1 : sel.to;
+  state.doc.nodesBetween(start, end, (node) => {
+    if (node.marks) {
+      for (const mark of node.marks) {
+        marks.push(mark);
+      }
+    }
+    return true;
+  });
+  return marks;
+}

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

@@ -0,0 +1,2 @@
+import type { NodeType, Schema } from "@tiptap/pm/model";
+export declare const getTypeByName: (schema: Schema, name: string) => NodeType;

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

@@ -0,0 +1,5 @@
+export const getTypeByName = (schema, name) => {
+  const nodeType = schema.nodes[name];
+  if (nodeType === void 0 || nodeType === null) throw new Error(`Unknown node type:${name}`);
+  return nodeType;
+};

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

@@ -0,0 +1,15 @@
+export { createStateOnlyPluginApply } from "./createStateOnlyPluginApply.js";
+export { createStateOnlyPluginObjApply } from "./createStateOnlyPluginObjApply.js";
+export { dropPointInfo } from "./dropPointInfo.js";
+export { findUpwards } from "./findUpwards.js";
+export { getChildChunks } from "./getChildChunks.js";
+export { getDiffReplacementRange } from "./getDiffReplacementRange.js";
+export { getElMaxVisualSize } from "./getElMaxVisualSize.js";
+export { getElPropertyAsInt } from "./getElPropertyAsInt.js";
+export { getGroupNodeNames } from "./getGroupNodeNames.js";
+export { getMarkPosition } from "./getMarkPosition.js";
+export { getMarksInSelection } from "./getMarksInSelection.js";
+export { mapSelection } from "./mapSelection.js";
+export { nodesBetween } from "./nodesBetween.js";
+export { pointToPmPoint } from "./pointToPmPoint.js";
+export { splitIntoChunks } from "./splitIntoChunks.js";

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

@@ -0,0 +1,15 @@
+export { createStateOnlyPluginApply } from "./createStateOnlyPluginApply.js";
+export { createStateOnlyPluginObjApply } from "./createStateOnlyPluginObjApply.js";
+export { dropPointInfo } from "./dropPointInfo.js";
+export { findUpwards } from "./findUpwards.js";
+export { getChildChunks } from "./getChildChunks.js";
+export { getDiffReplacementRange } from "./getDiffReplacementRange.js";
+export { getElMaxVisualSize } from "./getElMaxVisualSize.js";
+export { getElPropertyAsInt } from "./getElPropertyAsInt.js";
+export { getGroupNodeNames } from "./getGroupNodeNames.js";
+export { getMarkPosition } from "./getMarkPosition.js";
+export { getMarksInSelection } from "./getMarksInSelection.js";
+export { mapSelection } from "./mapSelection.js";
+export { nodesBetween } from "./nodesBetween.js";
+export { pointToPmPoint } from "./pointToPmPoint.js";
+export { splitIntoChunks } from "./splitIntoChunks.js";

package/dist/runtime/pm/utils/internal/createNodeTypesList.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from "@tiptap/pm/model";
+export declare const createNodeTypesList: (schema: Schema, mutatedNodeTypes: string[], nodeTypeNames?: string[], nodeGroups?: string[]) => string[];

package/dist/runtime/pm/utils/internal/createNodeTypesList.js

@@ -0,0 +1,17 @@
+import { pushIfNotIn } from "@alanscodelog/utils";
+import { getGroupNodeNames } from "../getGroupNodeNames.js";
+export const createNodeTypesList = (schema, mutatedNodeTypes, nodeTypeNames, nodeGroups) => {
+  if (nodeGroups) {
+    pushIfNotIn(
+      mutatedNodeTypes,
+      getGroupNodeNames(schema, nodeGroups)
+    );
+  }
+  if (nodeTypeNames) {
+    pushIfNotIn(
+      mutatedNodeTypes,
+      nodeTypeNames
+    );
+  }
+  return mutatedNodeTypes;
+};

package/dist/runtime/pm/utils/internal/debugMap.d.ts

@@ -0,0 +1,7 @@
+import type { Transaction } from "@tiptap/pm/state";
+export declare function debugMap(tr: Transaction, { asTable, start, end, collapse }?: {
+    asTable?: boolean;
+    start?: number;
+    end?: number;
+    collapse?: boolean;
+}): void;

package/dist/runtime/pm/utils/internal/debugMap.js

@@ -0,0 +1,24 @@
+export function debugMap(tr, {
+  asTable = true,
+  start = 0,
+  end = tr.doc.nodeSize - 1,
+  collapse = true
+} = {}) {
+  console[collapse ? "groupCollapsed" : "group"]("map");
+  if (asTable) {
+    const table = {
+      before: [],
+      after: []
+    };
+    for (let i = start; i <= end; i++) {
+      table.before.push(i);
+      table.after.push(tr.mapping.map(i));
+    }
+    console.table(table);
+  } else {
+    for (let i = start; i <= end; i++) {
+      console.log(i, tr.mapping.map(i));
+    }
+  }
+  console.groupEnd();
+}

package/dist/runtime/pm/utils/internal/debugNode.d.ts

@@ -0,0 +1,2 @@
+import { type Fragment, type Node, ResolvedPos, type Slice } from "@tiptap/pm/model";
+export declare function debugNode(doc?: Slice | Fragment | ResolvedPos | Node | null | undefined, title?: string | number, collapse?: boolean, deep?: boolean, props?: ("size" | "is" | "attrs")[]): void;

package/dist/runtime/pm/utils/internal/debugNode.js

@@ -0,0 +1,18 @@
+import { ResolvedPos } from "@tiptap/pm/model";
+import { recurse } from "./recurse.js";
+export function debugNode(doc, title, collapse = true, deep = true, props = ["size"]) {
+  if (doc instanceof ResolvedPos) {
+    doc = doc.node();
+  }
+  const d = doc;
+  const isSlice = d?.constructor?.name === "Slice";
+  const isFragment = d?.constructor?.name === "Fragment";
+  const message = !doc ? "UNDEFINED" : isSlice ? `[[${d.content.content.map((node) => recurse(node, deep, props) ?? "").join("]\n[")}]]` : isFragment ? `[[${d.content.map((node) => recurse(node, deep, props) ?? "").join("]\n[")}]]` : recurse(d, deep, props);
+  console[collapse ? "groupCollapsed" : "group"](
+    title !== void 0 ? title.toString() : "",
+    message !== "UNDEFINED" ? isSlice || isFragment ? "Slice" : message.split("\n")[0] : message
+    // new Error().stack?.split("\n")[2],
+  );
+  console.log(message);
+  console.groupEnd();
+}

package/dist/runtime/pm/utils/internal/debugSel.d.ts

@@ -0,0 +1,5 @@
+import { EditorState } from "@tiptap/pm/state";
+export declare function debugSel(sel: EditorState | {
+    from: number;
+    to: number;
+}, title?: string | number): void;

package/dist/runtime/pm/utils/internal/debugSel.js

@@ -0,0 +1,8 @@
+import { EditorState } from "@tiptap/pm/state";
+export function debugSel(sel, title = "") {
+  if (sel instanceof EditorState) {
+    console.log(title, sel.selection.from, sel.selection.to);
+  } else {
+    console.log(title, sel.from, sel.to);
+  }
+}

package/dist/runtime/pm/utils/internal/recurse.d.ts

@@ -0,0 +1,2 @@
+import type { Node } from "@tiptap/pm/model";
+export declare function recurse(node: Node, deep?: boolean, props?: ("size" | "is" | "attrs")[], depth?: number): string;