@blokkli/editor 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/runtime/helpers/domProvider.js

@@ -1,72 +1,52 @@
 import { reactive, ref, computed } from "#imports";
-import {
-  findClosestBlock,
-  buildDraggableItem,
-  falsy,
-  mapDroppableField,
-  findClosestEntityContext
-} from "#blokkli/helpers";
+import { falsy } from "#blokkli/helpers";
 import { cloneElementWithStyles } from "./dom/index.js";
 import onBlokkliEvent from "./composables/onBlokkliEvent.js";
 import useDelayedIntersectionObserver from "./composables/useDelayedIntersectionObserver.js";
-const buildFieldElement = (element) => {
-  const key = element.dataset.fieldKey;
-  const name = element.dataset.fieldName;
-  const label = element.dataset.fieldLabel;
-  const isNested = element.dataset.fieldIsNested === "true";
-  const nestingLevel = Number.parseInt(element.dataset.bkNestingLevel || "0");
-  const fieldListType = element.dataset.fieldListType;
-  const hostEntityType = element.dataset.hostEntityType;
-  const hostEntityBundle = element.dataset.hostEntityBundle;
-  const hostEntityUuid = element.dataset.hostEntityUuid;
-  const dropAlignment = element.dataset.fieldDropAlignment;
-  const cardinality = Number.parseInt(element.dataset.fieldCardinality || "-1");
-  const allowedBundles = (element.dataset.fieldAllowedBundles || "").split(",").filter(Boolean);
-  const allowedFragments = (element.dataset.allowedFragments || "").split(",").filter(Boolean);
-  if (key && name && label && hostEntityType && hostEntityUuid && hostEntityBundle && fieldListType) {
-    return {
-      key,
-      name,
-      label,
-      isNested,
-      nestingLevel,
-      hostEntityType,
-      hostEntityUuid,
-      hostEntityBundle,
-      cardinality: Number.isNaN(cardinality) ? -1 : cardinality,
-      allowedBundles,
-      allowedFragments,
-      fieldListType,
-      element,
-      dropAlignment: dropAlignment === "vertical" || dropAlignment === "horizontal" ? dropAlignment : void 0
-    };
-  }
-};
+import { itemEntityType } from "#blokkli-build/config";
 function rectWithTime(rect, time) {
   return {
     ...rect,
     time: time || performance.now()
   };
 }
