@witchcraft/editor 0.0.5 → 0.0.6

package/dist/runtime/pm/features/Blocks/components/ItemMenu.vue

@@ -0,0 +1,78 @@
+<template>
+<!-- @vue-expect-error -->
+<WPopup
+	:model-value="menu.opened"
+	:preferred-horizontal="['left-most']"
+	:preferred-vertical="popupVerticalPositioner"
+	:position-modifier="popupPositionModifier"
+	ref="popup"
+	@update:model-value="!$event && props.editor.commands.closeItemMenu()"
+>
+	<template #popup="{ extractEl }">
+		<div
+			:ref="extractEl"
+		>
+			<CommandsMenuList
+				:entries="commandsMenu"
+				@close="props.editor.commands.closeItemMenu()"
+			/>
+		</div>
+	</template>
+</WPopup>
+</template>
+
+<script setup>
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import WPopup from "@witchcraft/ui/components/LibPopup";
+import { computed, provide, ref, toRef, watch } from "vue";
+import { defaultItemMenu as commandsMenu } from "./defaultItemMenu.js";
+import CommandsMenuList from "../../CommandsMenus/components/CommandMenuList.vue";
+import { commandExecuterInjectionKey, menuBlockIdInjectionKey, menuEditorInjectionKey } from "../../CommandsMenus/types.js";
+import { popupPositionModifier } from "../../CommandsMenus/utils/popupPositionModifier.js";
+import { popupVerticalPositioner } from "../../CommandsMenus/utils/popupVerticalPositioner.js";
+import { itemMenuPluginKey } from "../types.js";
+import { createItemMenuCommandExecuter } from "../utils/createItemMenuCommandExecuter.js";
+const props = defineProps({
+  editor: { type: null, required: true }
+});
+const menu = ref({ opened: false, id: void 0 });
+const popup = ref();
+const virtualMenuEl = ref(null);
+function virtualGetBoundingClientRect() {
+  const el = props.editor.view.dom.querySelector(`li[blockid='${menu.value.id}']`);
+  const handle = el?.parentElement?.querySelector(".grab-handle");
+  if (handle instanceof HTMLElement) {
+    const rect = handle.getBoundingClientRect();
+    return {
+      // rect cannot be spread normally, it's properties are not enumerable
+      ...rect.toJSON(),
+      width: 0
+      // override the width of the item, we want it to be ignored
+      // we want to keep the height though, since we want the menu centered to it if possible
+    };
+  }
+  unreachable();
+}
+function updateState({ editor }) {
+  const was = menu.value;
+  const willBe = itemMenuPluginKey.getState(editor.state) ?? menu.value;
+  if (willBe.opened && (was.opened !== willBe.opened || was.id !== willBe.id)) {
+    virtualMenuEl.value = { getBoundingClientRect: virtualGetBoundingClientRect };
+    popup.value.setReference(virtualMenuEl.value);
+  } else if (virtualMenuEl.value && !willBe.opened) {
+    virtualMenuEl.value = null;
+    popup.value.setReference(virtualMenuEl.value);
+  }
+  menu.value = willBe;
+}
+const editorRef = toRef(props, "editor");
+provide(menuEditorInjectionKey, editorRef);
+const blockId = computed(() => menu.value.id);
+provide(menuBlockIdInjectionKey, blockId);
+provide(commandExecuterInjectionKey, createItemMenuCommandExecuter(() => blockId.value));
+watch(() => props.editor, (newVal, oldVal) => {
+  oldVal.off("transaction", updateState);
+  newVal.on("transaction", updateState);
+});
+props.editor.on("transaction", updateState);
+</script>

package/dist/runtime/pm/features/Blocks/components/ItemMenu.vue.d.ts

