@blokkli/editor 2.0.0-alpha.28 → 2.0.0-alpha.29

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

@@ -0,0 +1,29 @@
+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: {
+    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/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,438 @@
+<template>
+  <Renderer
+    v-if="dragItems.length && isVisible"
+    v-slot="{ 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"
+      :active-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 } from "#blokkli/editor/composables";
+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
+} = useBlokkli();
+const bundleSelectorData = ref(null);
+function onCloseBundleSelector() {
+  bundleSelectorData.value = null;
+}
+async function onSelectBundle(bundle) {
+  const data = bundleSelectorData.value;
+  if (!data) {
+    return;
+  }
+  const item = data.item;
+  if (Array.isArray(item)) {
+    await onDropMediaLibraryItem(
+      data.field,
+      item,
+      data.host,
+      data.afterUuid,
+      bundle
+    );
+  } else {
+    await state.mutateWithLoadingState(
+      () => adapter.addContentSearchItem({
+        item: item.searchItem,
+        host: data.host,
+        bundle,
+        afterUuid: data.afterUuid
+      })
+    );
+  }
+  onCloseBundleSelector();
+}
+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 isSameItemType(items) {
+  return items.every((item) => item.itemType === items[0].itemType);
+}
+function filterItemType(items) {
+  if (!items.length) {
+    throw new Error("Items array is empty");
+  }
+  if (!isSameItemType(items)) {
+    throw new Error("Items of different types");
+  }
+  const itemType = items[0].itemType;
+  if (itemType === "existing" || itemType === "existing_structure" || itemType === "media_library") {
+    return { itemType, items };
+  }
+  if (items.length > 1) {
+    throw new Error(`Only a single item of type '${itemType}' is allowed.`);
+  }
+  return { itemType, item: items[0] };
+}
+const onDropNew = async (bundle, host, afterUuid) => {
+  const field = fields.find(host.uuid, host.fieldName);
+  if (!field) {
+    throw new Error(
+      `Failed to locate field with name "${host.fieldName}" on UUID "${host.uuid}"`
+    );
+  }
+  const definition = definitions.getBlockDefinition(
+    bundle,
+    field.fieldListType,
+    field.hostEntityBundle
+  );
+  const addBehaviour = definition?.editor?.addBehaviour || "form";
+  if (definition?.editor?.disableEdit || addBehaviour === "no-form" || addBehaviour.startsWith("editable:") || !adapter.formFrameBuilder) {
+    await state.mutateWithLoadingState(
+      () => adapter.addNewBlock({
+        bundle,
+        host,
+        afterUuid
+      })
+    );
+  } else {
+    eventBus.emit("add:block:new", {
+      bundle,
+      host,
+      afterUuid
+    });
+  }
+};
+const onDropExisting = async (items, host, afterUuid) => {
+  const uuids = items.map((v) => v.block.uuid);
+  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
+    });
+  }
+};
+const onDropReusable = async (item, host, afterUuid) => {
+  if (adapter.addLibraryItem) {
+    await state.mutateWithLoadingState(
+      () => adapter.addLibraryItem({
+        libraryItemUuid: item.libraryItemUuid,
+        host,
+        afterUuid
+      })
+    );
+  }
+};
+const onDropClipboardItem = async (item, host, afterUuid) => {
+  eventBus.emit("drop:clipboardItem", {
+    id: item.clipboardId,
+    host,
+    blockBundle: item.itemBundle,
+    afterUuid
+  });
+};
+const onDropMediaLibraryItem = async (field, items, host, afterUuid, bundle) => {
+  const allSameBundles = [...new Set(items.map((v) => v.mediaBundle)).values()].length === 1;
+  if (!allSameBundles) {
+    throw new Error(
+      "Multi select of media library items of different bundles is not supported."
+    );
+  }
+  let targetBundle = bundle;
+  if (targetBundle === null) {
+    const item = items[0];
+    const allowedBundles = field.allowedBundles;
+    const possibleBundles = allowedBundles.filter(
+      (bundle2) => item.itemBundles.includes(bundle2)
+    );
+    if (possibleBundles.length === 0) {
+      throw new Error("This search item can not be placed here.");
+    } else if (possibleBundles.length === 1) {
+      targetBundle = possibleBundles[0];
+    } else {
+      bundleSelectorData.value = {
+        bundles: possibleBundles,
+        anchorCoordinates: getAnchorCoordinates(),
+        item: items,
+        host,
+        afterUuid,
+        field
+      };
+      return;
+    }
+  }
+  if (adapter.mediaLibraryAddBlock && items.length === 1) {
+    await state.mutateWithLoadingState(
+      () => adapter.mediaLibraryAddBlock({
+        preceedingUuid: afterUuid,
+        host,
+        item: items[0],
+        targetBundle
+      })
+    );
+  } else if (adapter.mediaLibraryAddBlocks && items.length > 1) {
+    await state.mutateWithLoadingState(
+      () => adapter.mediaLibraryAddBlocks({
+        preceedingUuid: afterUuid,
+        host,
+        items,
+        targetBundle
+      })
+    );
+  }
+};
+function getAnchorCoordinates() {
+  return ui.toArtboardCoords({
+    x: mouseX.value,
+    y: mouseY.value
+  });
+}
+const onDropSearchContentItem = async (field, item, host, afterUuid) => {
+  if (!adapter.addContentSearchItem) {
+    throw new Error('Adapter does not implement "addContentSearchItem".');
+  }
+  const allowedBundles = field.allowedBundles;
+  const possibleBundles = allowedBundles.filter(
+    (bundle) => item.itemBundles.includes(bundle)
+  );
+  if (possibleBundles.length === 0) {
+    throw new Error("This search item can not be placed here.");
+  } else if (possibleBundles.length === 1) {
+    await state.mutateWithLoadingState(
+      () => adapter.addContentSearchItem({
+        item: item.searchItem,
+        host,
+        bundle: possibleBundles[0],
+        afterUuid
+      })
+    );
+  } else {
+    bundleSelectorData.value = {
+      bundles: possibleBundles,
+      anchorCoordinates: getAnchorCoordinates(),
+      field,
+      item,
+      host,
+      afterUuid
+    };
+  }
+};
+const onDropAction = (action, host, field, afterUuid) => {
+  action.action.callback({
+    preceedingUuid: afterUuid,
+    host,
+    field
+  });
+};
+let allUuidsBefore = [];
+const onDrop = async (e) => {
+  allUuidsBefore = state.getAllUuids();
+  await nextTick(async () => {
+    const afterUuid = e.preceedingUuid ?? null;
+    const host = e.host;
+    const typed = filterItemType(e.items);
+    if (typed.itemType === "existing" || typed.itemType === "existing_structure") {
+      await onDropExisting(typed.items, host, afterUuid);
+    } else if (typed.itemType === "new") {
+      await onDropNew(typed.item.itemBundle, host, afterUuid);
+    } else if (typed.itemType === "reusable") {
+      await onDropReusable(typed.item, host, afterUuid);
+    } else if (typed.itemType === "clipboard") {
+      await onDropClipboardItem(typed.item, host, afterUuid);
+    } else if (typed.itemType === "search_content") {
+      await onDropSearchContentItem(e.field, typed.item, host, afterUuid);
+    } else if (typed.itemType === "action") {
+      onDropAction(typed.item, host, e.field, afterUuid);
+    } else if (typed.itemType === "media_library") {
+      await onDropMediaLibraryItem(e.field, typed.items, host, afterUuid, 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));
+  allUuidsBefore = [];
+  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);
+  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:focus", {
+    fieldName: editableField,
+    uuid: newUuid
+  });
+});
+onBlokkliEvent("dragging:drop", onDrop);
+function loop() {
+  if (!isVisible.value) {
+    isVisible.value = true;
+  }
+  if (!dragItemsComponent.value) {
+    return;
+  }
+  box.value = dragItemsComponent.value.getRect();
+}
+const onMouseUp = (e) => {
+  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", (e) => {
+  allUuidsBefore = state.getAllUuids();
+  onDropNew(e.bundle, e.host, e.afterUuid);
+});
+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>;

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

