@witchcraft/editor 0.0.5 → 0.0.6

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

@@ -0,0 +1,65 @@
+import { InputRule, mergeAttributes, Node } from "@tiptap/core";
+import { Blockquote as TiptapBlockquote } from "@tiptap/extension-blockquote";
+import { TextSelection } from "@tiptap/pm/state";
+import { blockquoteEnter } from "./commands/blockquoteEnter.js";
+import { blockquoteShiftEnter } from "./commands/blockquoteShiftEnter.js";
+export const Blockquote = TiptapBlockquote.extend({
+  name: "blockquote",
+  content: "paragraph+ cite?",
+  addOptions() {
+    return {
+      ...this.parent?.(),
+      HTMLAttributes: {
+        class: "border-l-4 border-neutral-400 pl-2 dark:border-neutral-600"
+      }
+    };
+  },
+  addCommands() {
+    return {
+      blockquoteShiftEnter: blockquoteShiftEnter(this.name),
+      blockquoteEnter: blockquoteEnter(this.name)
+    };
+  }
+});
+export const Cite = Node.create({
+  name: "cite",
+  content: "inline+",
+  parseHTML() {
+    return [
+      { tag: "cite" }
+    ];
+  },
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "cite",
+      mergeAttributes(HTMLAttributes, {
+        class: "text-neutral-700 dark:text-neutral-400 before:content-['\u2014']"
+      }),
+      0
+    ];
+  },
+  addInputRules() {
+    return [
+      // tiptap's nodeInputRule doesn't work well at all for this situation
+      new InputRule({
+        find: /(?:^|\s)---\s?$/,
+        handler: ({ state, range }) => {
+          const { tr } = state;
+          const start = range.from;
+          const end = range.to;
+          const insertionStart = start - 1;
+          const $pos = tr.doc.resolve(insertionStart);
+          if ($pos.node().type.name !== "blockquote") {
+            return null;
+          }
+          tr.delete(insertionStart, end);
+          tr.insert(insertionStart, this.type.create());
+          tr.setSelection(TextSelection.create(tr.doc, tr.mapping.map(insertionStart)));
+          tr.scrollIntoView();
+          return void 0;
+        }
+      })
+    ];
+  }
+});

package/dist/runtime/pm/features/Blockquote/commands/blockquoteEnter.d.ts

@@ -0,0 +1,11 @@
+import { type Command } from "@tiptap/core";
+import type { NodeType } from "@tiptap/pm/model";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        blockquoteEnter: {
+            blockquoteEnter: (pos?: number) => ReturnType;
+        };
+    }
+}
+/** Allows blockquotes enter to work if possible, otherwise fallsback to creating and focusing a new node of the given fallback type after the blockquote containing item. */
+export declare const blockquoteEnter: (blockQuoteTypeOrName: string | NodeType, citationTypeOrName?: string | NodeType, fallbackNodeTypeOrName?: string | NodeType) => (pos?: number) => Command;

package/dist/runtime/pm/features/Blockquote/commands/blockquoteEnter.js

@@ -0,0 +1,31 @@
+import { getNodeType } from "@tiptap/core";
+import { TextSelection } from "@tiptap/pm/state";
+export const blockquoteEnter = (blockQuoteTypeOrName, citationTypeOrName = "cite", fallbackNodeTypeOrName = "item") => (pos) => ({ tr, dispatch, state }) => {
+  const { $from, $to, empty } = tr.selection;
+  const $pos = pos !== void 0 ? tr.doc.resolve(pos) : $to;
+  const blockquoteType = getNodeType(blockQuoteTypeOrName, state.schema);
+  const citationType = getNodeType(citationTypeOrName, state.schema);
+  const fallbackNodeType = getNodeType(fallbackNodeTypeOrName, state.schema);
+  const matchesQuote = $pos.node(-1).type === blockquoteType || $from.node(-1).type === blockquoteType;
+  const matchesCite = $pos.node().type === citationType || $from.node().type === citationType;
+  if (matchesQuote || matchesCite) {
+    const node = fallbackNodeType.createAndFill();
+    if (!node) return false;
+    if (dispatch) {
+      if (pos === void 0 && !empty) {
+        tr.delete($from.pos, $to.pos);
+      }
+      const position = pos ?? $to.pos;
+      const $position = tr.doc.resolve(position);
+      const isAtEnd = position === $position.end();
+      if (isAtEnd || matchesCite) {
+        tr.insert(matchesCite ? $position.end() + 1 : position, node);
+        tr.setSelection(TextSelection.near(tr.doc.resolve(tr.mapping.map(matchesCite ? $position.end() + 1 : position + 1)), isAtEnd ? -1 : 1));
+      } else {
+        tr.split(tr.mapping.map(pos ?? $to.pos), 3);
+      }
+    }
+    return true;
+  }
+  return false;
+};

