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

package/dist/runtime/components/Edit/RelativeTime/index.vue.d.ts

@@ -3,9 +3,9 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{
 }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
     timestamp: number;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    default?: ((props: {
+    default?: (props: {
         formatted: string;
-    }) => any) | undefined;
+    }) => any;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/runtime/components/Edit/Resizable/index.vue.d.ts

@@ -3,7 +3,7 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{
 }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
     id: string;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    default?: ((props: {}) => any) | undefined;
+    default?: (props: {}) => any;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/runtime/components/Edit/ScaleToFit/index.vue.d.ts

@@ -5,7 +5,7 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{
     width?: number;
     maxHeight?: number;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    default?: ((props: {}) => any) | undefined;
+    default?: (props: {}) => any;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/runtime/components/Edit/ScrollBoundary/index.vue.d.ts

@@ -4,15 +4,10 @@ type __VLS_Props = {
      */
     dragging?: boolean;
 };
-declare function onWheel(e: WheelEvent): void;
-declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
 declare var __VLS_1: {};
-type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
-}>;
-declare const __VLS_self: import("vue").DefineComponent<__VLS_Props, {
-    onWheel: typeof onWheel;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+};
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/runtime/components/Edit/Sortli/index.vue.d.ts

@@ -4,7 +4,7 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<{
 }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
     getDragItems?: (activeItem?: DraggableItem) => DraggableItem[] | null;
 }> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
-    default?: ((props: {}) => any) | undefined;
+    default?: (props: {}) => any;
 }>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/runtime/components/Edit/SystemRequirements/index.vue

@@ -40,8 +40,8 @@
         <p>
           {{
             $t(
-  'systemRequirementsDialogText',
-  'bl\xF6kkli has been tested and optimized for the latest versions of Chrome, Firefox, Edge, and Safari. Features like WebGL are well supported, but they may sometimes be disabled for performance or security reasons.'
+  "systemRequirementsDialogText",
+  "bl\xF6kkli has been tested and optimized for the latest versions of Chrome, Firefox, Edge, and Safari. Features like WebGL are well supported, but they may sometimes be disabled for performance or security reasons."
 )
           }}
         </p>

package/dist/runtime/components/Edit/ViewportBlockingRect/index.vue.d.ts

@@ -1,15 +1,10 @@
 type __VLS_Props = {
     id: string;
 };
-declare const el: import("vue").Ref<HTMLDivElement | null, HTMLDivElement | null>;
-declare const __VLS_ctx: InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>;
 declare var __VLS_1: {};