@@ -0,0 +1,76 @@
+<template>
+  <PluginItemAction
+    id="edit"
+    edit-only
+    :title="$t('edit', 'Edit...')"
+    :disabled="!canEdit"
+    meta
+    key-code="E"
+    icon="bk_mdi_edit"
+    :weight="-100"
+    @click="onClick"
+  />
+</template>
+
+<script setup>
+import { computed, useBlokkli, defineBlokkliFeature } from "#imports";
+import { PluginItemAction } from "#blokkli/editor/plugins";
+import { onBlokkliEvent } from "#blokkli/editor/composables";
+defineBlokkliFeature({
+  id: "edit",
+  icon: "bk_mdi_edit",
+  label: "Edit",
+  description: "Provides an action to edit a block.",
+  requiredAdapterMethods: ["formFrameBuilder"]
+});
+const { eventBus, selection, state, $t, adapter, definitions } = useBlokkli();
+const canEdit = computed(() => {
+  const item = selection.item.value;
+  if (!item) {
+    return false;
+  }
+  const definition = definitions.getBlockDefinition(
+    item.bundle,
+    item.fieldListType,
+    item.parentBlockBundle
+  );
+  if (definition?.editor?.disableEdit) {
+    return false;
+  }
+  if (item.library?.libraryItemUuid) {
+    return !!adapter.getLibraryItemEditUrl && (state.editMode.value === "editing" || state.editMode.value === "translating") && !item.isNew;
+  }
+  return state.editMode.value === "editing";
+});
+function onClick(items) {
+  if (items.length !== 1) {
+    return;
+  }
+  if (!canEdit.value) {
+    return;
+  }
+  const item = items[0];
+  if (item.library?.libraryItemUuid && adapter.getLibraryItemEditUrl) {
+    const url = adapter.getLibraryItemEditUrl(item.library.libraryItemUuid);
+    eventBus.emit("library:edit-item", {
+      url,
+      label: item.library.label,
+      uuid: item.library.libraryItemUuid
+    });
+    return;
+  }
+  eventBus.emit("item:edit", {
+    uuid: item.uuid,
+    bundle: item.bundle
+  });
+}
+onBlokkliEvent("item:doubleClick", function(block) {
+  onClick([block]);
+});
+</script>
+
+<script>
+export default {
+  name: "Edit"
+};
+</script>

package/dist/runtime/editor/features/edit/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/edit/types.d.ts

@@ -0,0 +1,9 @@
+export type EditBlockEvent = {
+    uuid: string;
+    bundle: string;
+};
+declare module '#blokkli/editor/events' {
+    interface EventbusEvents {
+        'item:edit': EditBlockEvent;
+    }
+}