package/dist/runtime/pm/features/Blockquote/commands/blockquoteShiftEnter.d.ts

@@ -0,0 +1,11 @@
+import { type Command } from "@tiptap/core";
+import type { NodeType } from "@tiptap/pm/model";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        blockquoteShiftEnter: {
+            blockquoteShiftEnter: () => ReturnType;
+        };
+    }
+}
+/** Allows blockquotes to have multiple paragraphs. */
+export declare const blockquoteShiftEnter: (blockQuoteTypeOrName: string | NodeType) => () => Command;

package/dist/runtime/pm/features/Blockquote/commands/blockquoteShiftEnter.js

@@ -0,0 +1,12 @@
+import { getNodeType } from "@tiptap/core";
+export const blockquoteShiftEnter = (blockQuoteTypeOrName) => () => ({ tr, dispatch, state }) => {
+  const { $from, $to, from } = tr.selection;
+  const blockquoteType = getNodeType(blockQuoteTypeOrName, state.schema);
+  if ($from.node(-1)?.type === blockquoteType || $to.node(-1)?.type === blockquoteType) {
+    if (dispatch) {
+      tr.split(from, 1);
+    }
+    return true;
+  }
+  return false;
+};

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

@@ -0,0 +1,2 @@
+export { Item } from "./Item.js";
+export { List } from "./List.js";

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

@@ -0,0 +1,2 @@
+export { Item } from "./Item.js";
+export { List } from "./List.js";

package/dist/runtime/pm/features/Blocks/Item.d.ts

@@ -0,0 +1,11 @@
+import { Node } from "@tiptap/core";
+import { type ItemNodeOptions } from "./types.js";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        item: {
+            deleteItem: (pos?: number) => ReturnType;
+        };
+    }
+}
+export declare const Item: Node<ItemNodeOptions, any>;
+export type NodeItemName = "item";

package/dist/runtime/pm/features/Blocks/Item.js