@@ -0,0 +1,6 @@
+import type { Editor } from "@tiptap/core";
+type __VLS_Props = {
+    editor: Editor;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/pm/features/Blocks/components/ItemNodeView.d.vue.ts

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

package/dist/runtime/pm/features/Blocks/components/ItemNodeView.vue

@@ -0,0 +1,350 @@
+<template>
+<!-- The component requires the following global css variables to be set, see CssVariables type:
+	--dragHandleSize
+	--dragHandleMargin
+	--dragHandleImage
+	--dragHandleCollapseIndicatorImage
+	--pmNodeTypeMargin
+	--pmDragDropIndicatorHeight
+-->
+<!-- @vue-expect-error role is a valid attribute -->
+<node-view-wrapper
+	:class="twMerge(
+  `
+		group/item
+		pl-[calc(var(--dragHandleSize)+var(--dragHandleMargin)+var(--spacing))]
+		relative
+	`,
+  passedDragThreshold && `
+		pointer-events-none
+		bg-neutral-100
+		dark:bg-neutral-900
+		rounded-sm
+	`
+)"
+	role="listitem"
+	:style="
+  `
+		--counterStyle:${counterStyle};
+		--nodeState:${nodeState?.icon};
+		--typeHandleHeight:${typeHandleHeight}px;
+	`
+"
+	v-extract-root-el="(el) => itemEl = el"
+>
+	<DragTreeHandle
+		:has-children="hasChildren"
+		:hide-children="node.attrs.hideChildren"
+		:passed-drag-threshold="passedDragThreshold"
+		:class="twMerge(
+  `[&>.collapse-indicator]:h-[var(--typeHandleHeight)]`,
+  hasSingularSelection && `
+				group-[.using-touch]:flex
+				group-[.using-touch]:opacity-100
+			`
+)"
+		@collapse-indicator-click="collapseIndicatorClick"
+		@grab-handle-pointer-down="grabPointerDown"
+		@grab-handle-passive-touch-start="touchStart"
+		@grab-handle-context-menu="editor.commands.toggleItemMenu(props.node.attrs.blockId)"
+	/>
+	<div
+		contenteditable="false"
+		:class="
+  twMerge(
+    `type-handle
+				flex flex-col justify-center items-center
+				w-[1.2rem]
+				center
+				left-[calc(var(--dragHandleSize)+var(--dragHandleMargin))+var(--pmNodeTypeMargin)]
+				absolute
+				z-[1]
+			`,
+    node.attrs.type.startsWith('ordered') && `
+					[counter-increment:ordered]
+					after:content-[counter(ordered,var(--counterStyle))_\'.\']
+				`,
+    node.attrs.type.startsWith('unordered') && `
+					after:content-[counter(none,var(--counterStyle))]
+				`,
+    node.attrs.type.startsWith('stateful') && `
+					after:h-[1.2rem]
+					after:content-[var(--nodeState)]
+					after:cursor-pointer
+					hover:after:[filter:drop-shadow(0px_1px_1px_rgba(0,0,0,0.4))]
+					hover:after:content-[var(--nodeState)]
+				`,
+    node.attrs.type === 'none' && `
+				hidden
+			`,
+    `type-${node.attrs.type}`
+  )
+"
+		:style="`
+			height:var(--typeHandleHeight);
+		`"
+		:role="node.attrs.type.startsWith('stateful') ? 'checkbox' : ''"
+		:aria-checked="node.attrs.state"
+		tabindex="0"
+		@pointerdown="typeHandlePointerDown"
+	/>
+	<node-view-content
+		as="li"
+		v-bind="node.attrs"
+		:class="twMerge(
+  `
+			item-content
+			[counter-reset:ordered]
+			relative
+			flex
+			block
+			full
+		`,
+  node.attrs.hideChildren && `
+				[&_ul.list]:hidden
+			`,
+  node.attrs.type !== 'none' && `
+				pl-[calc(1.2rem+var(--pmNodeTypeMargin))]
+				`
+)"
+	/>
+</node-view-wrapper>
+<Teleport
+	v-if="passedDragThreshold && pointerCoords"
+	:to="teleportTo"
+>
+	<div
+		:id="cloneId"
+		class="
+				item-node-clone
+				fixed
+				cursor-pointer
+				scale-50
+				-m-2
+				pointer-events-none
+				select-none
+				bg-bg
+				dark:bg-neutral-900
+				border-neutral-500
+				border
+				rounded-sm
+				p-3
+			"
+		:style="`left:${pointerCoords.x}px;top:${pointerCoords.y}px`"
+	/>
+</Teleport>
+
+<Teleport
+	v-if="dropIndicator !== void 0 && !scroll?.isScrolling.value"
+	:to="teleportTo"
+>
+	<div
+		class="
+		fixed
+		h-[var(--pmDragDropIndicatorHeight,5px)]
+		bg-accent-500
+		opacity-50
+	"
+		:style="`
+			left:${dropIndicator.x}px;
+			top:calc(${dropIndicator.y}px ${dropIndicator.type !== 'before' ? `- (var(--pmDragDropIndicatorHeight, 5px))` : ''});
+			width:calc(${dropIndicator.width}px);
+		`"
+	/>
+</Teleport>
+</template>
+
+<script setup>
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { NodeViewContent, nodeViewProps, NodeViewWrapper } from "@tiptap/vue-3";
+import { useDragWithThreshold } from "@witchcraft/ui/composables/useDragWithThreshold";
+import { vExtractRootEl } from "@witchcraft/ui/directives/vExtractRootEl";
+import { twMerge } from "tailwind-merge";
+import { computed, inject, nextTick, onMounted, ref, watch } from "vue";
+import DragTreeHandle from "./DragTreeHandle.vue";
+import { editorScrollInjectionKey, editorTeleportToInjectionKey } from "../../../../injectionKeys.js";
+import { createDropIndicator } from "../../../utils/createDropIndicator.js";
+import { dropPointInfo } from "../../../utils/dropPointInfo.js";
+import { findUpwards } from "../../../utils/findUpwards.js";
+import { getElMaxVisualSize } from "../../../utils/getElMaxVisualSize.js";
+import { getElPropertyAsInt } from "../../../utils/getElPropertyAsInt.js";
+import { debugNode } from "../../../utils/internal/debugNode.js";
+import { useHandleHeight } from "../composables/useHandleHeight.js";
+import { useNodeStates } from "../composables/useNodeStates.js";
+import { statesInjectionKey } from "../types.js";
+const props = defineProps(nodeViewProps);
+const itemEl = ref(null);
+const hasChildren = computed(() => props.node.childCount > 1);
+const { handleHeight: typeHandleHeight, recalculateHandleHeight } = useHandleHeight(itemEl);
+watch([() => props.node, () => props.decorations], () => {
+  nextTick(() => {
+    recalculateHandleHeight();
+  });
+});
+const states = inject(statesInjectionKey);
+const { nodeState, counterStyle } = useNodeStates(props);
+const hasSingularSelection = computed(() => props.decorations.find((deco) => deco.type.attrs.hasSingularSelection));
+const teleportTo = inject(editorTeleportToInjectionKey, "body");
+const cloneId = `editor-item-node-clone`;
+const {
+  pointerCoords,
+  passedDragThreshold,
+  startDragThresholdCheck,
+  endDragThresholdCheck,
+  checkDragThreshold
+} = useDragWithThreshold({ threshold: ref(5) });
+const scroll = inject(editorScrollInjectionKey);
+if (!scroll) {
+  throw new Error("editorScrollInjectionKey must be provided.");
+}
+const draggedEl = ref(null);
+const dropIndicator = ref(void 0);
+let dropoverEl;
+let firstDragEvent = false;
+function stopDrag() {
+  firstDragEvent = false;
+  props.editor.commands.setCursorVisible(true);
+  if ("enableMarkMenus" in props.editor.commands) {
+    ;
+    props.editor.commands.enableMarkMenus();
+  }
+  endDragThresholdCheck();
+  document.removeEventListener("keyup", escapeDrag);
+  document.removeEventListener("pointermove", grabPointerMove);
+  document.removeEventListener("pointerup", grabPointerUp);
+  scroll?.endScroll();
+  const clone = document.querySelector(`#${cloneId}`);
+  if (clone) clone.innerHTML = "";
+  draggedEl.value = null;
+  dropoverEl = void 0;
+  dropIndicator.value = void 0;
+}
+function escapeDrag(e) {
+  if (e.code === "Escape") stopDrag();
+}
+function grabPointerDown(e) {
+  e.preventDefault();
+  startDragThresholdCheck(e);
+  if (e.button !== 0) return;
+  document.addEventListener("pointermove", grabPointerMove);
+  document.addEventListener("pointerup", grabPointerUp);
+  document.addEventListener("keyup", escapeDrag);
+}
+function grabPointerMove(e) {
+  e.preventDefault();
+  checkDragThreshold(e);
+  if (passedDragThreshold.value) {
+    if (!firstDragEvent) {
+      firstDragEvent = true;
+      props.editor.commands.setCursorVisible(false);
+      if ("disableMarkMenus" in props.editor.commands) {
+        ;
+        props.editor.commands.disableMarkMenus();
+      }
+    }
+    if (!draggedEl.value) {
+      draggedEl.value = itemEl.value.cloneNode(true);
+      setTimeout(() => {
+        const clone = document.querySelector(`#${cloneId}`);
+        clone?.append(draggedEl.value);
+      });
+    }
+    scroll?.scrollEdges(e.clientX, e.clientY);
+    if (pointerCoords.value && e.target instanceof HTMLElement) {
+      const editorEl = props.editor.view.dom;
+      const editorBox = editorEl.getBoundingClientRect();
+      const target = document.elementFromPoint(editorBox.x + editorBox.width - 1, pointerCoords.value.y)?.closest(".item-content > *") ?? null;
+      const targetIsSelf = target === itemEl.value || itemEl.value?.contains(target);
+      const targetIsParentIsBlock = target?.parentElement?.classList.contains("item-content");
+      const parentEl = editorEl.parentElement;
+      if (!parentEl || !target || targetIsSelf || !targetIsParentIsBlock) return;
+      const dropOverPos = props.editor.view.posAtDOM(target, 0);
+      if (dropOverPos < 0) {
+        return;
+      }
+      const width = getElMaxVisualSize(parentEl).width;
+      const targetBox = target.getBoundingClientRect();
+      const indentX = getElPropertyAsInt(itemEl.value, "padding-left");
+      const dropInfo = dropPointInfo(pointerCoords.value, targetBox, indentX);
+      dropoverEl = target;
+      dropIndicator.value = createDropIndicator(dropInfo, targetBox, indentX, width);
+    }
+  }
+}
+function grabPointerUp(_e) {
+  if (!passedDragThreshold.value || !props.editor.isEditable) {
+  } else {
+    if (dropoverEl && dropIndicator.value) {
+      const dropOverPos = props.editor.view.posAtDOM(dropoverEl, 0);
+      if (dropOverPos < 0) {
+        stopDrag();
+        return;
+      }
+      const {
+        /* $pos: $dropPos, */
+        pos
+      } = findUpwards(
+        props.editor.state.doc,
+        dropOverPos,
+        ($pos) => $pos.node().type.name === "item",
+        { stop: 2 }
+        // we shouldn't have to go more than 2 nodes up
+      );
+      if (!pos || !pos) {
+        stopDrag();
+        return;
+      }
+      const propsPos = props.getPos();
+      if (!propsPos) unreachable();
+      props.editor.commands.copyOrMoveItem(
+        propsPos + 1,
+        pos,
+        dropIndicator.value.type,
+        {
+          move: true
+        }
+      );
+    }
+  }
+  stopDrag();
+}
+function collapseIndicatorClick(e) {
+  const pos = props.getPos();
+  if (!pos) unreachable();
+  const $pos = props.editor.state.doc.resolve(pos);
+  debugNode($pos.node());
+  const wantedPos = pos + 2;
+  const sel = props.editor.state.selection;
+  props.editor.chain().setTextSelection({ from: wantedPos, to: wantedPos }).changeAttrs("item", { hideChildren: !props.node.attrs.hideChildren }).setTextSelection({ from: sel.from, to: sel.to }).run();
+  e.preventDefault();
+}
+function typeHandlePointerDown(e) {
+  const pos = props.getPos();
+  if (!pos) unreachable();
+  if (nodeState.value) {
+    const wantedPos = pos + 2;
+    const entries = states?.value[counterStyle.value]?.entries;
+    if (entries === void 0) unreachable();
+    let stateIndex = entries.indexOf(nodeState.value);
+    if (stateIndex === -1) unreachable();
+    if (stateIndex + 1 >= entries.length) stateIndex = 0;
+    const sel = props.editor.state.selection;
+    if (props.editor.view.dom !== document.activeElement) {
+      props.editor.commands.focus();
+    }
+    props.editor.chain().setTextSelection({ from: wantedPos, to: wantedPos }).changeItemType({
+      type: props.node.attrs.type,
+      state: entries[stateIndex + 1].value
+    }).setTextSelection({ from: sel.from, to: sel.to }).run();
+    e.preventDefault();
+  }
+}
+function touchStart(e) {
+  e.preventDefault();
+}
+onMounted(() => {
+  nextTick(() => {
+    recalculateHandleHeight();
+  });
+});
+</script>

