@blokkli/editor 1.3.4 → 1.4.0-alpha.1

package/dist/runtime/composables/defineBlokkli.js

@@ -4,23 +4,14 @@ import {
   INJECT_FIELD_LIST_BLOCKS,
   INJECT_FIELD_LIST_TYPE,
   INJECT_REUSABLE_OPTIONS,
-  INJECT_PROVIDER_BLOCKS,
-  INJECT_FIELD_USES_PROXY
+  INJECT_PROVIDER_BLOCKS
 } from "../helpers/symbols.js";
-import {
-  computed,
-  inject,
-  getCurrentInstance,
-  onMounted,
-  onBeforeUnmount
-} from "#imports";
-import { globalOptionsDefaults } from "#blokkli/default-global-options";
+import { computed, inject } from "#imports";
 import { getRuntimeOptionValue } from "#blokkli/helpers/runtimeHelpers";
-export function defineBlokkli(config) {
-  const optionKeys = [
-    ...Object.keys(config.options || {}),
-    ...config.globalOptions || []
-  ];
+import { BLOCK_OPTIONS } from "#blokkli-build/runtime-options";
+export function defineBlokkli(arg) {
+  const config = arg;
+  const bundle = config.bundle;
   const fieldListType = inject(
     INJECT_FIELD_LIST_TYPE,
     computed(() => "default")
@@ -45,67 +36,40 @@ export function defineBlokkli(config) {
     null
   );
   const editContext = inject(INJECT_EDIT_CONTEXT, null);
+  const runtimeOptionDefinitions = BLOCK_OPTIONS[bundle] || {};
   const options = computed(() => {
-    if (config.bundle === "from_library" || config.bundle === "blokkli_fragment") {
+    if (bundle === "from_library" || bundle === "blokkli_fragment") {
       return {
         ...item?.value.options || {},
         ...editContext?.mutatedOptions[uuid] || {}
       };
     }
-    const result = optionKeys.reduce((acc, key) => {
+    const result = Object.entries(runtimeOptionDefinitions).reduce((acc, [key, definition]) => {
       if (editContext) {
         const overrideOptions = editContext.mutatedOptions[uuid] || {};
-        if (overrideOptions[key] !== void 0) {
-          acc[key] = overrideOptions[key];
+        if (overrideOptions[key] !== void 0 && overrideOptions[key] !== null) {
+          acc[key] = getRuntimeOptionValue(definition, overrideOptions[key]);
           return acc;
         }
       }
-      if (fromLibraryOptions && fromLibraryOptions.value[key] !== void 0) {
-        acc[key] = fromLibraryOptions.value[key];
+      if (fromLibraryOptions && fromLibraryOptions.value[key] !== void 0 && fromLibraryOptions.value[key] !== null) {
+        acc[key] = getRuntimeOptionValue(
+          definition,
+          fromLibraryOptions.value[key]
+        );
         return acc;
       }
-      if (item?.value.options && item.value.options[key] !== void 0) {
-        acc[key] = item.value.options[key];
+      if (item?.value.options && item.value.options[key] !== void 0 && item.value.options[key] !== null) {
+        acc[key] = getRuntimeOptionValue(definition, item.value.options[key]);
         return acc;
       }
+      acc[key] = definition[1];
       return acc;
     }, {});
-    optionKeys.forEach((key) => {
-      const definition = config.options?.[key] || globalOptionsDefaults[key];
-      if (!definition) {
-        return;
-      }
-      const value = result[key] === void 0 || result[key] === null ? definition.default : result[key];
-      result[key] = getRuntimeOptionValue(definition, value);
-    });
     return result;
   });
   const parentType = computed(() => item?.value.parentType);
   const isEditing = !!item?.value.isEditing;
-  const fieldUsesProxy = inject(INJECT_FIELD_USES_PROXY, false);
-  onMounted(() => {
-    if (
-      // If the field uses proxy mode we don't want to register the block here.
-      fieldUsesProxy || !item?.value || !isEditing || !editContext || !editContext.dom || // Block is already registered by the from_library block.
-      fromLibraryOptions || // The defineBlokkliFragment composable registers the block itself.
-      config.bundle === "blokkli_fragment"
-    ) {
-      return;
-    }
-    const instance = getCurrentInstance();
-    editContext.dom.registerBlock(
-      uuid,
-      instance,
-      config.bundle,
-      fieldListType.value,
-      item.value.parentType
-    );
-  });
-  onBeforeUnmount(() => {
-    if (!fieldUsesProxy && isEditing && editContext && editContext.dom && uuid && config.bundle !== "blokkli_fragment") {
-      editContext.dom.unregisterBlock(uuid);
-    }
-  });
   return {
     uuid,
     index,

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

@@ -1,7 +1,7 @@
 import { type ComputedRef } from '#imports';
 import type { BlokkliAdapter, AdapterMethods } from '#blokkli/adapter';
 import type { FeatureDefinition } from '#blokkli/types';
-import type { ValidFeatureKey } from '#blokkli-runtime/features';
+import type { ValidFeatureKey } from '#blokkli-build/features';
 import type { DebugLogger } from '#blokkli/helpers/debugProvider';
 type SettingType<S> = S extends {
     type: 'checkbox';

package/dist/runtime/composables/defineBlokkliFeature.js

@@ -5,7 +5,7 @@ import {
   onUnmounted,
   provide
 } from "#imports";
-import { settingsOverride } from "#blokkli/config";
+import { settingsOverride } from "#blokkli-build/config";
 import { INJECT_EDIT_LOGGER } from "#blokkli/helpers/symbols";
 export function defineBlokkliFeature(feature) {
   const { adapter, storage, features, debug } = useBlokkli();

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

@@ -1,3 +1,3 @@
 import type { BlockDefinitionOptionsInput, DefineBlokkliContext, FragmentDefinitionInput } from '#blokkli/types';
-import type { GlobalOptionsKey } from '#blokkli/generated-types';
+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,22 +1,12 @@
-import {
-  INJECT_EDIT_CONTEXT,
-  INJECT_FRAGMENT_CONTEXT
-} from "../helpers/symbols.js";
+import { INJECT_FRAGMENT_CONTEXT } from "../helpers/symbols.js";
 import { getRuntimeOptionValue } from "../helpers/runtimeHelpers/index.js";
-import {
-  computed,
-  getCurrentInstance,
-  inject,
-  onBeforeUnmount,
-  onMounted
-} from "#imports";
-import { globalOptionsDefaults } from "#blokkli/default-global-options";
+import { computed, inject } from "#imports";
+import { globalOptionsDefaults } from "#blokkli-build/default-global-options";
 export function defineBlokkliFragment(config) {
   const ctx = inject(
     INJECT_FRAGMENT_CONTEXT,
     null
   );
-  const editContext = inject(INJECT_EDIT_CONTEXT, null);
   const optionKeys = [
     ...Object.keys(config.options || {}),
     ...config.globalOptions || []
@@ -36,22 +26,5 @@ export function defineBlokkliFragment(config) {
     });
     return result;
   });
-  onMounted(() => {
-    if (editContext && editContext.dom && ctx) {
-      const instance = getCurrentInstance();
-      editContext.dom.registerBlock(
-        ctx.uuid,
-        instance,
-        "blokkli_fragment",
-        ctx.fieldListType.value,
-        ctx.parentType.value
-      );
-    }
-  });
-  onBeforeUnmount(() => {
-    if (editContext && ctx && ctx.uuid && editContext.dom) {
-      editContext.dom.unregisterBlock(ctx.uuid);
-    }
-  });
   return { ...ctx, options };
 }