@@ -0,0 +1,157 @@
+import { keys } from "@alanscodelog/utils";
+import { mergeAttributes, Node } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import { nanoid } from "nanoid";
+import { changeItemType } from "./commands/changeItemType.js";
+import { copyOrMoveItem } from "./commands/copyOrMoveItem.js";
+import { deleteItem } from "./commands/deleteItem.js";
+import { indentItem } from "./commands/indentItem.js";
+import { closeItemMenu, openItemMenu, toggleItemMenu } from "./commands/itemMenuCommands.js";
+import { moveItem } from "./commands/moveItem.js";
+import { splitItem } from "./commands/splitItem.js";
+import { unindentItem } from "./commands/unindentItem.js";
+import ItemNodeView from "./components/ItemNodeView.vue";
+import { ensureLastItemIsContentPlugin } from "./plugins/ensureLastItemIsContentPlugin.js";
+import { itemBlockIdPlugin } from "./plugins/itemBlockIdPlugin.js";
+import { itemHasSingularSelectionPlugin } from "./plugins/itemHasSingularSelectionPlugin.js";
+import { itemMenuPlugin } from "./plugins/itemMenuPlugin.js";
+import { statefulStates } from "./states/stateful.js";
+import { itemMenuPluginKey } from "./types.js";
+export const Item = Node.create({
+  name: "item",
+  content: "block list? | list",
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      states: statefulStates,
+      types: [
+        "none",
+        "ordered",
+        // todo list all list-style-types
+        "unordered",
+        "ordered-upper-roman",
+        "ordered-lower-roman",
+        ...keys(statefulStates).map((type) => `stateful-${type}`)
+        // "unordered-square",
+      ],
+      idLength: 10,
+      allowAnyIdLength: true,
+      ensureLastItemIsParagraph: true
+    };
+  },
+  addAttributes() {
+    return {
+      type: {
+        default: "none"
+      },
+      state: {
+        default: void 0
+      },
+      hideChildren: {
+        default: false
+      },
+      blockId: {
+        default: () => nanoid(this.options.idLength),
+        keepOnSplit: false
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "li",
+        // totest
+        getAttrs: (node) => {
+          const blockId = node.getAttribute("blockid") ?? nanoid(this.options.idLength);
+          const type = node.getAttribute("type");
+          const hideChildren = node.getAttribute("hidechildren");
+          const base = { type, hideChildren: hideChildren === "true", blockId };
+          if (type && this.options.types.includes(type)) {
+            if (type.startsWith("stateful")) {
+              const state = node.getAttribute("state");
+              const stateTypeEntry = this.options.states[type.slice(9)];
+              if (stateTypeEntry !== void 0) {
+                if (stateTypeEntry.entries.find((entry) => entry.value === state) !== void 0) {
+                  return { ...base, state };
+                } else {
+                  return { ...base, state: stateTypeEntry.default };
+                }
+              }
+            }
+            return base;
+          } else {
+            const role = node.getAttribute("role");
+            const ariaChecked = node.getAttribute("aria-checked");
+            if (role === "checkbox") {
+              if (ariaChecked === "true") {
+                return { type, state: "checked", blockId };
+              } else {
+                return { type, state: "unchecked", blockId };
+              }
+            }
+          }
+          return type !== void 0 ? null : false;
+        }
+      },
+      { tag: "ol > li", attrs: { type: "ordered", blockId: nanoid(this.options.idLength) } },
+      { tag: "ul > li", attrs: { type: "unordered" }, blockId: nanoid(this.options.idLength) }
+    ];
+  },
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  renderHTML({ HTMLAttributes }) {
+    return [
+      "li",
+      mergeAttributes(
+        this.options.HTMLAttributes,
+        HTMLAttributes
+      ),
+      0
+    ];
+  },
+  addCommands() {
+    return {
+      changeItemType: changeItemType({
+        nodeType: this.name,
+        allowedValues: this.options.types,
+        attributeKey: "type",
+        allowedStates: statefulStates,
+        stateAttributeKey: "state"
+      }),
+      deleteItem: deleteItem(this.name),
+      indentItem: indentItem(this.name, "list"),
+      unindentItem: unindentItem(this.name),
+      copyOrMoveItem: copyOrMoveItem(),
+      moveItem: moveItem(this.name),
+      splitItem: splitItem(this.name),
+      openItemMenu: openItemMenu(this.name),
+      closeItemMenu: closeItemMenu(),
+      toggleItemMenu: toggleItemMenu()
+    };
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(ItemNodeView);
+  },
+  onCreate() {
+    if ("registerMenu" in this.editor.commands) {
+      this.editor.commands.registerMenu({
+        type: "context",
+        closeCommand: "closeItemMenu",
+        name: "itemMenu",
+        pluginKey: itemMenuPluginKey,
+        priority: 100,
+        canShow: (_state, pluginState) => !!pluginState?.opened
+      });
+    }
+  },
+  addProseMirrorPlugins() {
+    const self = this;
+    return [
+      ensureLastItemIsContentPlugin("paragraph", this.name, {
+        initialState: this.options.ensureLastItemIsParagraph ?? true
+      }),
+      itemMenuPlugin(),
+      itemBlockIdPlugin(self),
+      itemHasSingularSelectionPlugin()
+    ];
+  }
+});

package/dist/runtime/pm/features/Blocks/List.d.ts

@@ -0,0 +1,4 @@
+import { Node } from "@tiptap/core";
+import type { ListNodeOptions } from "./types.js";
+export declare const List: Node<ListNodeOptions, any>;
+export type NodeListName = "list";

package/dist/runtime/pm/features/Blocks/List.js

