@blokkli/editor 2.0.0-alpha.4 → 2.0.0-alpha.41

package/dist/runtime/editor/features/dragging-overlay/Renderer/index.vue.d.ts

@@ -0,0 +1,30 @@
+import type { Rectangle } from '#blokkli/editor/types/geometry';
+import type { DraggableItem } from '#blokkli/editor/types/draggable';
+type __VLS_Props = {
+    items: DraggableItem[];
+    box: Rectangle;
+    mouseX: number;
+    mouseY: number;
+    isTouch: boolean;
+};
+declare var __VLS_7: {
+    backgroundColor: any;
+    color: any;
+    label: any;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    drop: (data: DropTargetEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDrop?: ((data: DropTargetEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/editor/features/dragging-overlay/Renderer/vertex.glsl

@@ -0,0 +1,183 @@
+#version 300 es
+
+precision highp float;
+
+in vec2 a_position;
+in vec4 a_quad;
+in float a_rect_id;
+in float a_rect_type;
+in float a_state;
+
+uniform float u_scale;
+uniform float u_offset_x;
+uniform float u_offset_y;
+uniform vec2 u_resolution;
+uniform float u_active_rect_id;
+uniform vec3 u_color_area;
+uniform vec3 u_color_hover_area;
+uniform vec4 u_active_hover_rect;
+uniform float u_active_hover_nesting_level;
+uniform float u_field_min_size;
+uniform float u_dpi;
+uniform vec3 u_field_0[4];
+uniform vec3 u_field_1[4];
+uniform vec3 u_field_2[4];
+uniform vec3 u_field_3[4];
+uniform vec3 u_drop_area[4];
+
+out vec4 v_quad;
+out float v_intersecting;
+out float v_is_hover_area;
+out float v_is_field;
+out float v_is_drop_area;
+out float v_is_vertical;
+out vec3 v_color;
+out vec3 v_grad_start;
+out vec3 v_grad_end;
+out vec3 v_border_outer;
+out vec3 v_border_inner;
+
+// Optimized varyings - values computed once per vertex instead of per pixel
+out vec2 v_size;
+out vec2 v_location;
+out vec2 v_size_inner;
+out float v_thickness;
+out float v_border_width;
+out float v_edge_softness;
+out float v_radius_outer;
+out float v_radius_inner;
+out float v_fill_alpha;
+
+vec4 getQuad() {
+  if (a_rect_type >= 5.0) {
+    // Return the quad coming in via uniform.
+    return u_active_hover_rect;
+  }
+  // Use the provided quad.
+  return a_quad;
+}
+
+vec3 getFieldColor(int idx, int kind) {
+  // kind: 0=gradStart, 1=gradEnd, 2=borderOuter, 3=borderInner
+  if (idx == 1) {
+    return u_field_1[kind];
+  } else if (idx == 2) {
+    return u_field_2[kind];
+  } else if (idx == 3) {
+    return u_field_3[kind];
+  }
+  return u_field_0[kind];
+}
+
+void main() {
+  vec4 quad = getQuad();
+
+  bool is_field = a_rect_type >= 1.0 && a_rect_type < 5.0;
+  bool is_active = a_rect_id == u_active_rect_id;
+  bool is_empty = a_state > 1.5;
+  bool is_vertical_shrink = a_state > 0.5;
+
+  if (is_field && !is_active) {
+    float minSize = u_field_min_size;
+    if (is_vertical_shrink) {
+      float newHeight = min(minSize, quad.w);
+      quad.y += (quad.w - newHeight) * 0.5;
+      quad.w = newHeight;
+    } else {
+      float newWidth = min(minSize, quad.z);
+      quad.x += (quad.z - newWidth) * 0.5;
+      quad.z = newWidth;
+    }
+  }
+  vec2 offsetPosition = a_position * u_scale;
+  offsetPosition.x += u_offset_x;
+  offsetPosition.y += u_offset_y;
+
+  vec2 normalizedPosition = offsetPosition / u_resolution;
+
+  // Transform to screen space (-1 to 1)
+  vec2 screenSpacePosition = normalizedPosition * 2.0 - vec2(1.0, 1.0);
+  screenSpacePosition.y = -screenSpacePosition.y;
+
+  // Output final position in clip space
+  gl_Position = vec4(screenSpacePosition, 0.0, 1.0);
+  v_intersecting = a_rect_id == u_active_rect_id ? 1.0 : 0.0;
+
+  // Transform the quad.
+  vec4 transformed_quad = vec4(
+    (quad.x * u_scale + u_offset_x) * u_dpi,
+    (u_resolution.y - quad.y * u_scale - quad.w * u_scale - u_offset_y) * u_dpi,
+    quad.z * u_scale * u_dpi,
+    quad.w * u_scale * u_dpi
+  );
+  v_quad = transformed_quad;
+
+  v_is_hover_area = a_rect_type >= 5.0 ? 1.0 : 0.0;
+  v_is_field = a_rect_type >= 1.0 && a_rect_type < 5.0 ? 1.0 : 0.0;
+  v_is_drop_area = a_rect_type < 1.0 ? 1.0 : 0.0;
+  v_is_vertical = is_empty ? 0.0 : (is_vertical_shrink ? 1.0 : 0.0);
+
+  bool is_drop_target = a_rect_type <= 0.5;
+
+  // Set correct colors based on type.
+  if (a_rect_type < 1.0) {
+    v_color = u_color_area;
+  } else if (a_rect_type < 2.0) {
+    v_color = u_color_area;
+  } else if (a_rect_type < 3.0) {
+    v_color = u_color_area;
+  } else if (a_rect_type < 4.0) {
+    v_color = u_color_area;
+  } else if (a_rect_type < 5.0) {
+    v_color = u_color_area;
+  } else {
+    v_color = u_color_hover_area;
+  }
+
+  if (v_is_field >= 0.5) {
+    int idx = int(floor(a_rect_type - 1.0));
+    idx = int(clamp(float(idx), 0.0, 3.0));
+    v_grad_start = getFieldColor(idx, 0);
+    v_grad_end = getFieldColor(idx, 1);
+    v_border_outer = getFieldColor(idx, 2);
+    v_border_inner = getFieldColor(idx, 3);
+  } else if (v_is_drop_area >= 0.5) {
+    v_grad_start = u_drop_area[0];
+    v_grad_end = u_drop_area[1];
+    v_border_outer = u_drop_area[2];
+    v_border_inner = u_drop_area[3];
+  } else {
+    v_grad_start = v_color;
+    v_grad_end = v_color;
+    v_border_outer = v_color;
+    v_border_inner = v_color;
+  }
+
+  // Compute values that are constant per quad (optimization)
+  bool isHoverArea = v_is_hover_area >= 1.0;
+  float stroke = isHoverArea ? 0.5 : 1.0;
+  float radiusBase = 4.0;
+
+  v_thickness = max(min(1.0 * u_scale, 3.0), 0.5);
+  v_size = vec2(transformed_quad.z, transformed_quad.w);
+  v_location = vec2(
+    transformed_quad.x + v_size.x / 2.0,
+    transformed_quad.y + v_size.y / 2.0
+  );
+
+  v_edge_softness = 0.5 * u_dpi;
+
+  float borderWidth = stroke * u_scale * u_dpi;
+  float maxBorder = min(v_size.x, v_size.y) * 0.25;
+  borderWidth = min(borderWidth, maxBorder);
+  v_border_width = borderWidth;
+
+  // Different radius for inner and outer (based on full quad size)
+  v_radius_outer =
+    min(radiusBase * u_dpi, min(v_size.x, v_size.y) / 2.0);
+  v_radius_inner = max(v_radius_outer - borderWidth, 0.0);
+
+  v_size_inner = v_size - 2.0 * borderWidth;
+
+  v_fill_alpha = v_is_hover_area >= 1.0 ? 0.5 : 1.0;
+}

package/dist/runtime/editor/features/dragging-overlay/index.d.vue.ts

@@ -0,0 +1,3 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/editor/features/dragging-overlay/index.vue

@@ -0,0 +1,345 @@
+<template>
+  <Renderer
+    v-if="dragItems.length && isVisible"
+    v-slot="{ backgroundColor, color, label }"
+    :items="dragItems"
+    :box="box"
+    :mouse-x="mouseX"
+    :mouse-y="mouseY"
+    :is-touch="isTouching"
+  >
+    <DragItems
+      ref="dragItemsComponent"
+      :x="mouseX"
+      :y="mouseY"
+      :start-coords="startCoords"
+      :items="dragItems"
+      :is-touch="isTouching"
+      :background-color
+      :color
+      :active-label="label"
+    />
+  </Renderer>
+  <Teleport to="#bk-canvas-overlay">
+    <BlokkliTransition name="caret-tooltip">
+      <BundleSelector
+        v-if="bundleSelectorData"
+        :bundles="bundleSelectorData.bundles"
+        :label="
+  $t('draggingOverlaySelectBundle', 'Select block type to create')
+"
+        :anchor-coordinates="bundleSelectorData.anchorCoordinates"
+        hide-actions
+        @close="onCloseBundleSelector"
+        @select="onSelectBundle"
+      />
+    </BlokkliTransition>
+  </Teleport>
+</template>
+
+<script setup>
+import DragItems from "./DragItems/index.vue";
+import Renderer from "./Renderer/index.vue";
+import {
+  ref,
+  useBlokkli,
+  onUnmounted,
+  defineBlokkliFeature,
+  nextTick,
+  useTemplateRef
+} from "#imports";
+import { renderCycle } from "#blokkli/editor/helpers/vue";
+import { BundleSelector, BlokkliTransition } from "#blokkli/editor/components";
+import { onBlokkliEvent, defineDropHandler } from "#blokkli/editor/composables";
+import { MOUSE_BUTTON } from "#blokkli/editor/helpers/dom";
+const { adapter } = defineBlokkliFeature({
+  icon: "bk_mdi_drag_pan",
+  id: "dragging-overlay",
+  label: "Dragging Overlay",
+  description: "Renders an overlay when dragging or placing a block.",
+  screenshot: "feature-dragging-overlay.jpg"
+});
+const {
+  eventBus,
+  state,
+  ui,
+  animation,
+  dom,
+  selection,
+  definitions,
+  blocks,
+  directive,
+  fields,
+  $t,
+  dragdrop
+} = useBlokkli();
+const bundleSelectorData = ref(null);
+let bundleSelectorResolve = null;
+function showBundleSelector(bundles) {
+  return new Promise((resolve) => {
+    bundleSelectorResolve = resolve;
+    bundleSelectorData.value = {
+      bundles,
+      anchorCoordinates: getAnchorCoordinates()
+    };
+  });
+}
+function onCloseBundleSelector() {
+  bundleSelectorData.value = null;
+  if (bundleSelectorResolve) {
+    bundleSelectorResolve(null);
+    bundleSelectorResolve = null;
+  }
+}
+function onSelectBundle(bundle) {
+  bundleSelectorData.value = null;
+  if (bundleSelectorResolve) {
+    bundleSelectorResolve(bundle);
+    bundleSelectorResolve = null;
+  }
+}
+const dragItemsComponent = useTemplateRef("dragItemsComponent");
+const isVisible = ref(false);
+const isTouching = ref(false);
+const mouseX = ref(0);
+const mouseY = ref(0);
+const startCoords = ref({
+  x: 0,
+  y: 0
+});
+const box = ref({
+  x: 0,
+  y: 0,
+  width: 10,
+  height: 10
+});
+const dragItems = ref([]);
+function getAnchorCoordinates() {
+  return ui.toArtboardCoords({
+    x: mouseX.value,
+    y: mouseY.value
+  });
+}
+defineDropHandler("existing", {
+  async execute({ items, host, afterUuid }) {
+    const uuids = items.map((v) => v.block.uuid);
+    const isCopy = items.some((v) => v.isCopy);
+    if (isCopy && adapter.pasteExistingBlocks) {
+      await state.mutateWithLoadingState(
+        () => adapter.pasteExistingBlocks({
+          uuids,
+          host: {
+            type: host.type,
+            uuid: host.uuid,
+            fieldName: host.fieldName
+          },
+          preceedingUuid: afterUuid
+        })
+      );
+    } else {
+      await state.mutateWithLoadingState(
+        () => adapter.moveMultipleBlocks({
+          uuids,
+          afterUuid,
+          host
+        })
+      );
+    }
+    if (uuids.length >= 1 && uuids.length <= 10) {
+      for (let i = 0; i < uuids.length; i++) {
+        dom.refreshBlockRect(uuids[i]);
+      }
+    }
+    if (ui.isMobile.value && uuids.length) {
+      eventBus.emit("scrollIntoView", {
+        uuid: uuids[0],
+        center: true
+      });
+    }
+  }
+});
+let allUuidsBefore = [];
+let lastDropResult = null;
+const onDrop = async (e) => {
+  allUuidsBefore = state.getAllUuids();
+  await nextTick(async () => {
+    const itemType = e.items[0]?.itemType;
+    if (!itemType) {
+      return;
+    }
+    const handler = dragdrop.getDropHandler(itemType);
+    if (!handler) {
+      return;
+    }
+    const baseCtx = {
+      items: e.items,
+      field: e.field,
+      host: e.host,
+      afterUuid: e.preceedingUuid ?? null
+    };
+    let result;
+    if (handler.resolveBundles) {
+      const bundles = await handler.resolveBundles(baseCtx);
+      if (bundles.length === 0) {
+        return;
+      }
+      let bundle;
+      if (bundles.length === 1) {
+        bundle = bundles[0];
+      } else {
+        const selected = await showBundleSelector(bundles);
+        if (!selected) {
+          return;
+        }
+        bundle = selected;
+      }
+      result = await handler.execute({ ...baseCtx, bundle }) || void 0;
+    } else {
+      result = await handler.execute({ ...baseCtx, bundle: "" }) || void 0;
+    }
+    lastDropResult = result ?? null;
+    eventBus.emit("dragging:end");
+    eventBus.emit("item:dropped");
+  });
+  mouseX.value = 0;
+  mouseY.value = 0;
+};
+onBlokkliEvent("state:reloaded", async function() {
+  if (!allUuidsBefore.length) {
+    return;
+  }
+  const allUuidsAfter = state.getAllUuids();
+  const newUuid = allUuidsAfter.find((uuid) => !allUuidsBefore.includes(uuid));
+  const dropResult = lastDropResult;
+  allUuidsBefore = [];
+  lastDropResult = null;
+  if (!newUuid) {
+    return;
+  }
+  eventBus.emit("select", newUuid);
+  await renderCycle();
+  const newBlock = blocks.getBlock(newUuid);
+  if (!newBlock) {
+    return;
+  }
+  const allSelected = [...selection.uuids.value, newBlock.uuid];
+  eventBus.emit("select", allSelected);
+  if (!dropResult?.focusEditable) {
+    return;
+  }
+  const definition = definitions.getBlockDefinition(
+    newBlock.bundle,
+    newBlock.fieldListType
+  );
+  if (!definition?.editor?.addBehaviour?.startsWith("editable:")) {
+    return;
+  }
+  const editableField = definition.editor.addBehaviour.split(":")[1];
+  if (!editableField) {
+    return;
+  }
+  const editableFieldElement = directive.getEditablesForBlock(newUuid).find((v) => v.fieldName === editableField);
+  if (!editableFieldElement) {
+    return;
+  }
+  eventBus.emit("editable:open", {
+    fieldName: editableField,
+    uuid: newUuid
+  });
+});
+onBlokkliEvent("dragging:move", (e) => {
+  mouseX.value = e.x;
+  mouseY.value = e.y;
+});
+onBlokkliEvent("dragging:drop", onDrop);
+function loop() {
+  if (!isVisible.value) {
+    isVisible.value = true;
+  }
+  if (!dragItemsComponent.value) {
+    return;
+  }
+  box.value = dragItemsComponent.value.getRect();
+}
+const onMouseUp = (e) => {
+  if (e.button === MOUSE_BUTTON.AUXILIARY) {
+    return;
+  }
+  e.preventDefault();
+  e.stopPropagation();
+  if (!ui.isMobile.value) {
+    eventBus.emit("dragging:end");
+  }
+};
+function onMouseMove(e) {
+  mouseX.value = e.clientX;
+  mouseY.value = e.clientY;
+}
+onBlokkliEvent("dragging:start", (e) => {
+  isTouching.value = e.mode === "touch";
+  startCoords.value = e.coords;
+  animation.requestDraw();
+  const item = e.items[0];
+  if (!item) {
+    return;
+  }
+  mouseX.value = e.coords.x;
+  mouseY.value = e.coords.y;
+  dom.updateVisibleRects();
+  dragItems.value = e.items;
+  if (!isTouching.value) {
+    document.removeEventListener("pointerup", onMouseUp);
+    document.addEventListener("pointerup", onMouseUp);
+    document.removeEventListener("pointermove", onMouseMove, {
+      capture: true
+    });
+    document.addEventListener("pointermove", onMouseMove, { capture: true });
+  }
+  eventBus.on("animationFrame", loop);
+});
+onBlokkliEvent("dragging:end", () => {
+  isVisible.value = false;
+  dragItems.value = [];
+  eventBus.off("animationFrame", loop);
+  document.removeEventListener("pointerup", onMouseUp);
+  document.removeEventListener("pointermove", onMouseMove, { capture: true });
+});
+onBlokkliEvent("keyPressed", (e) => {
+  if (ui.hasDialogOpen.value) {
+    return;
+  }
+  if (e.code === "Escape") {
+    eventBus.emit("dragging:end");
+  }
+});
+onBlokkliEvent("block:append", async (e) => {
+  allUuidsBefore = state.getAllUuids();
+  const handler = dragdrop.getDropHandler("new");
+  if (handler) {
+    const result = await handler.execute({
+      items: [
+        {
+          itemType: "new",
+          itemBundle: e.bundle,
+          element: () => document.createElement("div")
+        }
+      ],
+      field: fields.find(e.host.uuid, e.host.fieldName),
+      host: e.host,
+      afterUuid: e.afterUuid,
+      bundle: e.bundle
+    });
+    lastDropResult = result ?? null;
+  }
+});
+onUnmounted(() => {
+  document.removeEventListener("pointerup", onMouseUp);
+  document.removeEventListener("pointermove", onMouseMove, { capture: true });
+});
+</script>
+
+<script>
+export default {
+  name: "DraggingOverlay"
+};
+</script>

package/dist/runtime/editor/features/dragging-overlay/index.vue.d.ts

@@ -0,0 +1,3 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/editor/features/duplicate/index.d.vue.ts

@@ -0,0 +1,3 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/editor/features/duplicate/index.vue

@@ -0,0 +1,105 @@
+<template>
+  <PluginItemAction
+    id="duplicate"
+    :title="$t('duplicate', 'Duplicate')"
+    :disabled="!canDuplicate"
+    edit-only
+    meta
+    key-code="D"
+    multiple
+    icon="duplicate"
+    :weight="-90"
+    @click="onClick"
+  />
+</template>
+
+<script setup>
+import { computed, useBlokkli, defineBlokkliFeature } from "#imports";
+import { PluginItemAction } from "#blokkli/editor/plugins";
+import { getFieldKey } from "#blokkli/helpers";
+import { getArrayDiff } from "#blokkli/editor/helpers/array";
+const { state, $t, selection, types, eventBus } = useBlokkli();
+const { adapter } = defineBlokkliFeature({
+  id: "duplicate",
+  icon: "duplicate",
+  label: "Duplicate",
+  requiredAdapterMethods: ["duplicateBlocks"],
+  description: "Provides an action to duplicate one or more blocks in place."
+});
+async function onClick(items) {
+  const uuidsBefore = state.getAllUuids();
+  const success = await state.mutateWithLoadingState(
+    () => adapter.duplicateBlocks(items.map((v) => v.uuid)),
+    $t("duplicateError", "The items could not be duplicated.")
+  );
+  if (!success) {
+    return;
+  }
+  const diff = getArrayDiff(uuidsBefore, state.getAllUuids()).filter(
+    (uuid, _, arr) => !arr.some((other) => state.isChildOf(uuid, other))
+  );
+  if (!diff.length) {
+    return;
+  }
+  eventBus.emit("select", diff);
+  const firstUuid = diff[0];
+  eventBus.emit("scrollIntoView", { uuid: firstUuid });
+}
+const canDuplicate = computed(() => {
+  const blocksByField = {};
+  const fieldsByKey = {};
+  const selectedCount = selection.items.value.length;
+  for (let i = 0; i < selectedCount; i++) {
+    const block = selection.items.value[i];
+    const field = state.getMutatedField(block.host.uuid, block.host.fieldName);
+    if (!field) {
+      continue;
+    }
+    const fieldKey = getFieldKey(field.entityUuid, field.name);
+    const fieldConfig = types.getFieldConfig(
+      field.entityType,
+      block.host.bundle,
+      field.name
+    );
+    if (!fieldConfig) {
+      continue;
+    }
+    const count = field.list.length;
+    if (fieldConfig.cardinality !== -1 && count >= fieldConfig.cardinality) {
+      return false;
+    }
+    if (!blocksByField[fieldKey]) {
+      blocksByField[fieldKey] = [];
+    }
+    blocksByField[fieldKey].push(block);
+    fieldsByKey[fieldKey] = {
+      cardinality: fieldConfig.cardinality,
+      allowedBundles: fieldConfig.allowedBundles,
+      count
+    };
+  }
+  const entries = Object.entries(blocksByField);
+  for (let i = 0; i < entries.length; i++) {
+    const [fieldKey, blocks] = entries[i];
+    const field = fieldsByKey[fieldKey];
+    if (!field) {
+      return false;
+    }
+    const count = state.getFieldBlockCount(fieldKey);
+    if (field.cardinality !== -1 && count + blocks.length > field.cardinality) {
+      return false;
+    }
+    const bundles = blocks.map((v) => v.bundle);
+    if (!field.allowedBundles.length || bundles.some((bundle) => !field.allowedBundles.includes(bundle))) {
+      return false;
+    }
+  }
+  return true;
+});
+</script>
+
+<script>
+export default {
+  name: "Duplicate"
+};
+</script>

package/dist/runtime/editor/features/duplicate/index.vue.d.ts

@@ -0,0 +1,3 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/editor/features/duplicate/types.d.ts

@@ -0,0 +1,8 @@
+declare module '#blokkli/editor/adapter' {
+    interface BlokkliAdapter<T> {
+        /**
+         * Duplicate blocks.
+         */
+        duplicateBlocks?: (uuids: string[]) => Promise<MutationResponseLike<T>>;
+    }
+}

package/dist/runtime/editor/features/edit/index.d.vue.ts

@@ -0,0 +1,3 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;