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

package/dist/runtime/components/BlokkliField.vue.d.ts

@@ -1,6 +1,8 @@
 import type { BlokkliFragmentName } from '#blokkli-build/definitions';
-import type { FieldListItem, FieldDropAlignment, VueClassProp } from '#blokkli/types';
+import type { FieldListItem } from '#blokkli/types';
 import type { ValidFieldListTypes, FieldListItemTyped } from '#blokkli-build/generated-types';
+import type { FieldDropAlignment } from '#blokkli/types/field';
+import type { VueClassProp } from '#blokkli/types/vue';
 type __VLS_Props = {
     /**
      * The name of the field.
@@ -73,18 +75,19 @@ type __VLS_Slots = {
         items: FieldListItemTyped[];
     }): any;
 };
-declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
-    list: Array<FieldListItem | null | undefined> | FieldListItem | null;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    tag: string;
     fieldListType: ValidFieldListTypes;
     allowedFragments: BlokkliFragmentName[] | BlokkliFragmentName;
     dropAlignment: FieldDropAlignment;
-    tag: string;
+    list: Array<FieldListItem | null | undefined> | FieldListItem | null;
     shouldRenderItem: (item: FieldListItem | FieldListItemTyped) => boolean;
     listClass: VueClassProp;
     editClass: VueClassProp;
     nonEmptyClass: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+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 (): {

package/dist/runtime/components/BlokkliItem.d.vue.ts

@@ -0,0 +1,31 @@
+import type { BlockEditContext } from '#blokkli/types/field';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    uuid: string;
+    bundle: string;
+    isVisible?: boolean;
+    options?: any;
+    editContext?: BlockEditContext;
+    props?: any;
+    index?: number;
+    parentType?: string;
+    isEditing?: boolean;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    uuid: string;
+    bundle: string;
+    isVisible?: boolean;
+    options?: any;
+    editContext?: BlockEditContext;
+    props?: any;
+    index?: number;
+    parentType?: string;
+    isEditing?: boolean;
+}> & Readonly<{}>, {
+    isEditing: boolean;
+    props: any;
+    options: any;
+    editContext: BlockEditContext;
+    index: number;
+    parentType: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/BlokkliItem.vue

@@ -6,12 +6,12 @@
     :uuid="uuid"
     :field-list-type="fieldListType"
     :parent-type="parentType"
-    :item-props="props"
+    :item-props
   />
   <Component
     :is="component"
     v-else-if="component"
-    v-bind="props"
+    v-bind="itemProps"
     :data-bk-in-proxy="fieldUsesProxy || (isEditing ? 'false' : void 0)"
   />
   <Component
@@ -23,13 +23,7 @@
 </template>
 
 <script setup>
-import {
-  computed,
-  provide,
-  useRuntimeConfig,
-  inject,
-  defineAsyncComponent
-} from "#imports";
+import { computed, provide, inject, defineAsyncComponent } from "#imports";
 import { getComponent } from "#blokkli/helpers/imports";
 import {
   INJECT_ALL_COMPONENTS_CHUNK,
@@ -38,9 +32,10 @@ import {
   INJECT_FIELD_LIST_TYPE,
   INJECT_FIELD_PROXY_MODE,
   INJECT_FIELD_USES_PROXY,
-  INJECT_GLOBAL_PROXY_MODE
-} from "../helpers/symbols";
-const itemEntityType = useRuntimeConfig().public.blokkli.itemEntityType;
+  INJECT_GLOBAL_PROXY_MODE,
+  INJECT_ITEM_PROPS_OVERRIDE
+} from "../helpers/injections";
+import { fragmentBlockBundle, itemEntityType } from "#blokkli-build/config";
 const componentProps = defineProps({
   uuid: { type: String, required: true },
   bundle: { type: String, required: true },
@@ -53,20 +48,24 @@ const componentProps = defineProps({
   isEditing: { type: Boolean, required: false, default: false }
 });
 const isProxyMode = inject(INJECT_FIELD_PROXY_MODE, false);
-const allComponentsChunk = inject(
-  INJECT_ALL_COMPONENTS_CHUNK,
-  null
-);
+const mutatedItemProps = inject(INJECT_ITEM_PROPS_OVERRIDE, null);
+const allComponentsChunk = inject(INJECT_ALL_COMPONENTS_CHUNK, null);
 const fieldUsesProxy = inject(INJECT_FIELD_USES_PROXY, false);
-const isGlobalProxyMode = inject(
-  INJECT_GLOBAL_PROXY_MODE,
-  null
-);
-const fieldListType = inject(
-  INJECT_FIELD_LIST_TYPE,
-  void 0
-);
-const component = isProxyMode || isGlobalProxyMode?.value ? defineAsyncComponent(() => import("./Edit/BlockProxy/index.vue")) : getComponent(
+const isGlobalProxyMode = inject(INJECT_GLOBAL_PROXY_MODE, null);
+const fieldListType = inject(INJECT_FIELD_LIST_TYPE, void 0);
+const itemProps = computed(() => {
+  if (mutatedItemProps) {
+    const mutatedProps = mutatedItemProps[componentProps.uuid];
+    if (mutatedProps) {
+      return {
+        ...componentProps.props,
+        ...mutatedProps
+      };
+    }
+  }
+  return componentProps.props;
+});
+const component = isProxyMode || isGlobalProxyMode?.value ? defineAsyncComponent(() => import("./../editor/components/BlockProxy/index.vue")) : getComponent(
   "block",
   componentProps.bundle,
   fieldListType?.value || "default",
@@ -81,7 +80,7 @@ const item = computed(() => ({
   options: componentProps.options || {},
   isEditing: componentProps.isEditing,
   parentType: componentProps.parentType,
-  fragmentName: componentProps.bundle === "blokkli_fragment" ? componentProps.props?.name : void 0
+  fragmentName: componentProps.bundle === fragmentBlockBundle ? componentProps.props?.name : void 0
 }));
 provide(INJECT_BLOCK_ITEM, item);
 provide(INJECT_ENTITY_CONTEXT, {

package/dist/runtime/components/BlokkliItem.vue.d.ts

@@ -1,5 +1,7 @@
-import type { BlockEditContext } from '#blokkli/types';
-declare const _default: import("vue").DefineComponent<{
+import type { BlockEditContext } from '#blokkli/types/field';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
     uuid: string;
     bundle: string;
     isVisible?: boolean;
@@ -20,11 +22,10 @@ declare const _default: import("vue").DefineComponent<{
     parentType?: string;
     isEditing?: boolean;
 }> & Readonly<{}>, {
-    index: number;
-    options: any;
-    parentType: string;
     isEditing: boolean;
-    editContext: BlockEditContext;
     props: any;
+    options: any;
+    editContext: BlockEditContext;
+    index: number;
+    parentType: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-export default _default;

package/dist/runtime/components/BlokkliProvider.d.vue.ts

@@ -0,0 +1,77 @@
+import type { EditPermission } from '#blokkli/types/provider';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        /**
+         * The entity type.
+         */
+        entityType: string;
+        /**
+         * The entity bundle.
+         */
+        entityBundle: string;
+        /**
+         * The entity UUID.
+         */
+        entityUuid: string;
+        /**
+         * The tag to use for the root element.
+         */
+        tag?: string;
+        /**
+         * The current language code.
+         */
+        language?: string;
+        /**
+         * The override label for the edit button.
+         */
+        editLabel?: string;
+        /**
+         * The path to use to open the editor. Defaults to the current route.path value.
+         */
+        editPath?: string;
+        /**
+         * The host options as a key value object.
+         */
+        hostOptions?: Record<string, any>;
+        /**
+         * The edit permissions.
+         */
+        permissions?: Array<EditPermission | null>;
+        /**
+         * Whether to isolate the provider element during editing.
+         */
+        isolate?: boolean;
+    } & ({
+        /**
+         * The entity data. Will be merged with the mutatedEntity data during editing.
+         */
+        entity: T;
+    } | {
+        /**
+         * The entity data. Will be merged with the mutatedEntity data during editing.
+         */
+        entity?: never;
+    })> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default(props: {
+            isEditing: boolean;
+            canEdit: boolean;
+            isPreview: boolean;
+            entity: T;
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/components/BlokkliProvider.vue

@@ -79,7 +79,7 @@ import {
 import {
   INJECT_ENTITY_CONTEXT,
   INJECT_PROVIDER_CONTEXT
-} from "../helpers/symbols";
+} from "../helpers/injections";
 const props = defineProps({
   entityType: { type: String, required: true },
   entityBundle: { type: String, required: true },
@@ -96,22 +96,22 @@ const props = defineProps({
 defineSlots();
 const providerEl = useTemplateRef("providerEl");
 const PreviewProvider = defineAsyncComponent(
-  () => import("./Edit/PreviewProvider.vue")
+  () => import("./../editor/components/PreviewProvider.vue")
 );
 const EditProvider = defineAsyncComponent(
-  () => import("./Edit/EditProvider.vue")
+  () => import("./../editor/components/EditProvider.vue")
 );
 const BlokkliRootErrorBoundary = defineAsyncComponent(
-  () => import("./Edit/BlokkliRootErrorBoundary.vue")
+  () => import("./../editor/components/BlokkliRootErrorBoundary.vue")
 );
 const EditIndicator = defineAsyncComponent(
-  () => import("./Edit/EditIndicator.vue")
+  () => import("./../editor/components/EditIndicator.vue")
 );
 const route = useRoute();
 const router = useRouter();
 const shouldRender = ref(false);
 const isInEditor = computed(
-  () => props.entityUuid && props.entityType && props.entityBundle && (isPreviewing.value || isEditing.value)
+  () => !!props.entityUuid && !!props.entityType && !!props.entityBundle && (isPreviewing.value || isEditing.value)
 );
 const canEdit = computed(() => props.permissions.includes("edit"));
 const canUseBlokkli = computed(() => !!props.permissions.length);

package/dist/runtime/components/BlokkliProvider.vue.d.ts

@@ -1,6 +1,6 @@
-import type { EditPermission } from '#blokkli/types';
-declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & ({
+import type { EditPermission } from '#blokkli/types/provider';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
         /**
          * The entity type.
          */
@@ -51,8 +51,10 @@ declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>
          * The entity data. Will be merged with the mutatedEntity data during editing.
          */
         entity?: never;
-    })) & Partial<{}>> & import("vue").PublicProps;
-    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    })> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
     attrs: any;
     slots: {
         default(props: {
@@ -66,7 +68,10 @@ declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };
+declare const _default: typeof __VLS_export;
 export default _default;
-type __VLS_PrettifyLocal<T> = {
+type __VLS_PrettifyLocal<T> = (T extends any ? {
     [K in keyof T]: T[K];
-} & {};
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/composables/defineBlokkli.d.ts

@@ -1,5 +1,5 @@
-import type { BlockDefinitionInput, BlockDefinitionOptionsInput, BundleKey, DefineBlokkliContext } from '#blokkli/types';
 import type { GlobalOptionsKey } from '#blokkli-build/generated-types';
+import type { BlockDefinitionInput, BlockDefinitionOptionsInput, BundleKey, DefineBlokkliContext } from '#blokkli/types/definitions';
 /**
  * Define a blokkli component.
  */

package/dist/runtime/composables/defineBlokkli.js

@@ -8,60 +8,58 @@ import {
   INJECT_PROVIDER_CONTEXT,
   INJECT_FIELD_USES_PROXY,
   INJECT_REUSABLE_UUID
-} from "../helpers/symbols.js";
+} from "../helpers/injections.js";
 import { computed, inject } from "#imports";
 import { getRuntimeOptionValue } from "#blokkli/helpers/runtimeHelpers";
 import {
   OPTIONS
 } from "#blokkli-build/runtime-options";
 import {
-  BUNDLE_BLOKKLI_FRAGMENT,
-  BUNDLE_FROM_LIBRARY
-} from "#blokkli/constants";
+  fragmentBlockBundle,
+  fromLibraryBlockBundle
+} from "#blokkli-build/config";
 export function defineBlokkli(arg) {
   const [bundle, identifier] = arg.split("::", 2);
   const fieldListType = inject(
     INJECT_FIELD_LIST_TYPE,
-    computed(() => "default")
+    () => computed(() => "default"),
+    true
   );
   const siblings = inject(
     INJECT_FIELD_LIST_BLOCKS,
-    computed(function() {
+    () => computed(function() {
       return [];
-    })
+    }),
+    true
   );
   const rootBlocks = inject(
     INJECT_PROVIDER_BLOCKS,
-    computed(function() {
+    () => computed(function() {
       return [];
-    })
-  );
-  const item = inject(
-    INJECT_BLOCK_ITEM,
-    null
+    }),
+    true
   );
+  const item = inject(INJECT_BLOCK_ITEM, null);
   const uuid = item?.value.uuid || "";
   const index = item?.value.index !== void 0 ? item.value.index : computed(() => 0);
-  const fromLibraryOptions = inject(
-    INJECT_REUSABLE_OPTIONS,
-    null
-  );
+  const fromLibraryOptions = inject(INJECT_REUSABLE_OPTIONS, null);
   const reusableUuid = inject(INJECT_REUSABLE_UUID, null);
   const editContext = inject(INJECT_EDIT_CONTEXT, null);
   const provider = inject(
     INJECT_PROVIDER_CONTEXT,
-    computed(() => null)
+    () => computed(() => null),
+    true
   );
   const parentType = computed(() => item?.value.parentType);
   const isEditing = !!item?.value.isEditing;
   const options = computed(() => {
-    if (bundle === BUNDLE_FROM_LIBRARY) {
+    if (bundle === fromLibraryBlockBundle) {
       return {
         ...item?.value.options || {},
         ...editContext?.mutatedOptions[uuid] || {}
       };
     }
-    const optionKey = bundle === BUNDLE_BLOKKLI_FRAGMENT ? "fragment:" + item?.value.fragmentName : identifier;
+    const optionKey = bundle === fragmentBlockBundle ? "fragment:" + item?.value.fragmentName : identifier;
     const runtimeOptionDefinitions = (editContext?.definitions.runtimeOptions.value || OPTIONS)[optionKey] || {};
     const result = Object.entries(runtimeOptionDefinitions).reduce((acc, [key, v]) => {
       const definition = v;
@@ -94,7 +92,7 @@ export function defineBlokkli(arg) {
     import.meta.hot.accept("#blokkli/helpers/runtimeHelpers", () => {
     });
   }
-  if (editContext?.useBlockRegistration && editContext.dom && bundle !== BUNDLE_FROM_LIBRARY && bundle !== BUNDLE_BLOKKLI_FRAGMENT) {
+  if (editContext?.useBlockRegistration && editContext.dom && bundle !== fromLibraryBlockBundle && bundle !== fragmentBlockBundle) {
     const isProxyMode = inject(INJECT_FIELD_USES_PROXY, false);
     if (!isProxyMode) {
       editContext.useBlockRegistration(editContext.dom, reusableUuid ?? uuid);
@@ -103,7 +101,6 @@ export function defineBlokkli(arg) {
   return {
     uuid,
     index,
-    // Must be cast because type of options is inferred automatically.
     options,
     isEditing,
     parentType,

package/dist/runtime/composables/defineBlokkliFeature.d.ts

@@ -1,8 +1,8 @@
 import { type ComputedRef } from '#imports';
-import type { BlokkliAdapter, AdapterMethods } from '#blokkli/adapter';
-import type { FeatureDefinition } from '#blokkli/types';
+import type { BlokkliAdapter, AdapterMethods } from '#blokkli/editor/adapter';
 import type { ValidFeatureKey } from '#blokkli-build/features';
-import type { DebugLogger } from '#blokkli/helpers/providers/debug';
+import type { DebugLogger } from '#blokkli/editor/providers/debug';
+import type { FeatureDefinition } from '#blokkli/editor/types/features';
 type SettingType<S> = S extends {
     type: 'checkbox';
 } ? boolean : S extends {

package/dist/runtime/composables/defineBlokkliFeature.js

@@ -5,8 +5,8 @@ import {
   onUnmounted,
   provide
 } from "#imports";
-import { settingsOverride } from "#blokkli-build/config";
-import { INJECT_EDIT_LOGGER } from "#blokkli/helpers/symbols";
+import { settingsOverride } from "#blokkli-build/editor-config";
+import { INJECT_EDIT_LOGGER } from "#blokkli/helpers/injections";
 export function defineBlokkliFeature(feature) {
   const { adapter, storage, features, debug } = useBlokkli();
   const logger = debug.createLogger(feature.label || feature.id);

package/dist/runtime/composables/defineBlokkliFragment.d.ts

@@ -1,3 +1,3 @@
-import type { BlockDefinitionOptionsInput, DefineBlokkliContext, FragmentDefinitionInput } from '#blokkli/types';
+import type { BlockDefinitionOptionsInput, DefineBlokkliContext, FragmentDefinitionInput } from '#blokkli/types/definitions';
 import type { GlobalOptionsKey } from '#blokkli-build/generated-types';
 export declare function defineBlokkliFragment<T extends BlockDefinitionOptionsInput = BlockDefinitionOptionsInput, G extends GlobalOptionsKey[] | undefined = undefined>(_config: FragmentDefinitionInput<T, G>): DefineBlokkliContext<T, G>;

package/dist/runtime/composables/defineBlokkliFragment.js

@@ -1,13 +1,10 @@
 import {
   INJECT_EDIT_CONTEXT,
   INJECT_FRAGMENT_CONTEXT
-} from "../helpers/symbols.js";
+} from "../helpers/injections.js";
 import { inject, computed } from "#imports";
 export function defineBlokkliFragment(_config) {
-  const ctx = inject(
-    INJECT_FRAGMENT_CONTEXT,
-    null
-  );
+  const ctx = inject(INJECT_FRAGMENT_CONTEXT, null);
   if (!ctx) {
     return {
       uuid: "",

package/dist/runtime/composables/defineBlokkliProvider.d.ts

@@ -1,4 +1,4 @@
-import type { BlockDefinitionOptionsInput, DefineProviderContext, ProviderDefinitionInput } from '#blokkli/types';
+import type { BlockDefinitionOptionsInput, DefineProviderContext, ProviderDefinitionInput } from '#blokkli/types/definitions';
 import type { GlobalOptionsKey } from '#blokkli-build/generated-types';
 type DefineBlokkliProviderProps = {
     hostOptions?: any;

package/dist/runtime/composables/defineBlokkliProvider.js

@@ -1,5 +1,5 @@
 import { computed, provide, useState } from "#imports";
-import { INJECT_PROVIDER_KEY } from "#blokkli/helpers/symbols";
+import { INJECT_PROVIDER_KEY } from "#blokkli/helpers/injections";
 import {
   OPTIONS
 } from "#blokkli-build/runtime-options";

package/dist/runtime/composables/useBlokkli.d.ts

@@ -1,4 +1,4 @@
-import type { BlokkliApp } from '#blokkli/types';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
 /**
  * Use the blokkli editor app.
  *

package/dist/runtime/composables/useBlokkli.js

@@ -1,7 +1,7 @@
-import { INJECT_APP } from "../helpers/symbols.js";
+import { INJECT_APP } from "../helpers/injections.js";
 import { inject } from "#imports";
 export function useBlokkli(optional) {
-  const app = inject(INJECT_APP);
+  const app = inject(INJECT_APP, void 0);
   if (!app) {
     if (optional) {
       return void 0;

package/dist/runtime/composables/useBlokkliHelper.d.ts

@@ -1,6 +1,7 @@
 import { type ComputedRef } from '#imports';
 import type { FieldListItemTyped } from '#blokkli-build/generated-types';
-type BundleWithoutLibrary = Exclude<FieldListItemTyped['bundle'], 'from_library'>;
+import type { fromLibraryBlockBundle } from '#blokkli-build/config';
+type BundleWithoutLibrary = Exclude<FieldListItemTyped['bundle'], typeof fromLibraryBlockBundle>;
 type CallbackResult = {
     include: boolean;
     continueChildren?: boolean;

package/dist/runtime/composables/useBlokkliHelper.js

@@ -2,7 +2,7 @@ import {
   INJECT_EDIT_CONTEXT,
   INJECT_MUTATED_FIELDS_MAP,
   INJECT_PROVIDER_BLOCKS
-} from "#blokkli/helpers/symbols";
+} from "#blokkli/helpers/injections";
 import { inject, computed, watch, ref } from "#imports";
 import { FIELD_MAPPING } from "#blokkli-build/runtime-options";
 import { getActualBlock } from "#blokkli/helpers/runtimeHelpers";
@@ -10,12 +10,12 @@ function walkBlocks(matches, callback, mutatedOptions, mutatedFieldsMap, list) {
   if (!list) return;
   for (let i = 0; i < list.length; i++) {
     const item = list[i];
-    if (!item) continue;
+    if (!item || typeof item !== "object") continue;
     if (!("bundle" in item) || !("uuid" in item)) continue;
     const mutatedOptionsForBlock = mutatedOptions[item.uuid] ?? {};
     const mappedItem = getActualBlock({
       ...item,
-      options: { ...item.options, ...mutatedOptionsForBlock }
+      options: { ...item.options || {}, ...mutatedOptionsForBlock }
     });
     if (!mappedItem) continue;
     const callbackResult = callback(mappedItem);
@@ -48,16 +48,10 @@ function walkBlocks(matches, callback, mutatedOptions, mutatedFieldsMap, list) {
   }
 }
 export function useBlokkliHelper() {
-  const rootBlocks = inject(
-    INJECT_PROVIDER_BLOCKS,
-    null
-  );
+  const rootBlocks = inject(INJECT_PROVIDER_BLOCKS, null);
   const editContext = inject(INJECT_EDIT_CONTEXT, null);
   const mutatedOptions = ref({});
-  const mutatedFields = inject(
-    INJECT_MUTATED_FIELDS_MAP,
-    null
-  );
+  const mutatedFields = inject(INJECT_MUTATED_FIELDS_MAP, null);
   if (editContext?.mutatedOptions) {
     watch(editContext.mutatedOptions, (options) => {
       mutatedOptions.value = options;