@@ -0,0 +1,59 @@
+import { mergeAttributes, Node } from "@tiptap/core";
+import { setNode } from "./commands/setNode.js";
+export const List = Node.create({
+  name: "list",
+  content: "item+",
+  allowGapCursor: true,
+  addOptions() {
+    return { HTMLAttributes: {} };
+  },
+  addAttributes() {
+    return {
+      type: {
+        default: "list"
+      }
+    };
+  },
+  addCommands() {
+    return {
+      // override tiptap's setNode
+      setNode: setNode()
+    };
+  },
+  parseHTML() {
+    const getAttrs = (node) => {
+      const type = node.getAttribute("node-type");
+      if (type === "list") {
+        return { type };
+      } else return false;
+    };
+    return [
+      {
+        tag: "ul",
+        getAttrs
+      },
+      {
+        tag: "ol",
+        getAttrs
+      }
+    ];
+  },
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  renderHTML({ HTMLAttributes, node }) {
+    return [
+      "ul",
+      mergeAttributes(
+        this.options.HTMLAttributes,
+        {
+          "node-type": node.attrs.type,
+          role: "list"
+        },
+        HTMLAttributes,
+        {
+          class: `list flex flex-col gap-1 ${HTMLAttributes?.class ?? this.options.HTMLAttributes?.class ?? ""}`
+        }
+      ),
+      0
+    ];
+  }
+});

package/dist/runtime/pm/features/Blocks/commands/changeItemType.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "@tiptap/core";
+import type { CommandAttributeOptions } from "../../../../types/index.js";
+import type { StatefulNodeStates } from "../types.js";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        changeItemType: {
+            changeItemType: (opts: {
+                type: string;
+                state?: string;
+            }, pos?: number) => ReturnType;
+        };
+    }
+}
+export declare const changeItemType: ({ nodeType, allowedValues, allowedStates, stateAttributeKey, attributeKey }: CommandAttributeOptions<string> & {
+    allowedStates: StatefulNodeStates;
+    stateAttributeKey: string;
+}) => ({ type, state: itemState }: {
+    type: string;
+    state?: string;
+}, pos?: number) => Command;

package/dist/runtime/pm/features/Blocks/commands/changeItemType.js

@@ -0,0 +1,40 @@
+import { findUpwards } from "../../../utils/findUpwards.js";
+export const changeItemType = ({
+  nodeType,
+  allowedValues,
+  allowedStates,
+  stateAttributeKey,
+  attributeKey
+}) => ({
+  type,
+  state: itemState
+}, pos) => ({ state, tr, dispatch }) => {
+  if (!allowedValues.includes(type)) {
+    return false;
+  }
+  const position = pos ?? state.selection.map(tr.doc, tr.mapping).from;
+  const $item = findUpwards(tr.doc, position, ($pos) => {
+    if ($pos.node().type.name === nodeType) {
+      return true;
+    }
+    return false;
+  })?.$pos;
+  if ($item) {
+    const finalPos = $item.pos;
+    const node = $item.node();
+    if (dispatch) {
+      tr.setNodeAttribute(finalPos - 1, attributeKey, type);
+      if (type.startsWith("stateful-")) {
+        const statefulType = type.slice(type.indexOf("-") + 1);
+        const stateEntry = allowedStates[statefulType];
+        if (stateEntry !== void 0) {
+          const newState = itemState ?? node.state ?? stateEntry.default;
+          tr.setNodeAttribute(finalPos, stateAttributeKey, newState);
+        }
+      }
+    }
+    return true;
+  } else {
+    return false;
+  }
+};

package/dist/runtime/pm/features/Blocks/commands/changeTypeAttr.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "@tiptap/core";
+import type { CommandAttributeOptions } from "../../../../types/index.js";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        changeTypeAttr: {
+            changeTypeAttr: (opts: {
+                type: string;
+            }) => ReturnType;
+        };
+    }
+}
+export declare const changeTypeAttr: ({ nodeType, allowedValues, attributeKey }: CommandAttributeOptions<string>) => ({ type }: {
+    type: string;
+}, pos?: number) => Command;

package/dist/runtime/pm/features/Blocks/commands/changeTypeAttr.js

