@blokkli/editor 1.4.0-alpha.1 → 2.0.0-alpha.10

package/dist/runtime/helpers/animationProvider.js

@@ -18,7 +18,7 @@ export default function(ui) {
       return;
     }
     iterator--;
-    eventBus.emit("animationFrame:before", time);
+    eventBus.emit("animationFrame:before", { time, mouseX, mouseY });
     eventBus.emit("animationFrame", {
       mouseX,
       mouseY,

package/dist/runtime/helpers/composables/useBlockRegistration.d.ts

@@ -0,0 +1,5 @@
+import type { DomProvider } from '../domProvider.js';
+/**
+ * Helper composable to handle registering the block in the DOM provider.
+ */
+export declare function useBlockRegistration(dom: DomProvider, uuid: string): void;

package/dist/runtime/helpers/composables/useBlockRegistration.js

@@ -0,0 +1,23 @@
+import {
+  getCurrentInstance,
+  onBeforeUnmount,
+  onMounted,
+  onUpdated
+} from "#imports";
+export function useBlockRegistration(dom, uuid) {
+  const instance = getCurrentInstance();
+  const key = uuid + Math.round(Math.random() * 1e10).toString() + Date.now().toString();
+  let rootElement = null;
+  function setRootElement() {
+    const newElement = instance?.proxy?.$el;
+    if (newElement && rootElement !== newElement) {
+      rootElement = newElement;
+      dom.registerBlock(key, uuid, newElement);
+    }
+  }
+  onMounted(setRootElement);
+  onUpdated(setRootElement);
+  onBeforeUnmount(() => {
+    dom.unregisterBlock(key, uuid);
+  });
+}

package/dist/runtime/helpers/definitionProvider.d.ts

@@ -0,0 +1,18 @@
+import { type Ref, type ComputedRef } from '#imports';
+import type { BlockDefinition, FragmentDefinition } from '#blokkli-build/definitions';
+import type { ValidFieldListTypes, BlockBundleWithNested } from '#blokkli-build/generated-types';
+import type { DeepReadonly } from 'vue';
+import type { BlockDefinitionOptionsInput } from '../types/index.js';
+import { type RuntimeBlockOptionArray } from '#blokkli-build/runtime-options';
+export type DefinitionProvider = {
+    getBlockDefinition: (bundle: string, fieldListType: ValidFieldListTypes, parentBundle?: BlockBundleWithNested) => BlockDefinition | undefined;
+    getDefaultDefinition: (bundle: string) => BlockDefinition | undefined;
+    getFragmentDefinition: (name: string) => FragmentDefinition | undefined;
+    getBlockIcon: (bundle: string) => string | undefined;
+    fragmentDefinitions: ComputedRef<FragmentDefinition[]>;
+    blockDefinitions: ComputedRef<BlockDefinition[]>;
+    globalOptions: DeepReadonly<Ref<BlockDefinitionOptionsInput>>;
+    runtimeOptions: DeepReadonly<Ref<Record<string, Record<string, RuntimeBlockOptionArray>>>>;
+    renderKey: DeepReadonly<Ref<string>>;
+};
+export default function (): DefinitionProvider;

package/dist/runtime/helpers/definitionProvider.js

@@ -0,0 +1,96 @@
+import { computed, ref, readonly } from "#imports";
+import definitions from "#blokkli-build/definitions";
+import {
+  OPTIONS
+} from "#blokkli-build/runtime-options";
+export default function() {
+  const blocks = ref(definitions.blocks);
+  const fragments = ref(definitions.fragments);
+  const renderKey = ref(definitions.renderKey);
+  const blockIcons = ref(definitions.icons);
+  const allGlobalOptions = ref(
+    definitions.globalOptions
+  );
+  const runtimeOptions = ref(OPTIONS);
+  if (import.meta.hot) {
+    import.meta.hot.accept("#blokkli-build/definitions", (mod) => {
+      const newDefinitions = mod;
+      renderKey.value = newDefinitions?.default.renderKey || "";
+      blocks.value = newDefinitions?.default?.blocks || [];
+      fragments.value = newDefinitions?.default?.fragments || [];
+      blockIcons.value = newDefinitions?.default?.icons || {};
+      allGlobalOptions.value = newDefinitions?.default?.globalOptions || {};
+    });
+    import.meta.hot.accept("#blokkli-build/runtime-options", (mod) => {
+      if (mod?.OPTIONS) {
+        runtimeOptions.value = mod.OPTIONS;
+      }
+    });
+  }
+  const blocksByKey = computed(
+    () => blocks.value.reduce((acc, definition) => {
+      const bundle = definition.bundle;
+      const renderForValue = definition.renderFor || [];
+      const renderForList = Array.isArray(renderForValue) ? renderForValue : [renderForValue];
+      if (renderForList.length) {
+        renderForList.forEach((renderFor) => {
+          if ("parentBundle" in renderFor) {
+            acc[bundle + "__parent:" + renderFor.parentBundle] = definition;
+          } else if ("fieldList" in renderFor) {
+            acc[bundle + "__field:" + renderFor.fieldList] = definition;
+          } else if ("fieldListType" in renderFor) {
+            acc[bundle + "__field:" + renderFor.fieldListType] = definition;
+          }
+        });
+      } else {
+        acc[bundle] = definition;
+      }
+      return acc;
+    }, {})
+  );
+  const fragmentsByName = computed(
+    () => fragments.value.reduce(
+      (acc, definition) => {
+        acc[definition.name] = definition;
+        return acc;
+      },
+      {}
+    )
+  );
+  function getBlockDefinition(bundle, fieldListType, parentBundle) {
+    const forFieldListType = bundle + "__field:" + fieldListType;
+    if (blocksByKey.value[forFieldListType]) {
+      return blocksByKey.value[forFieldListType];
+    }
+    if (parentBundle) {
+      const forParentBundle = bundle + "__parent:" + parentBundle;
+      if (blocksByKey.value[forParentBundle]) {
+        return blocksByKey.value[forParentBundle];
+      }
+    }
+    return blocksByKey.value[bundle];
+  }
+  function getFragmentDefinition(name) {
+    return fragmentsByName.value[name];
+  }
+  function getDefaultDefinition(bundle) {
+    return blocksByKey.value[bundle];
+  }
+  function getBlockIcon(bundle) {
+    return blockIcons.value[bundle];
+  }
+  return {
+    getBlockDefinition,
+    getFragmentDefinition,
+    getDefaultDefinition,
+    getBlockIcon,
+    fragmentDefinitions: computed(() => fragments.value),
+    blockDefinitions: computed(() => blocks.value),
+    globalOptions: readonly(allGlobalOptions),
+    runtimeOptions: readonly(runtimeOptions),
+    renderKey: readonly(renderKey)
+  };
+}
+if (import.meta.hot) {
+  import.meta.hot.accept();
+}

package/dist/runtime/helpers/domProvider.d.ts

@@ -2,6 +2,7 @@ import { type ComputedRef } from '#imports';
 import type { DraggableExistingBlock, BlokkliFieldElement, DraggableItem, DroppableEntityField, EntityContext, Rectangle } from '#blokkli/types';
 import type { UiProvider } from './uiProvider.js';
 import type { DebugProvider } from './debugProvider.js';
+import type { DefinitionProvider } from './definitionProvider.js';
 type RegisteredFieldType = {
     entityType: string;
     entityBundle: string;
@@ -19,6 +20,8 @@ export type DomProvider = {
      */
     getDropElementMarkup(item: DraggableItem, checkSize?: boolean): string;
     findField(entityUuid: string, fieldName: string): BlokkliFieldElement | undefined;
+    registerBlock: (key: string, uuid: string, el: HTMLElement | null) => void;
+    unregisterBlock: (key: string, uuid: string) => void;
     registerField: (entity: EntityContext, fieldName: string, instance: HTMLElement) => void;
     updateFieldElement: (entity: EntityContext, fieldName: string, element: HTMLElement) => void;
     unregisterField: (entity: EntityContext, fieldName: string) => void;
@@ -44,5 +47,5 @@ export type DomProvider = {
      */
     getDragElement: (block: DraggableExistingBlock) => HTMLElement | undefined;
 };
-export default function (ui: UiProvider, debug: DebugProvider): DomProvider;
+export default function (ui: UiProvider, debug: DebugProvider, definitions: DefinitionProvider): DomProvider;
 export {};

package/dist/runtime/helpers/domProvider.js

@@ -9,7 +9,6 @@ import {
 import { cloneElementWithStyles } from "./dom/index.js";
 import onBlokkliEvent from "./composables/onBlokkliEvent.js";
 import useDelayedIntersectionObserver from "./composables/useDelayedIntersectionObserver.js";
-import { getDefinition } from "#blokkli-build/definitions";
 const buildFieldElement = (element) => {
   const key = element.dataset.fieldKey;
   const name = element.dataset.fieldName;
@@ -49,8 +48,7 @@ function rectWithTime(rect, time) {
     time: time || performance.now()
   };
 }
-export default function(ui, debug) {
-  const artboardElement = ui.artboardElement();
+export default function(ui, debug, definitions) {
   const logger = debug.createLogger("DomProvider");
   const mutationsReady = ref(true);
   const intersectionReady = ref(false);
@@ -58,6 +56,7 @@ export default function(ui, debug) {
   const visibleFields = /* @__PURE__ */ new Set();
   const blockRects = {};
   const fieldRects = {};
+  const blockUuidCurrentKey = {};
   let draggableBlockCache = {};
   const resizeObserver = new ResizeObserver(function(entries) {
     for (const entry of entries) {
@@ -177,7 +176,11 @@ export default function(ui, debug) {
     if (el.classList.contains("bk-block-proxy")) {
       return el;
     }
-    const definition = getDefinition(bundle, fieldListType, parentBlockBundle);
+    const definition = definitions.getBlockDefinition(
+      bundle,
+      fieldListType,
+      parentBlockBundle
+    );
     if (!definition) {
       throw new Error("Failed to load definition for bundle: " + bundle);
     }
@@ -357,66 +360,6 @@ export default function(ui, debug) {
   }
   const dragElementUuidMap = /* @__PURE__ */ new WeakMap();
   const dragElementCache = /* @__PURE__ */ new Map();
-  function handleNodeAdded(node) {
-    if (!(node instanceof HTMLElement)) {
-      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);
-      }
-    }
-  }
-  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);
-    }
-  }
-  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);
-        }
-      }
-    }
-  };
-  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)) {
@@ -426,9 +369,6 @@ export default function(ui, debug) {
     if (!el) {
       return;
     }
-    if (el.parentNode) {
-      mutationObserver.observe(el.parentNode, { childList: true });
-    }
     dragElementUuidMap.set(el, block.uuid);
     dragElementCache.set(block.uuid, el);
     return el;
@@ -436,6 +376,52 @@ export default function(ui, debug) {
   function isBlockVisible(uuid) {
     return visibleBlocks.has(uuid);
   }
+  function registerBlock(key, uuid, el) {
+    logger.log("registerBlock: " + uuid);
+    blockUuidCurrentKey[uuid] = key;
+    if (!el) {
+      logger.log("registerBlock call unregisterBlock because no element", uuid);
+      unregisterBlock(key, uuid);
+      return;
+    }
+    if (registeredBlocks[uuid]) {
+      logger.log(
+        "registerBlock call unregisterBlock because already registered",
+        uuid
+      );
+      unregisterBlock(key, uuid);
+    }
+    const item = buildDraggableItem(el);
+    if (item && item.itemType === "existing") {
+      const observableElement = getElementToObserve(
+        el,
+        item.itemBundle,
+        item.hostFieldListType,
+        item.hostBundle
+      );
+      intersectionObserver.observe(observableElement);
+      resizeObserver.observe(observableElement);
+      registeredBlocks[item.uuid] = el;
+    }
+  }
+  function unregisterBlock(key, uuid) {
+    const currentKey = blockUuidCurrentKey[uuid];
+    if (currentKey && currentKey !== key) {
+      return;
+    }
+    logger.log("unregisterBlock: " + uuid);
+    const el = registeredBlocks[uuid];
+    if (el) {
+      intersectionObserver.unobserve(el);
+      resizeObserver.unobserve(el);
+      dragElementUuidMap.delete(el);
+      dragElementUuidMap.delete(el);
+    }
+    dragElementCache.delete(uuid);
+    registeredBlocks[uuid] = void 0;
+    delete blockRects[uuid];
+    visibleBlocks.delete(uuid);
+  }
   return {
     findBlock,
     getAllBlocks,
@@ -459,6 +445,8 @@ export default function(ui, debug) {
     init,
     getDragElement,
     updateVisibleRects,
-    registeredFieldTypes
+    registeredFieldTypes,
+    registerBlock,
+    unregisterBlock
   };
 }

package/dist/runtime/helpers/editComponents/index.d.ts

@@ -0,0 +1,2 @@
+export declare function getBlokkliItemProxyComponent(bundle: string): any;
+export declare function getBlokkliItemDiffComponent(bundle: string): any;

package/dist/runtime/helpers/editComponents/index.js

@@ -0,0 +1,10 @@
+import {
+  PROXY_COMPONENTS,
+  DIFF_COMPONENTS
+} from "#blokkli-build/edit-components";
+export function getBlokkliItemProxyComponent(bundle) {
+  return PROXY_COMPONENTS[bundle];
+}
+export function getBlokkliItemDiffComponent(bundle) {
+  return DIFF_COMPONENTS[bundle];
+}

package/dist/runtime/helpers/featuresProvider.d.ts

@@ -3,7 +3,8 @@ import { type ValidFeatureKey } from '#blokkli-build/features';
 import { type ComputedRef } from '#imports';
 import type { StorageProvider } from './storageProvider.js';
 export type FeaturesProvider = {
-    features: ComputedRef<FeatureDefinition<AdapterMethods[], ValidFeatureKey>[]>;
+    features: ComputedRef<FeatureDefinition[]>;
+    mountedFeatures: ComputedRef<FeatureDefinition<AdapterMethods[], ValidFeatureKey>[]>;
     betaFeatures: ComputedRef<{
         id: ValidFeatureKey;
         label: string;

package/dist/runtime/helpers/featuresProvider.js

@@ -1,10 +1,17 @@
 import {
-  featureComponents
+  featureDefinitions
 } from "#blokkli-build/features";
 import { computed, ref } from "#imports";
 import { falsy } from "./index.js";
 export default function(storage) {
+  const definitions = ref(featureDefinitions);
   const mountedFeatures = ref([]);
+  if (import.meta.hot) {
+    import.meta.hot.accept("#blokkli-build/features", (mod) => {
+      const newDefinitions = mod;
+      definitions.value = newDefinitions?.featureDefinitions || [];
+    });
+  }
   const settingsSettings = storage.use(
     "feature:settings:settings",
     {}
@@ -18,15 +25,16 @@ export default function(storage) {
       return null;
     }).filter(falsy);
   });
-  const features = computed(() => mountedFeatures.value);
   const betaFeatures = computed(
-    () => featureComponents.filter((v) => v.beta).map((v) => {
-      return {
-        id: v.id,
-        label: v.label,
-        description: v.description
-      };
-    })
+    () => definitions.value.map((v) => {
+      if (v.beta && v.label) {
+        return {
+          id: v.id,
+          label: v.label,
+          description: v.description
+        };
+      }
+    }).filter(falsy)
   );
   const unmount = (id) => {
     mountedFeatures.value = mountedFeatures.value.filter((v) => v.id !== id);
@@ -35,7 +43,8 @@ export default function(storage) {
     mountedFeatures.value.push(feature);
   };
   return {
-    features,
+    features: computed(() => definitions.value),
+    mountedFeatures: computed(() => mountedFeatures.value),
     betaFeatures,
     enabledBetaFeatures,
     mount,

package/dist/runtime/helpers/frameEventBus.d.ts

@@ -1,4 +1,4 @@
-import type { MutatedField, UpdateBlockOptionEvent } from '../types.js';
+import type { MutatedField, UpdateBlockOptionEvent } from '../types/index.js';
 type FrameEventBusEvents = {
     selectItems: string[];
     mutatedFields: MutatedField[];

package/dist/runtime/helpers/imports/index.d.ts

@@ -0,0 +1 @@
+export declare function getComponent(type: 'block' | 'fragment', bundle: string, fieldListType?: string, parentBundle?: string): any;

package/dist/runtime/helpers/imports/index.js

@@ -0,0 +1,44 @@
+import { chunks, chunkMapping } from "#blokkli-build/imports";
+import { defineAsyncComponent } from "#imports";
+function objectOrImport(key) {
+  const chunkName = chunkMapping[key];
+  if (!chunkName) {
+    return;
+  }
+  const chunkEntry = chunks[chunkName];
+  if (!chunkEntry) {
+    return;
+  }
+  if (typeof chunkEntry === "function") {
+    return defineAsyncComponent(
+      () => chunkEntry().then((group) => {
+        const item2 = group[key];
+        if (item2 && "loadComponent" in item2) {
+          return item2.loadComponent();
+        }
+        return item2;
+      })
+    );
+  }
+  const item = chunkEntry[key];
+  if (item && "loadComponent" in item) {
+    return defineAsyncComponent(() => item.loadComponent());
+  }
+  return item;
+}
+export function getComponent(type, bundle, fieldListType, parentBundle) {
+  if (fieldListType) {
+    const key2 = `${type}:${bundle}__f:${fieldListType}`;
+    if (chunkMapping[key2]) {
+      return objectOrImport(key2);
+    }
+  }
+  if (parentBundle) {
+    const key2 = `${type}:${bundle}__p:${parentBundle}`;
+    if (chunkMapping[key2]) {
+      return objectOrImport(key2);
+    }
+  }
+  const key = `${type}:${bundle}`;
+  return objectOrImport(key);
+}

package/dist/runtime/helpers/index.js

@@ -1,6 +1,5 @@
 import { easeOutSine } from "./easing.js";
 import { useRuntimeConfig } from "#imports";
-import { getDefinition } from "#blokkli-build/definitions";
 export function falsy(value) {
   return value !== null && value !== void 0;
 }
@@ -24,13 +23,8 @@ export function buildDraggableItem(element) {
     const isNew = dataset.isNew === "true";
     const parentBlockBundle = hostType === itemEntityType ? hostBundle : void 0;
     if (uuid && hostType && hostUuid && hostFieldName && itemBundle && hostBundle && entityType && hostFieldListType) {
-      const definition = getDefinition(
-        itemBundle,
-        hostFieldListType,
-        parentBlockBundle
-      );
       const libraryLabel = dataset.bkLibraryLabel;
-      const editTitle = libraryLabel || (definition?.editor?.editTitle ? definition?.editor.editTitle(element) : void 0);
+      const editTitle = libraryLabel || "";
       return {
         itemType: "existing",
         element: () => document.querySelector(`[data-uuid="${uuid}"]`),
@@ -205,7 +199,10 @@ export function calculateIntersection(rectA, rectB) {
 }
 export function findClosestRectangle(x, y, rects) {
   let closestRect = rects[0];
-  let minDistance = distanceToClosestRectangleEdge(x, y, rects[0]);
+  if (!closestRect) {
+    throw new Error("Need at least one rect.");
+  }
+  let minDistance = distanceToClosestRectangleEdge(x, y, closestRect);
   for (let i = 1; i < rects.length; i++) {
     const rect = rects[i];
     const distance = distanceToClosestRectangleEdge(x, y, rect);

package/dist/runtime/helpers/runtimeHelpers/index.d.ts

@@ -10,6 +10,7 @@ import type { FieldListItem } from '#blokkli/types';
  * Returns our "internal" value of a checkbox state.
  */
 export declare function mapCheckboxTrue(v?: unknown): '1' | '0';
+export declare function isValidDatetimeLocalValue(value: string): boolean;
 /**
  * Get the runtime value for an option.
  *
@@ -29,6 +30,10 @@ export declare function isVisibleByOptions(item?: FieldListItemTyped | FieldList
  */
 export declare function getRuntimeOptions<K extends keyof RuntimeBlockOptions>(item: FieldListItemTyped & {
     bundle: K;
+}, context?: {
+    parentType: string;
+} | {
+    fieldListType: string;
 }, fromLibraryOptions?: Record<string, any>): RuntimeBlockOptions[K];
 /**
  * Get the actual block for reusable blocks.

package/dist/runtime/helpers/runtimeHelpers/index.js

@@ -1,5 +1,5 @@
 import {
-  BLOCK_OPTIONS
+  OPTIONS
 } from "#blokkli-build/runtime-options";
 import {
   bundlesWithVisibleLanguage,
@@ -9,10 +9,17 @@ import { BK_HIDDEN_GLOBALLY, BK_VISIBLE_LANGUAGES } from "../symbols.js";
 export function mapCheckboxTrue(v) {
   return v === true || v === "1" || v === 1 || v === "true" ? "1" : "0";
 }
+export function isValidDatetimeLocalValue(value) {
+  const pattern = (
+    // eslint-disable-next-line regexp/no-unused-capturing-group
+    /^(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])T([01]\d|2[0-3]):([0-5]\d)(:[0-5]\d(\.\d{1,3})?)?$/
+  );
+  return pattern.test(value);
+}
 export function getRuntimeOptionValue(definition, value) {
   const type = Array.isArray(definition) ? definition[0] : definition.type;
   const defaultValue = Array.isArray(definition) ? definition[1] : definition.default;
-  if (value === null || value === void 0) {
+  if ((value === null || value === void 0) && defaultValue !== void 0) {
     return defaultValue;
   }
   if (type === "checkbox") {
@@ -46,6 +53,11 @@ export function getRuntimeOptionValue(definition, value) {
     }
   } else if (type === "text" && typeof value === "string") {
     return value;
+  } else if (type === "datetime-local" && typeof value === "string" && isValidDatetimeLocalValue(value)) {
+    return value;
+  }
+  if (defaultValue === void 0) {
+    return "";
   }
   return defaultValue;
 }
@@ -69,7 +81,7 @@ export function isVisibleByOptions(item, language) {
   }
   return true;
 }
-export function getRuntimeOptions(item, fromLibraryOptions) {
+export function getRuntimeOptions(item, context, fromLibraryOptions) {
   if (item.bundle === "from_library" && "libraryItem" in item.props) {
     const actualBlock = item.props.libraryItem?.block;
     if (!actualBlock) {
@@ -77,16 +89,17 @@ export function getRuntimeOptions(item, fromLibraryOptions) {
     }
     return getRuntimeOptions(
       actualBlock,
+      context,
       item.options
     );
   }
-  const availableOptions = BLOCK_OPTIONS[item.bundle] || {};
+  const availableOptions = OPTIONS["block:" + item.bundle] || {};
   return Object.entries(availableOptions).reduce(
     (acc, [key, definition]) => {
       if (fromLibraryOptions && fromLibraryOptions[key] !== void 0 && fromLibraryOptions[key] !== null) {
         acc[key] = getRuntimeOptionValue(
           definition,
-          fromLibraryOptions.value[key]
+          fromLibraryOptions.value?.[key]
         );
         return acc;
       }

package/dist/runtime/helpers/stateProvider.d.ts

@@ -1,5 +1,5 @@
 import { type Ref, type ComputedRef } from 'vue';
-import type { BlokkliAdapter, AdapterContext } from '../adapter.js';
+import type { BlokkliAdapter, AdapterContext } from '../adapter/index.js';
 import type { MutatedField, EditEntity, MutatedOptions, TranslationState, MutationItem, Validation, MutateWithLoadingStateFunction, EditMode, FieldListItem } from '#blokkli/types';
 import type { TextProvider } from './textProvider.js';
 export type BlokkliOwner = {

package/dist/runtime/helpers/textProvider.d.ts

@@ -1,4 +1,4 @@
 import { type ComputedRef } from 'vue';
-import type { AdapterContext } from '../adapter.js';
+import type { AdapterContext } from '../adapter/index.js';
 export type TextProvider = (key: string, defaultValue?: string) => string;
 export default function (context?: ComputedRef<AdapterContext>): TextProvider;

package/dist/runtime/helpers/themeProvider.js

@@ -85,7 +85,10 @@ export default function() {
       const meta = document.createElement("meta");
       meta.name = "theme-color";
       meta.content = THEME_COLOR;
-      document.getElementsByTagName("head")[0].appendChild(meta);
+      const head = document.getElementsByTagName("head")[0];
+      if (head) {
+        head.appendChild(meta);
+      }
     }
   });
   onBeforeUnmount(() => {

package/dist/runtime/helpers/transform.d.ts

@@ -1,2 +1,2 @@
-import type { TransformPlugin } from '../types.js';
+import type { TransformPlugin } from '../types/index.js';
 export declare function filterTransforms(plugins: TransformPlugin[], selectedItems: any[], selectedBundles: string[], allowedBundles: string[]): TransformPlugin[];

package/dist/runtime/helpers/typesProvider.d.ts

@@ -1,6 +1,6 @@
 import type { ComputedRef } from 'vue';
-import type { FieldConfig, BlockBundleDefinition, EditableFieldConfig, BlockDefinitionInput, BlockDefinitionOptionsInput, DroppableFieldConfig, DraggableExistingBlock, EntityContext } from '../types.js';
-import type { AdapterContext, BlokkliAdapter } from '../adapter.js';
+import type { FieldConfig, BlockBundleDefinition, EditableFieldConfig, BlockDefinitionInput, BlockDefinitionOptionsInput, DroppableFieldConfig, DraggableExistingBlock, EntityContext } from '../types/index.js';
+import type { AdapterContext, BlokkliAdapter } from '../adapter/index.js';
 import type { SelectionProvider } from './selectionProvider.js';
 export type BlokkliBlockType = BlockBundleDefinition & {
     definition: BlockDefinitionInput<BlockDefinitionOptionsInput, never[]> | undefined;