package/dist/runtime/pm/features/Blocks/components/ItemNodeView.vue.d.ts

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

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

@@ -0,0 +1,5 @@
+export declare const defaultItemMenu: (import("../types.ts").ItemMenuCommand | {
+    type: "group";
+    title: string;
+    variations: import("../types.ts").ItemMenuCommand[];
+})[];

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

@@ -0,0 +1,42 @@
+import {
+  bulletItemCommand,
+  codeBlockCommand,
+  deleteNodesCommand,
+  embeddedDocCommand,
+  heading1Command,
+  heading2Command,
+  heading3Command,
+  heading4Command,
+  heading5Command,
+  heading6Command,
+  numberedItemCommand,
+  paragraphCommand,
+  tableCommand
+} from "../itemMenuMenuItems.js";
+export const defaultItemMenu = [
+  deleteNodesCommand,
+  {
+    type: "group",
+    title: "Change Item Type",
+    variations: [
+      bulletItemCommand,
+      numberedItemCommand
+    ]
+  },
+  {
+    type: "group",
+    title: "Change Block Type",
+    variations: [
+      codeBlockCommand,
+      embeddedDocCommand,
+      paragraphCommand,
+      tableCommand,
+      heading1Command,
+      heading2Command,
+      heading3Command,
+      heading4Command,
+      heading5Command,
+      heading6Command
+    ]
+  }
+];

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+import { type Ref } from "vue";
+export declare function useHandleHeight(handlesEl: Ref<HTMLElement | null>): {
+    handleHeight: Ref<number>;
+    recalculateHandleHeight: () => void;
+};