@@ -0,0 +1,28 @@
+import { findUpwards } from "../../../utils/findUpwards.js";
+export const changeTypeAttr = ({
+  nodeType,
+  allowedValues,
+  attributeKey
+}) => ({
+  type
+}, pos) => ({ state, tr, dispatch }) => {
+  if (!allowedValues.includes(type)) {
+    return false;
+  }
+  const position = pos ?? state.selection.map(tr.doc, tr.mapping).from;
+  const $item = findUpwards(tr.doc, position, ($pos) => {
+    if ($pos.node().type.name === nodeType) {
+      return true;
+    }
+    return false;
+  })?.$pos;
+  if ($item) {
+    if (dispatch) {
+      const finalPos = $item.pos;
+      tr.setNodeAttribute(finalPos - 1, attributeKey, type);
+    }
+    return true;
+  } else {
+    return false;
+  }
+};

package/dist/runtime/pm/features/Blocks/commands/copyOrMoveItem.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copies/moves an item to be before/after/child of the target item.
+ */
+import type { Command } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        copyOrMoveItem: {
+            /**
+             * @redirectable
+             */
+            copyOrMoveItem: (itemPos: number, moveItemPos: number, position: "before" | "after" | "child", options?: {
+                move?: boolean;
+            }) => ReturnType;
+        };
+    }
+}
+/** Copies or moves a single list item. This is for using while dragging an item. */
+export declare const copyOrMoveItem: ({ listNodeTypeName, itemNodeTypeName }?: {
+    listNodeTypeName?: string;
+    itemNodeTypeName?: string;
+}) => (itemPos: number, moveItemPos: number, position: "before" | "after" | "child", { move }?: {
+    move?: boolean;
+}) => Command;

package/dist/runtime/pm/features/Blocks/commands/copyOrMoveItem.js