-type __VLS_Slots = __VLS_PrettifyGlobal<__VLS_OmitStringIndex<typeof __VLS_ctx.$slots> & {
+type __VLS_Slots = {} & {
     default?: (props: typeof __VLS_1) => any;
-}>;
-declare const __VLS_self: import("vue").DefineComponent<__VLS_Props, {
-    el: typeof el;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+};
 declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;

package/dist/runtime/composables/defineBlokkli.js

@@ -5,7 +5,8 @@ import {
   INJECT_FIELD_LIST_TYPE,
   INJECT_REUSABLE_OPTIONS,
   INJECT_PROVIDER_BLOCKS,
-  INJECT_PROVIDER_CONTEXT
+  INJECT_PROVIDER_CONTEXT,
+  INJECT_FIELD_USES_PROXY
 } from "../helpers/symbols.js";
 import { computed, inject } from "#imports";
 import { getRuntimeOptionValue } from "#blokkli/helpers/runtimeHelpers";
@@ -87,6 +88,12 @@ export function defineBlokkli(arg) {
     import.meta.hot.accept("#blokkli/helpers/runtimeHelpers", () => {
     });
   }
+  if (editContext?.useBlockRegistration && editContext.dom && bundle !== "from_library" && bundle !== "blokkli_fragment") {
+    const isProxyMode = inject(INJECT_FIELD_USES_PROXY, false);
+    if (!isProxyMode) {
+      editContext.useBlockRegistration(editContext.dom, uuid);
+    }
+  }
   return {
     uuid,
     index,

package/dist/runtime/composables/defineBlokkliFragment.js

@@ -1,4 +1,7 @@
-import { INJECT_FRAGMENT_CONTEXT } from "../helpers/symbols.js";
+import {
+  INJECT_EDIT_CONTEXT,
+  INJECT_FRAGMENT_CONTEXT
+} from "../helpers/symbols.js";
 import { inject, computed } from "#imports";
 export function defineBlokkliFragment(_config) {
   const ctx = inject(
@@ -18,5 +21,9 @@ export function defineBlokkliFragment(_config) {
       provider: computed(() => null)
     };
   }
+  const editContext = inject(INJECT_EDIT_CONTEXT, null);
+  if (editContext?.dom && editContext.useBlockRegistration) {
+    editContext.useBlockRegistration(editContext.dom, ctx.uuid);
+  }
   return ctx;
 }

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

@@ -0,0 +1,19 @@
+import { type ComputedRef } from '#imports';
+import type { FieldListItemTyped } from '#blokkli-build/generated-types';
+type BundleWithoutLibrary = Exclude<FieldListItemTyped['bundle'], 'from_library'>;
+type CallbackResult = {
+    include: boolean;
+    continueChildren?: boolean;
+} | undefined | null;
+type UseBlokkliHelper = {
+    /**
+     * Iterates over the all blocks of the current field and returns a flat array
+     * of matching block bundles.
+     */
+    queryBlocks<K extends BundleWithoutLibrary>(bundles: K[], providedList?: FieldListItemTyped[]): ComputedRef<Extract<FieldListItemTyped, {
+        bundle: K;
+    }>[]>;
+    queryBlocks(bundles: (item: FieldListItemTyped) => CallbackResult, providedList?: FieldListItemTyped[]): ComputedRef<FieldListItemTyped[]>;
+};
+export declare function useBlokkliHelper(): UseBlokkliHelper;
+export {};

package/dist/runtime/composables/useBlokkliHelper.js

@@ -0,0 +1,82 @@
+import {
+  INJECT_EDIT_CONTEXT,
+  INJECT_PROVIDER_BLOCKS
+} from "#blokkli/helpers/symbols";
+import { inject, computed, watch, ref } from "#imports";
+import { FIELD_MAPPING } from "#blokkli-build/runtime-options";
+import { getActualBlock } from "#blokkli/helpers/runtimeHelpers";
+function walkBlocks(matches, callback, mutatedOptions, list) {
+  if (!list) return;
+  for (let i = 0; i < list.length; i++) {
+    const item = list[i];
+    if (!item) continue;
+    if (!("bundle" in item) || !("uuid" in item)) continue;
+    const mutatedOptionsForBlock = mutatedOptions[item.uuid] ?? {};
+    const mappedItem = getActualBlock({
+      ...item,
+      options: { ...item.options, ...mutatedOptionsForBlock }
+    });
+    if (!mappedItem) continue;
+    const callbackResult = callback(mappedItem);
+    if (callbackResult === null || callbackResult === void 0) {
+      continue;
+    } else if (callbackResult.include) {
+      matches.push(mappedItem);
+    }
+    if (callbackResult.continueChildren === false) {
+      continue;
+    }
+    const nestedFieldMapping = FIELD_MAPPING[mappedItem.bundle];
+    if (!nestedFieldMapping) continue;
+    if (!mappedItem.props) continue;
+    const propNames = Object.keys(nestedFieldMapping);
+    for (const propName of propNames) {
+      const value = mappedItem.props[propName];
+      if (!value) continue;
+      const valueAsArray = Array.isArray(value) ? value : [value];
+      walkBlocks(matches, callback, mutatedOptions, valueAsArray);
+    }
+  }
+}
+export function useBlokkliHelper() {
+  const rootBlocks = inject(
+    INJECT_PROVIDER_BLOCKS,
+    null
+  );
+  const editContext = inject(INJECT_EDIT_CONTEXT, null);
+  const mutatedOptions = ref({});
+  if (editContext?.mutatedOptions) {
+    watch(editContext.mutatedOptions, (options) => {
+      mutatedOptions.value = options;
+    });
+  }
+  function queryBlocks(bundlesOrCallback, providedList) {
+    const callback = typeof bundlesOrCallback === "function" ? bundlesOrCallback : (item) => {
+      if (bundlesOrCallback.includes(item.bundle)) {
+        return {
+          include: true,
+          continueChildren: true
+        };
+      }
+      return {
+        include: false,
+        continueChildren: true
+      };
+    };
+    return computed(() => {
+      const matches = [];
+      const list = providedList ? providedList : rootBlocks?.value;
+      if (!list) {
+        console.error(
+          "[bl\xF6kkli] - Failed to inject rootBlocks in queryBlocks. Automatic injection is only available when the useBlokkliHelper composable is called in a component inside <BlokkliField>. If this is not the case, pass the FieldListItemTyped array as the second argument to queryBlocks."
+        );
+        return [];
+      }
+      walkBlocks(matches, callback, mutatedOptions.value, list);
+      return matches;
+    });
+  }
+  return {
+    queryBlocks
+  };
+}