-export default function(ui, debug, definitions) {
-  const artboardElement = ui.artboardElement();
+export default function(ui, debug, definitions, state, element) {
   const logger = debug.createLogger("DomProvider");
   const mutationsReady = ref(true);
   const intersectionReady = ref(false);
+  const registeredBlocks = reactive({});
+  const registeredFields = reactive({});
   const visibleBlocks = /* @__PURE__ */ new Set();
   const visibleFields = /* @__PURE__ */ new Set();
+  const fieldElementToFieldKey = /* @__PURE__ */ new WeakMap();
+  const blockElementToUuid = /* @__PURE__ */ new WeakMap();
   const blockRects = {};
   const fieldRects = {};
-  let draggableBlockCache = {};
+  const blockUuidCurrentKey = {};
+  const observedElements = {};
+  let initTimeout = null;
+  const isInitalizing = ref(true);
+  const observedElementCache = /* @__PURE__ */ new Map();
+  const registeredBlockUuids = computed(() => {
+    return Object.entries(registeredBlocks).map(([uuid, element2]) => {
+      if (element2) {
+        return uuid;
+      }
+      return null;
+    }).filter(falsy);
+  });
   const resizeObserver = new ResizeObserver(function(entries) {
     for (const entry of entries) {
       if (!(entry.target instanceof HTMLElement)) {
         return;
       }
-      const uuid = entry.target.dataset.uuid || entry.target.closest("[data-uuid]")?.dataset.uuid;
+      const uuid = blockElementToUuid.get(entry.target);
       if (!uuid) {
         return;
       }
+      if (!registeredBlocks[uuid]) {
+        continue;
+      }
       const currentRect = blockRects[uuid];
       const now = performance.now();
       if (!currentRect) {
@@ -93,42 +73,52 @@ export default function(ui, debug, definitions) {
     const scale = ui.artboardScale.value;
     const offset = ui.artboardOffset.value;
     for (const entry of entries) {
-      if (entry.target instanceof HTMLElement) {
-        const uuid = entry.target.dataset.uuid || entry.target.closest("[data-uuid]")?.dataset.uuid;
-        const fieldKey = entry.target.dataset.fieldKey;
-        const rect = entry.target.getBoundingClientRect();
-        if (fieldKey) {
-          if (entry.isIntersecting) {
-            visibleFields.add(fieldKey);
-          } else {
-            visibleFields.delete(fieldKey);
-          }
-          fieldRects[fieldKey] = ui.getAbsoluteElementRect(rect, scale, offset);
-        } else if (uuid) {
-          const newRect = ui.getAbsoluteElementRect(rect, scale, offset);
-          const currentRect = blockRects[uuid];
-          if (currentRect) {
-            if (currentRect.time > entry.time) {
-              blockRects[uuid].x = newRect.x;
-              blockRects[uuid].y = newRect.y;
-            } else {
-              blockRects[uuid] = rectWithTime(newRect, entry.time);
-            }
-          } else {
-            blockRects[uuid] = rectWithTime(newRect, entry.time);
-          }
-          if (entry.isIntersecting) {
-            visibleBlocks.add(uuid);
-          } else {
-            visibleBlocks.delete(uuid);
-          }
+      if (!(entry.target instanceof HTMLElement)) {
+        continue;
+      }
+      const fieldKey = fieldElementToFieldKey.get(entry.target);
+      const rect = entry.target.getBoundingClientRect();
+      if (fieldKey) {
+        if (entry.isIntersecting) {
+          visibleFields.add(fieldKey);
+        } else {
+          visibleFields.delete(fieldKey);
+        }
+        fieldRects[fieldKey] = ui.getAbsoluteElementRect(rect, scale, offset);
+        continue;
+      }
+      const uuid = blockElementToUuid.get(entry.target);
+      if (!uuid) {
+        continue;
+      }
+      if (!registeredBlocks[uuid]) {
+        continue;
+      }
+      const newRect = ui.getAbsoluteElementRect(rect, scale, offset);
+      const currentRect = blockRects[uuid];
+      if (currentRect) {
+        if (currentRect.time > entry.time) {
+          blockRects[uuid].x = newRect.x;
+          blockRects[uuid].y = newRect.y;
+        } else {
+          blockRects[uuid] = rectWithTime(newRect, entry.time);
         }
+      } else {
+        blockRects[uuid] = rectWithTime(newRect, entry.time);
+      }
+      if (entry.isIntersecting) {
+        visibleBlocks.add(uuid);
+      } else {
+        visibleBlocks.delete(uuid);
       }
     }
   }
-  const intersectionObserver = useDelayedIntersectionObserver(intersectionCallback);
-  const registeredBlocks = reactive({});
-  const registeredFields = reactive({});
+  const intersectionObserver = useDelayedIntersectionObserver(
+    intersectionCallback,
+    {
+      rootMargin: "400px 0px 400px 0px"
+    }
+  );
   const registeredFieldTypes = computed(() => {
     const fields = Object.values(registeredFields);
     const found = /* @__PURE__ */ new Set();
@@ -149,33 +139,56 @@ export default function(ui, debug, definitions) {
     }
     return uniqueFieldTypes;
   });
-  const registerField = (entity, fieldName, element) => {
+  const registerField = (entity, fieldName, element2, data) => {
     const key = `${entity.uuid}:${fieldName}`;
-    registeredFields[key] = { element, entity, fieldName };
-    intersectionObserver.observe(element);
+    registeredFields[key] = {
+      element: element2,
+      entity,
+      fieldName,
+      ...data
+    };
+    intersectionObserver.observe(element2);
+    fieldElementToFieldKey.set(element2, key);
+    doInitTimeout();
   };
-  const updateFieldElement = (entity, fieldName, element) => {
+  const updateFieldElement = (entity, fieldName, element2, data) => {
     const key = `${entity.uuid}:${fieldName}`;
     const existingElement = registeredFields[key]?.element;
     if (existingElement) {
       intersectionObserver.unobserve(existingElement);
     }
-    registeredFields[key] = { entity, fieldName, element };
-    intersectionObserver.observe(element);
+    registeredFields[key] = {
+      entity,
+      fieldName,
+      element: element2,
+      ...data
+    };
+    fieldElementToFieldKey.set(element2, key);
+    intersectionObserver.observe(element2);
   };
   const unregisterField = (entity, fieldName) => {
     const key = `${entity.uuid}:${fieldName}`;
     const el = registeredFields[key]?.element;
     if (el) {
       intersectionObserver.unobserve(el);
+      fieldElementToFieldKey.delete(el);
     }
     visibleFields.delete(key);
     registeredFields[key] = void 0;
   };
-  function getElementToObserve(el, bundle, fieldListType, parentBlockBundle) {
+  const getRegisteredField = (uuid, fieldName) => {
+    const key = `${uuid}:${fieldName}`;
+    return registeredFields[key];
+  };
+  function getElementToObserve(uuid, el, bundle, fieldListType, parentBlockBundle) {
     if (el.classList.contains("bk-block-proxy")) {
       return el;
     }
+    const key = `${uuid}${bundle}${fieldListType}${parentBlockBundle ?? "none"}`;
+    const cached = observedElementCache.get(key);
+    if (cached) {
+      return cached;
+    }
     const definition = definitions.getBlockDefinition(
       bundle,
       fieldListType,
@@ -186,44 +199,32 @@ export default function(ui, debug, definitions) {
     }
     const observableElement = (definition.editor?.getDraggableElement ? definition.editor.getDraggableElement(el) : el) || el;
     if (observableElement instanceof HTMLElement) {
+      observedElementCache.set(key, observableElement);
       return observableElement;
     }
+    observedElementCache.set(key, el);
     return el;
   }
-  const findBlock = (uuid) => {
-    const cached = draggableBlockCache[uuid];
-    if (cached) {
-      return cached;
-    }
-    const el = registeredBlocks[uuid];
-    if (!el) {
-      return;
-    }
-    const item = buildDraggableItem(el);
-    if (item?.itemType === "existing") {
-      draggableBlockCache[uuid] = item;
-      return item;
-    }
-  };
-  const getAllBlocks = () => {
-    return [
-      ...document.querySelectorAll(
-        '[data-blokkli-provider-active="true"] [data-uuid]'
-      )
-    ].map((v) => {
-      const item = buildDraggableItem(v);
-      if (item?.itemType === "existing") {
-        return item;
-      }
-    }).filter(falsy);
-  };
   const getDropElementMarkup = (item, checkSize) => {
-    const el = item.itemType === "existing" ? getDragElement(item) : item.element();
+    const getElement = () => {
+      if ("itemType" in item) {
+        if (item.itemType === "existing") {
+          return getDragElement(item);
+        }
+        return item.element();
+      }
+      return getDragElement(item);
+    };
+    const el = getElement();
     if (!el) {
       return "";
     }
-    const dropElement = el.querySelector(".bk-drop-element") || el;
-    const childCount = dropElement.querySelectorAll("*").length;
+    const dropElement = element.query(el, ".bk-drop-element", "Find drop element for markup.") || el;
+    const childCount = element.queryAll(
+      dropElement,
+      "*",
+      "Get child count for drop element markup."
+    ).length;
     if (checkSize && childCount > 80) {
       return "";
     }
@@ -232,58 +233,50 @@ export default function(ui, debug, definitions) {
       ""
     );
   };
-  const findField = (uuid, fieldName) => {
-    const el = document.querySelector(
-      `[data-field-name="${fieldName}"][data-host-entity-uuid="${uuid}"]`
-    );
-    if (!(el instanceof HTMLElement)) {
-      return;
-    }
-    return buildFieldElement(el);
-  };
-  const getAllDroppableFields = () => [...document.querySelectorAll("[data-blokkli-droppable-field]")].filter((el) => {
-    return !el.closest('[data-bk-in-proxy="true"]');
-  }).map(mapDroppableField);
   const getVisibleBlocks = () => Array.from(visibleBlocks);
   const getVisibleFields = () => Array.from(visibleFields);
-  const getActiveProviderElement = () => {
-    const el = document.querySelector('[data-blokkli-provider-active="true"]');
-    if (!el) {
-      throw new Error("Failed to find active <BlokkliProvider> element.");
-    }
-    if (!(el instanceof HTMLElement)) {
-      throw new TypeError(
-        "The root element of the active <BlokkliProvider> is not an HTMLElement."
-      );
-    }
-    return el;
-  };
   function getBlockRects() {
     return blockRects;
   }
-  function getBlockRect(uuid) {
+  function getBlockRect(uuid, refresh) {
+    if (refresh) {
+      refreshBlockRect(uuid);
+    }
     return blockRects[uuid];
   }
   function getFieldRect(key) {
     return fieldRects[key];
   }
-  function refreshBlockRect(uuid) {
-    const block = findBlock(uuid);
-    if (!block) {
+  function refreshBlockRect(uuid, providedOffset, providedScale) {
+    const offset = providedOffset ?? ui.artboardOffset.value;
+    const scale = providedScale ?? ui.artboardScale.value;
+    const el = registeredBlocks[uuid];
+    if (!el) {
       return;
     }
-    const el = getDragElement(block);
-    if (!el) {
+    const bundle = el.dataset.itemBundle;
+    const hostBundle = el.dataset.hostBundle;
+    const hostFieldListType = el.dataset.hostFieldListType;
+    if (!bundle || !hostFieldListType) {
       return;
     }
+    const observableElement = getElementToObserve(
+      uuid,
+      el,
+      bundle,
+      hostFieldListType,
+      hostBundle
+    );
     blockRects[uuid] = rectWithTime(
-      ui.getAbsoluteElementRect(el.getBoundingClientRect())
+      ui.getAbsoluteElementRect(
+        observableElement.getBoundingClientRect(),
+        scale,
+        offset
+      )
     );
   }
   function refreshFieldRect(key) {
-    const el = document.querySelector(
-      `.bk-draggable-list-container[data-field-key="${key}"]`
-    );
+    const el = registeredFields[key]?.element;
     if (!(el instanceof HTMLElement)) {
       return;
     }
@@ -298,34 +291,15 @@ export default function(ui, debug, definitions) {
     return getVisibleBlocks();
   }
   function updateVisibleRects() {
+    logger.log("Update visible rects");
     const toUpdate = getUuidsToUpdateRectsFor();
     const offset = ui.artboardOffset.value;
     const scale = ui.artboardScale.value;
     for (let i = 0; i < toUpdate.length; i++) {
       const uuid = toUpdate[i];
-      const el = registeredBlocks[uuid];
-      if (!el) {
-        continue;
+      if (uuid) {
+        refreshBlockRect(uuid, offset, scale);
       }
-      const bundle = el.dataset.itemBundle;
-      const hostBundle = el.dataset.hostBundle;
-      const hostFieldListType = el.dataset.hostFieldListType;
-      if (!bundle || !hostFieldListType) {
-        continue;
-      }
-      const observableElement = getElementToObserve(
-        el,
-        bundle,
-        hostFieldListType,
-        hostBundle
-      );
-      blockRects[uuid] = rectWithTime(
-        ui.getAbsoluteElementRect(
-          observableElement.getBoundingClientRect(),
-          scale,
-          offset
-        )
-      );
     }
     const visibleFieldKeys = getVisibleFields();
     for (let i = 0; i < visibleFieldKeys.length; i++) {
@@ -342,17 +316,23 @@ export default function(ui, debug, definitions) {
     }
   }
   onBlokkliEvent("state:reloaded", () => {
-    draggableBlockCache = {};
+    observedElementCache.clear();
     if (stateReloadTimeout) {
       window.clearTimeout(stateReloadTimeout);
     }
+    const allUuids = Object.keys(registeredBlocks);
+    if (allUuids.length < 150) {
+      updateVisibleRects();
+    }
     stateReloadTimeout = window.setTimeout(updateVisibleRects, 300);
   });
-  onBlokkliEvent("ui:resized", function() {
+  function forceRefresh() {
     updateVisibleRects();
     getVisibleFields().forEach(refreshFieldRect);
     logger.log("Refreshed all visible rects");
-  });
+  }
+  onBlokkliEvent("option:finish-change", forceRefresh);
+  onBlokkliEvent("ui:resized", forceRefresh);
   function init() {
     intersectionObserver.init();
     intersectionReady.value = true;
@@ -360,108 +340,203 @@ export default function(ui, debug, definitions) {
   }
   const dragElementUuidMap = /* @__PURE__ */ new WeakMap();
   const dragElementCache = /* @__PURE__ */ new Map();
-  function handleNodeAdded(node) {
-    if (!(node instanceof HTMLElement)) {
+  function getDragElement(block) {
+    const item = "itemType" in block ? block.block : block;
+    if (!item) {
       return;
     }
-    if (node.dataset.uuid) {
-      const item = buildDraggableItem(node);
-      if (item && item.itemType === "existing") {
-        const observableElement = getElementToObserve(
-          node,
-          item.itemBundle,
-          item.hostFieldListType,
-          item.hostBundle
-        );
-        intersectionObserver.observe(observableElement);
-        resizeObserver.observe(observableElement);
-        registeredBlocks[item.uuid] = node;
-      }
-    } else if (node.dataset.fieldName && node.dataset.fieldKey && node.dataset.fieldCardinality) {
-      const blocks = node.querySelectorAll('[data-element-type="existing"]');
-      for (const block of blocks) {
-        handleNodeAdded(block);
-      }
+    const el = registeredBlocks[item.uuid];
+    if (!el) {
+      return;
     }
+    return getElementToObserve(
+      item.uuid,
+      el,
+      item.bundle,
+      item.fieldListType,
+      item.parentBlockBundle
+    );
   }
-  function handleNodeRemoved(node) {
-    if (node instanceof HTMLElement && node.dataset.uuid) {
-      const uuid = node.dataset.uuid;
-      const el = registeredBlocks[uuid];
-      if (el !== node) {
-        return;
-      }
-      if (el) {
-        intersectionObserver.unobserve(el);
-        resizeObserver.unobserve(el);
-        dragElementUuidMap.delete(el);
-      }
-      dragElementUuidMap.delete(node);
-      dragElementCache.delete(uuid);
-      registeredBlocks[uuid] = void 0;
-      delete blockRects[uuid];
-      visibleBlocks.delete(uuid);
-    }
+  function isBlockVisible(uuid) {
+    return visibleBlocks.has(uuid);
   }
-  const mutationObserverCallback = function(mutationsList) {
-    for (const mutation of mutationsList) {
-      if (mutation.type === "childList") {
-        for (const node of mutation.removedNodes) {
-          handleNodeRemoved(node);
-        }
-        for (const node of mutation.addedNodes) {
-          handleNodeAdded(node);
+  function refreshAllBlockRects() {
+    const uuids = Object.keys(blockRects);
+    if (uuids.length < 200) {
+      for (let i = 0; i < uuids.length; i++) {
+        const uuid = uuids[i];
+        if (!uuid) {
+          continue;
         }
+        refreshBlockRect(uuid);
       }
     }
-  };
-  const mutationObserver = new MutationObserver(mutationObserverCallback);
-  mutationObserver.observe(artboardElement, {
-    subtree: true,
-    childList: true
-  });
-  function getDragElement(block) {
-    const cached = dragElementCache.get(block.uuid);
-    if (cached && document.body.contains(cached)) {
-      return cached;
+  }
+  function doInitTimeout() {
+    if (initTimeout) {
+      window.clearTimeout(initTimeout);
+    }
+    if (isInitalizing.value) {
+      initTimeout = window.setTimeout(() => {
+        isInitalizing.value = false;
+        refreshAllBlockRects();
+      }, 500);
     }
-    const el = block.element();
+  }
+  function registerBlock(key, uuid, el) {
+    logger.log("registerBlock: " + uuid);
+    blockUuidCurrentKey[uuid] = key;
+    doInitTimeout();
     if (!el) {
+      logger.log("registerBlock call unregisterBlock because no element", uuid);
+      unregisterBlock(key, uuid);
       return;
     }
-    if (el.parentNode) {
-      mutationObserver.observe(el.parentNode, { childList: true });
+    if (registeredBlocks[uuid]) {
+      logger.log(
+        "registerBlock call unregisterBlock because already registered",
+        uuid
+      );
+      unregisterBlock(key, uuid);
+    }
+    const item = state.getFieldListItem(uuid);
+    if (item) {
+      const fieldList = state.getFieldListForBlock(item.uuid);
+      if (fieldList) {
+        const fieldListType = getRegisteredField(fieldList.entityUuid, fieldList.name)?.fieldListType ?? "default";
+        const parentBundle = fieldList.entityType === itemEntityType ? state.getFieldListItem(fieldList.entityUuid)?.bundle ?? null : null;
+        const observableElement = getElementToObserve(
+          item.uuid,
+          el,
+          item.bundle,
+          fieldListType,
+          parentBundle
+        );
+        blockElementToUuid.set(observableElement, uuid);
+        registeredBlocks[uuid] = el;
+        observedElements[uuid] = observableElement;
+        intersectionObserver.observe(observableElement);
+        resizeObserver.observe(observableElement);
+      }
     }
-    dragElementUuidMap.set(el, block.uuid);
-    dragElementCache.set(block.uuid, el);
-    return el;
   }
-  function isBlockVisible(uuid) {
-    return visibleBlocks.has(uuid);
+  function unregisterBlock(key, uuid) {
+    const currentKey = blockUuidCurrentKey[uuid];
+    if (currentKey && currentKey !== key) {
+      return;
+    }
+    logger.log("unregisterBlock: " + uuid);
+    const el = registeredBlocks[uuid];
+    const observedElement = observedElements[uuid];
+    if (observedElement) {
+      intersectionObserver.unobserve(observedElement);
+      resizeObserver.unobserve(observedElement);
+      delete observedElements[uuid];
+      blockElementToUuid.delete(observedElement);
+    }
+    if (el) {
+      dragElementUuidMap.delete(el);
+    }
+    dragElementCache.delete(uuid);
+    registeredBlocks[uuid] = void 0;
+    delete blockRects[uuid];
+    delete blockUuidCurrentKey[uuid];
+    visibleBlocks.delete(uuid);
+  }
+  function getDebugData() {
+    const allUuids = /* @__PURE__ */ new Set([
+      ...Object.keys(registeredBlocks),
+      ...Object.keys(blockRects),
+      ...Object.keys(observedElements),
+      ...Object.keys(blockUuidCurrentKey)
+    ]);
+    const blocksInfo = Array.from(allUuids).map((uuid) => {
+      const el = registeredBlocks[uuid];
+      return {
+        uuid,
+        hasElement: !!el,
+        hasObservedElement: !!observedElements[uuid],
+        hasRect: !!blockRects[uuid],
+        hasCurrentKey: !!blockUuidCurrentKey[uuid],
+        isVisible: visibleBlocks.has(uuid),
+        elementInfo: el ? {
+          tagName: el.tagName,
+          bundle: el.dataset.itemBundle,
+          hostBundle: el.dataset.hostBundle,
+          fieldListType: el.dataset.hostFieldListType
+        } : void 0
+      };
+    });
+    const fieldsInfo = Object.entries(registeredFields).filter(([, field]) => !!field).map(([key, field]) => ({
+      key,
+      isVisible: visibleFields.has(key),
+      hasRect: !!fieldRects[key],
+      entityType: field.entity.type,
+      entityBundle: field.entity.bundle,
+      fieldName: field.fieldName
+    }));
+    const registeredUuids = new Set(
+      Object.entries(registeredBlocks).filter(([, el]) => !!el).map(([uuid]) => uuid)
+    );
+    const rectsWithoutRegistration = Object.keys(blockRects).filter(
+      (uuid) => !registeredUuids.has(uuid)
+    );
+    const observedElementsWithoutRegistration = Object.keys(
+      observedElements
+    ).filter((uuid) => !registeredUuids.has(uuid));
+    const keysWithoutRegistration = Object.keys(blockUuidCurrentKey).filter(
+      (uuid) => !registeredUuids.has(uuid)
+    );
+    return {
+      registeredBlocks: blocksInfo,
+      fields: fieldsInfo,
+      summary: {
+        totalRegisteredBlocks: Object.keys(registeredBlocks).length,
+        totalBlocksWithElements: Object.values(registeredBlocks).filter(
+          (el) => !!el
+        ).length,
+        totalObservedElements: Object.keys(observedElements).length,
+        totalBlockRects: Object.keys(blockRects).length,
+        totalVisibleBlocks: visibleBlocks.size,
+        totalRegisteredFields: Object.values(registeredFields).filter(
+          (f) => !!f
+        ).length,
+        totalVisibleFields: visibleFields.size,
+        totalFieldRects: Object.keys(fieldRects).length,
+        isInitializing: isInitalizing.value,
+        isReady: mutationsReady.value && intersectionReady.value && !isInitalizing.value
+      },
+      orphanedData: {
+        rectsWithoutRegistration,
+        observedElementsWithoutRegistration,
+        keysWithoutRegistration
+      }
+    };
   }
   return {
-    findBlock,
-    getAllBlocks,
-    findClosestBlock,
     getDropElementMarkup,
-    findField,
-    getAllDroppableFields,
-    findClosestEntityContext,
     getVisibleBlocks,
     getVisibleFields,
     registerField,
     unregisterField,
     updateFieldElement,
-    getActiveProviderElement,
     getBlockRects,
     getBlockRect,
     getFieldRect,
     refreshBlockRect,
     isBlockVisible,
-    isReady: computed(() => mutationsReady.value && intersectionReady.value),
+    isReady: computed(
+      () => mutationsReady.value && intersectionReady.value && !isInitalizing.value
+    ),
     init,
     getDragElement,
     updateVisibleRects,
-    registeredFieldTypes
+    registeredFieldTypes,
+    registerBlock,
+    unregisterBlock,
+    registeredBlockUuids,
+    getDebugData,
+    getRegisteredField,
+    registeredBlocks: computed(() => registeredBlocks)
   };
 }