@@ -0,0 +1,124 @@
+import { Fragment, Slice } from "@tiptap/pm/model";
+import { TextSelection } from "@tiptap/pm/state";
+import { ReplaceAroundStep } from "@tiptap/pm/transform";
+import { redirectFromEmbedded } from "../../EmbeddedDocument/utils/redirectFromEmbedded.js";
+export const copyOrMoveItem = ({
+  listNodeTypeName = "list",
+  itemNodeTypeName = "item"
+} = {}) => (itemPos, moveItemPos, position, {
+  move = true
+} = {}) => ({ tr, state, view, commands, dispatch }) => {
+  const redirect = redirectFromEmbedded(
+    view,
+    "copyOrMoveItem",
+    { args: [itemPos, moveItemPos, position, { move }], view, commands }
+  );
+  if (redirect.redirected) {
+    return redirect.result;
+  }
+  const listNode = state.schema.nodes[listNodeTypeName];
+  const itemNode = state.schema.nodes[itemNodeTypeName];
+  const $targetItem = tr.doc.resolve(moveItemPos);
+  const $item = tr.doc.resolve(itemPos);
+  if ($item.node().type.name !== itemNodeTypeName) {
+    throw new Error(`itemPos ${itemPos} does not point to node type ${itemNodeTypeName} but to ${$item.node().type.name}`);
+  }
+  if ($targetItem.node().type.name !== itemNodeTypeName) {
+    throw new Error(`moveItemPos ${moveItemPos} does not point to node type ${itemNodeTypeName} but to ${$targetItem.node().type.name}`);
+  }
+  const $target = tr.doc.resolve($targetItem.start() + 1);
+  const targetIsContentless = $target.node().type.name === $targetItem.node().type.name;
+  const parent = targetIsContentless ? $targetItem.node() : $target.node(-1);
+  const nodeAfterIsList = parent.childCount > 1 && parent.child(1).type.name === listNodeTypeName;
+  const { from, to } = state.selection.map(tr.doc, tr.mapping);
+  const beforeItemPos = $item.before();
+  const afterItemPos = $item.after();
+  const selectionFromOffset = from > beforeItemPos && from < afterItemPos ? state.selection.from - beforeItemPos : void 0;
+  const selectionToOffset = to > beforeItemPos && to < afterItemPos ? state.selection.to - beforeItemPos : void 0;
+  function restoreSelection(start) {
+    if (!dispatch) return;
+    if (selectionFromOffset) {
+      tr.setSelection(TextSelection.create(
+        tr.doc,
+        start + selectionFromOffset,
+        selectionToOffset && selectionToOffset + start
+      ));
+    } else if (selectionToOffset) {
+      tr.setSelection(TextSelection.create(
+        tr.doc,
+        selectionToOffset && selectionToOffset + start
+      ));
+    } else {
+      const $start = tr.doc.resolve(start);
+      const sel = TextSelection.findFrom($start, 1, true);
+      if (sel) {
+        tr.setSelection(sel);
+      }
+    }
+  }
+  const deleteItemIfWanted = () => {
+    if (!dispatch) return;
+    if (move) {
+      const isLastItem = $item.index(-1) === 0;
+      const offset = isLastItem ? 2 : 1;
+      const start = $item.start() - offset;
+      const end = $item.end() + offset;
+      tr.delete(start, end);
+    }
+  };
+  if (position === "after") {
+    if (!nodeAfterIsList) {
+      const slice = tr.doc.slice($item.start() - 1, $item.end() + 1);
+      deleteItemIfWanted();
+      if (dispatch) tr.replace(tr.mapping.map($target.end()), void 0, slice);
+      restoreSelection(tr.mapping.map($target.end()) + 2);
+      return true;
+    } else {
+      let start = $targetItem.start() + $targetItem.node().child(0).nodeSize;
+      let end = start + $targetItem.node().child(1).nodeSize;
+      const slice = new Slice(
+        Fragment.from([itemNode.create({}), $item.node()]),
+        1,
+        1
+      );
+      deleteItemIfWanted();
+      start = tr.mapping.map(start);
+      end = tr.mapping.map(end);
+      if (dispatch) {
+        tr.step(new ReplaceAroundStep(
+          start,
+          end,
+          start,
+          end,
+          slice,
+          slice.size,
+          false
+        ));
+      }
+      restoreSelection(start + 1);
+      return true;
+    }
+  }
+  if (position === "before") {
+    deleteItemIfWanted();
+    const start = tr.mapping.map($target.before(targetIsContentless ? void 0 : -1));
+    if (dispatch) tr.insert(start, $item.node());
+    restoreSelection(start);
+    return true;
+  }
+  if (position === "child") {
+    const slice = new Slice(
+      Fragment.from([listNode.create({}, $item.node())]),
+      0,
+      nodeAfterIsList ? 1 : 0
+    );
+    deleteItemIfWanted();
+    const unmappedStart = $target.start() + $target.node().child(0).nodeSize + (targetIsContentless ? 0 : 1);
+    const start = tr.mapping.map(unmappedStart);
+    const end = nodeAfterIsList ? start + 1 : void 0;
+    if (dispatch) tr.replace(start, end, slice);
+    restoreSelection(start + 1);
+    return true;
+  }
+  return false;
+};

package/dist/runtime/pm/features/Blocks/commands/deleteItem.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        deleteItem: {
+            /**
+             * @redirectable
+             */
+            deleteItem: (pos?: number | undefined) => ReturnType;
+        };
+    }
+}
+export declare const deleteItem: (type: string) => (pos?: number | undefined) => Command;

package/dist/runtime/pm/features/Blocks/commands/deleteItem.js

@@ -0,0 +1,8 @@
+import { redirectFromEmbedded } from "../../EmbeddedDocument/utils/redirectFromEmbedded.js";
+export const deleteItem = (type) => (pos) => ({ view, commands }) => {
+  const redirect = redirectFromEmbedded(view, "deleteItem", { args: [pos], view, commands });
+  if (redirect.redirected) {
+    return redirect.result;
+  }
+  return commands.deleteNodes(type, pos);
+};

package/dist/runtime/pm/features/Blocks/commands/indentItem.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "@tiptap/core";
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        indentItem: {
+            /**
+             * @redirectable
+             */
+            indentItem: (from?: number, to?: number) => ReturnType;
+        };
+    }
+}
+export declare const indentItem: (itemTypeName: string, listTypeName: string) => (from?: number, to?: number) => Command;