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

package/dist/modules/drupal/graphql/features/import-existing.graphql

@@ -1,17 +1,24 @@
 query pbGetImportSourceEntities(
   $entityType: String!
   $entityUuid: String!
-  $searchText: String
+  $filters: [ParagraphsBlokkliUserConfigInput]
+  $page: Int
 ) {
   pbGetImportSourceEntities(
     entityType: $entityType
     entityUuid: $entityUuid
-    searchText: $searchText
+    filters: $filters
+    page: $page
   ) {
     total
+    perPage
+    filters {
+      ...paragraphsBlokkliConfigInput
+    }
     items {
       uuid
       label
+      description
     }
   }
 }

package/dist/modules/drupal/graphql/features/library.graphql

@@ -40,14 +40,21 @@ mutation pbDetachReusableParagraph(
   }
 }
 
-query pbLibraryItems($bundles: [String]!, $page: Int, $text: String) {
+query pbLibraryItems(
+  $bundles: [String]!
+  $page: Int
+  $filters: [ParagraphsBlokkliUserConfigInput]
+) {
   result: paragraphsBlokkliSearchLibraryItems(
     bundles: $bundles
-    text: $text
     page: $page
+    filters: $filters
   ) {
     perPage
     total
+    filters {
+      ...paragraphsBlokkliConfigInput
+    }
     items {
       ...paragraphsBlokkliLibraryItem
     }

package/dist/modules/drupal/graphql/features/media-library.graphql

@@ -1,5 +1,8 @@
-query pbMediaLibraryGetResults($text: String, $bundle: String, $page: Int) {
-  pbMediaLibraryGetResults(text: $text, bundle: $bundle, page: $page) {
+query pbMediaLibraryGetResults(
+  $page: Int
+  $filters: [ParagraphsBlokkliUserConfigInput]
+) {
+  pbMediaLibraryGetResults(page: $page, filters: $filters) {
     items {
       label
       mediaId
@@ -11,18 +14,7 @@ query pbMediaLibraryGetResults($text: String, $bundle: String, $page: Int) {
     total
     perPage
     filters {
-      __typename
-      id
-      label
-      type
-      ... on ParagraphsBlokkliMediaLibraryFilterText {
-        placeholder
-      }
-
-      ... on ParagraphsBlokkliMediaLibraryFilterSelect {
-        default
-        options
-      }
+      ...paragraphsBlokkliConfigInput
     }
   }
 }

package/dist/modules/drupal/graphql/features/publishNew.graphql

@@ -52,5 +52,8 @@ query pbSearchEditStates($page: Int) {
         bundleLabel
       }
     }
+    filters {
+      ...paragraphsBlokkliConfigInput
+    }
   }
 }

package/dist/modules/drupal/index.d.mts

@@ -1,10 +1,11 @@
-import { B as BlokkliModule } from '../../shared/editor.CKsrTpc1.mjs';
+import { B as BlokkliModule } from '../../shared/editor.DHqea16T.mjs';
 import 'nuxt/schema';
-import '../../../dist/runtime/types/index.js';
-import '#blokkli-build/module-types';
-import '../../../dist/runtime/types/theme.js';
+import 'consola';
+import '../../../dist/global/types/definitions.js';
+import '../../../dist/global/types/theme.js';
 import '@nuxt/kit';
+import '../../../dist/global/types/features.js';
 
-declare const _default: (options?: object | undefined) => BlokkliModule<object>;
+declare const _default: (options?: object) => BlokkliModule<object>;
 
 export { _default as default };

package/dist/modules/drupal/index.mjs

@@ -1,4 +1,4 @@
-import { useLogger, createResolver } from '@nuxt/kit';
+import { createResolver } from '@nuxt/kit';
 import { fileURLToPath } from 'node:url';
 import { join } from 'pathe';
 import { isObjectType, isInterfaceType } from 'graphql';
@@ -13,8 +13,6 @@ function defineBlokkliModule(init) {
   };
 }
 
-const logger = useLogger("@blokkli/editor");
-
 function toPascalCase(text) {
   return text.replace(/(^\w|_\w)/g, clearAndUpper);
 }
@@ -54,7 +52,7 @@ const index = defineBlokkliModule({
   setup({ context, helper }) {
     helper.addAlias("#blokkli/drupal-adapter", getDrupalAdapterPath());
     if (!useGraphqlModuleContext({ nullOnMissing: true })) {
-      logger.box(
+      helper.logger.box(
         'Failed to load nuxt-graphql-middleware module context. Make sure that "nuxt-graphql-middleware" is placed before "@blokkli/editor" in your "modules" config in nuxt.config.ts.'
       );
       throw new Error("Failed to initialise bl\xF6kkli Drupal module.");

package/dist/modules/drupal/runtime/adapter/index.d.ts

@@ -1,3 +1,2 @@
-import type { ParagraphsBlokkliEditStateFragment } from '#graphql-operations';
-declare const _default: import("#blokkli/adapter").BlokkliAdapterFactory<ParagraphsBlokkliEditStateFragment>;
+declare const _default: any;
 export default _default;

package/dist/modules/drupal/runtime/adapter/index.js

@@ -1,4 +1,6 @@
-import { defineBlokkliEditAdapter } from "#blokkli/adapter";
+import {
+  defineBlokkliEditAdapter
+} from "#blokkli/editor/adapter";
 import { falsy } from "#blokkli/helpers";
 import { availableFeaturesAtBuild } from "#blokkli-build/features";
 import { operationSources } from "#nuxt-graphql-middleware/sources";
@@ -21,6 +23,17 @@ function mapPublishOptions(publishOptions) {
     revisionLogMessage: publishOptions.revisionLogMessage ?? null
   };
 }
+function configObjectToUserConfigInput(values) {
+  if (!values) {
+    return [];
+  }
+  return Object.entries(values).map(([name, value]) => {
+    return {
+      name,
+      value
+    };
+  });
+}
 function mapPluginConfigInputs(inputs) {
   return inputs.map((input) => {
     if (input.__typename === "ParagraphsBlokkliConfigInputText") {
@@ -344,18 +357,24 @@ export default defineBlokkliEditAdapter(
       });
     }
     if (hasQuery("pbGetImportSourceEntities")) {
-      adapter.getImportItems = (searchText) => useGraphqlQuery("pbGetImportSourceEntities", {
+      adapter.getImportItems = (args) => useGraphqlQuery("pbGetImportSourceEntities", {
         entityType: ctx.value.entityType.toLowerCase(),
         entityUuid: ctx.value.entityUuid,
-        searchText
+        page: args.page,
+        filters: configObjectToUserConfigInput(args.filters)
       }).then((data) => {
         return {
+          perPage: data.data.pbGetImportSourceEntities?.perPage ?? 16,
           total: data?.data.pbGetImportSourceEntities?.total || 0,
+          filters: mapPluginConfigInputs(
+            data.data.pbGetImportSourceEntities?.filters ?? []
+          ),
           items: (data?.data.pbGetImportSourceEntities?.items || []).map((item) => {
             if (item?.uuid) {
               return {
                 uuid: item.uuid,
-                label: item.label || item.uuid
+                label: item.label,
+                description: item.description
               };
             }
           }).filter(falsy)
@@ -539,7 +558,7 @@ export default defineBlokkliEditAdapter(
       adapter.getLibraryItems = (data) => {
         return useGraphqlQuery("pbLibraryItems", {
           bundles: data.bundles,
-          text: data.text,
+          filters: configObjectToUserConfigInput(data.filters),
           page: data.page
         }).then((response) => {
           const items = response.data.result?.items?.map((v) => {
@@ -560,7 +579,8 @@ export default defineBlokkliEditAdapter(
           return {
             items,
             perPage: response.data.result?.perPage || 16,
-            total: response.data.result?.total || 0
+            total: response.data.result?.total || 0,
+            filters: mapPluginConfigInputs(response.data.result?.filters ?? [])
           };
         });
       };
@@ -682,28 +702,13 @@ export default defineBlokkliEditAdapter(
     if (hasQuery("pbMediaLibraryGetResults")) {
       adapter.mediaLibraryGetResults = (e) => {
         return useGraphqlQuery("pbMediaLibraryGetResults", {
-          text: e.filters.text,
-          bundle: e.filters.bundle,
+          filters: configObjectToUserConfigInput(e.filters),
           page: e.page
         }).then((data) => {
           return {
-            filters: (data.data.pbMediaLibraryGetResults?.filters || []).reduce((acc, filter) => {
-              if (filter?.__typename === "ParagraphsBlokkliMediaLibraryFilterText") {
-                acc[filter.id] = {
-                  type: "text",
-                  placeholder: filter.placeholder,
-                  label: filter.label
-                };
-              } else if (filter?.__typename === "ParagraphsBlokkliMediaLibraryFilterSelect") {
-                acc[filter.id] = {
-                  type: "select",
-                  label: filter.label,
-                  default: filter.default,
-                  options: filter.options
-                };
-              }
-              return acc;
-            }, {}),
+            filters: mapPluginConfigInputs(
+              data.data.pbMediaLibraryGetResults?.filters ?? []
+            ),
             items: (data.data.pbMediaLibraryGetResults?.items || []).filter(
               falsy
             ),
@@ -720,7 +725,7 @@ export default defineBlokkliEditAdapter(
           targetId: e.item.mediaId,
           targetBundle: e.item.mediaBundle,
           targetType: "media",
-          paragraphBundle: e.item.itemBundle,
+          paragraphBundle: e.targetBundle,
           hostType: e.host.type,
           hostUuid: e.host.uuid,
           hostFieldName: e.host.fieldName,
@@ -737,7 +742,7 @@ export default defineBlokkliEditAdapter(
               targetId: item.mediaId,
               targetType: "media",
               targetBundle: item.mediaBundle,
-              paragraphBundle: item.itemBundle
+              paragraphBundle: e.targetBundle
             };
           }),
           hostType: e.host.type,
@@ -876,7 +881,10 @@ export default defineBlokkliEditAdapter(
               return null;
             }).filter(falsy),
             total: data.data.pbSearchEditStates?.total || 0,
-            perPage: data.data.pbSearchEditStates?.perPage || 0
+            perPage: data.data.pbSearchEditStates?.perPage || 0,
+            filters: mapPluginConfigInputs(
+              data.data.pbSearchEditStates?.filters ?? []
+            )
           };
         });
       };

package/dist/runtime/components/Blocks/Fragment/index.d.vue.ts

@@ -0,0 +1,7 @@
+import type { BlokkliFragmentName } from '#blokkli-build/definitions';
+export type Props = {
+    name: BlokkliFragmentName;
+};
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/Blocks/Fragment/index.vue

@@ -5,13 +5,14 @@
 <script setup>
 import { getComponent } from "#blokkli/helpers/imports";
 import { provide, defineBlokkli } from "#imports";
-import { INJECT_FRAGMENT_CONTEXT } from "#blokkli/helpers/symbols";
+import { INJECT_FRAGMENT_CONTEXT } from "#blokkli/helpers/injections";
 const componentProps = defineProps({
   name: { type: null, required: true }
 });
 const ctx = defineBlokkli({
-  bundle: "blokkli_fragment",
+  bundle: "BK_BUNDLE_FRAGMENT",
   editor: {
+    icon: "bk_mdi_newspaper",
     disableEdit: true
   }
 });

package/dist/runtime/components/Blocks/Fragment/index.vue.d.ts

@@ -2,5 +2,6 @@ import type { BlokkliFragmentName } from '#blokkli-build/definitions';
 export type Props = {
     name: BlokkliFragmentName;
 };
-declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/Blocks/FromLibrary/index.d.vue.ts

@@ -0,0 +1,7 @@
+import type { LibraryItemProps } from '#blokkli/editor/features/library/types';
+export type Props = {
+    libraryItem?: LibraryItemProps;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/Blocks/FromLibrary/index.vue

@@ -15,13 +15,17 @@ import {
   INJECT_IS_IN_REUSABLE,
   INJECT_REUSABLE_OPTIONS,
   INJECT_REUSABLE_UUID
-} from "#blokkli/helpers/symbols";
+} from "#blokkli/helpers/injections";
 const props = defineProps({
   libraryItem: { type: Object, required: false }
 });
-const { index, options, parentType, isEditing, uuid } = defineBlokkli({
-  bundle: "from_library"
+const { index, options, parentType, uuid } = defineBlokkli({
+  bundle: "BK_BUNDLE_FROM_LIBRARY",
+  editor: {
+    icon: "reusable"
+  }
 });
+const isEditing = import.meta.blokkliEditing;
 provide(INJECT_REUSABLE_OPTIONS, options);
 provide(INJECT_IS_IN_REUSABLE, true);
 provide(INJECT_REUSABLE_UUID, uuid);

package/dist/runtime/components/Blocks/FromLibrary/index.vue.d.ts

@@ -1,6 +1,7 @@
-import type { LibraryItemProps } from '#blokkli/types';
+import type { LibraryItemProps } from '#blokkli/editor/features/library/types';
 export type Props = {
     libraryItem?: LibraryItemProps;
 };
-declare const _default: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/Blocks/NotImplemented/index.d.vue.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    uuid: string;
+    bundle: string;
+};
+declare const __VLS_export: 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: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/Blocks/NotImplemented/index.vue

@@ -1,14 +1,14 @@
 <template>
   <div class="bk bk-block-not-implemented">
-    <Icon name="alert" />
+    <Icon name="bk_mdi_warning" />
     <div v-html="text" />
   </div>
 </template>
 
 <script setup>
-import { useBlockRegistration } from "#blokkli/helpers/composables/useBlockRegistration";
 import { computed, useBlokkli } from "#imports";
-import { Icon } from "#blokkli/components";
+import { Icon } from "#blokkli/editor/components";
+import { useBlockRegistration } from "#blokkli/editor/composables";
 const props = defineProps({
   uuid: { type: String, required: true },
   bundle: { type: String, required: true }

package/dist/runtime/components/Blocks/NotImplemented/index.vue.d.ts

@@ -2,5 +2,6 @@ type __VLS_Props = {
     uuid: string;
     bundle: string;
 };
-declare const _default: 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 __VLS_export: 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: typeof __VLS_export;
 export default _default;

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

@@ -0,0 +1,33 @@
+type __VLS_Props = {
+    /**
+     * The (machine) name of the field that is editable.
+     */
+    name: string;
+    /**
+     * The text value.
+     */
+    value?: string;
+    /**
+     * The tag to use for rendering the wrapper.
+     *
+     * @default "div"
+     */
+    tag?: string;
+};
+type __VLS_Slots = {
+    default(props: {
+        value: string;
+    }): any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    value: string;
+    tag: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+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 (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/BlokkliEditable.vue

@@ -1,5 +1,9 @@
 <template>
-  <component :is="tag" ref="root">
+  <component
+    :is="tag"
+    ref="root"
+    :data-blokkli-editable-field="isEditing ? name : void 0"
+  >
     <slot :value="renderedValue" />
   </component>
 </template>
@@ -19,7 +23,7 @@ import {
   INJECT_ENTITY_CONTEXT,
   INJECT_IS_EDITING,
   INJECT_IS_IN_REUSABLE
-} from "#blokkli/helpers/symbols";
+} from "#blokkli/helpers/injections";
 const props = defineProps({
   name: { type: String, required: true },
   value: { type: String, required: false, default: "" },
@@ -29,7 +33,7 @@ defineSlots();
 const root = useTemplateRef("root");
 const valueOverride = ref("");
 const isEditing = inject(INJECT_IS_EDITING, false);
-const entity = inject(INJECT_ENTITY_CONTEXT);
+const entity = inject(INJECT_ENTITY_CONTEXT, null);
 const editContext = inject(INJECT_EDIT_CONTEXT, null);
 const app = inject(INJECT_APP, null);
 const isInReusable = inject(INJECT_IS_IN_REUSABLE, false);
@@ -45,11 +49,15 @@ const onEditableUpdateValue = (e) => {
     valueOverride.value = e.value;
   }
 };
+function onStateReloaded() {
+  valueOverride.value = "";
+}
 onMounted(() => {
   if (!isEditing || !editContext || !app || isInReusable) {
     return;
   }
   editContext.eventBus.on("editable:update", onEditableUpdateValue);
+  editContext.eventBus.on("state:reloaded", onStateReloaded);
   if (root.value instanceof HTMLElement && entity) {
     app.directive.registerDirectiveElement(
       root.value,
@@ -64,6 +72,7 @@ onMounted(() => {
 onBeforeUnmount(() => {
   if (editContext) {
     editContext.eventBus.off("editable:update", onEditableUpdateValue);
+    editContext.eventBus.off("state:reloaded", onStateReloaded);
   }
   if (app && root.value instanceof HTMLElement && entity) {
     app.directive.unregisterDirectiveElement(

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

@@ -19,11 +19,12 @@ type __VLS_Slots = {
         value: string;
     }): any;
 };
-declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
     value: string;
     tag: 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/BlokkliField.d.vue.ts

@@ -0,0 +1,96 @@
+import type { BlokkliFragmentName } from '#blokkli-build/definitions';
+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.
+     */
+    name: string;
+    /**
+     * The field list items. Can be an array or a single item, also allows nullable values in an array.
+     */
+    list?: Array<FieldListItem | null | undefined> | FieldListItem | null;
+    /**
+     * The tag to use for rendering the root element.
+     */
+    tag?: string;
+    /**
+     * The field list types. The available types can be defined in the "fieldListTypes" module option.
+     */
+    fieldListType?: ValidFieldListTypes;
+    /**
+     * If true, the field list items are only rendered in edit mode.
+     * In normal mode, you are responsible yourself to render the items.
+     */
+    editOnly?: boolean;
+    /**
+     * The classes to render for the list. Same as passing classes via the :class prop.
+     */
+    listClass?: VueClassProp;
+    /**
+     * Classes only applied during editing.
+     */
+    editClass?: VueClassProp;
+    /**
+     * Classes to apply if the field is not empty.
+     */
+    nonEmptyClass?: string;
+    /**
+     * Define which fragments are allowed in this field.
+     *
+     * Note that this is only used during editing. It defines which fragments
+     * can be added here. If you change this prop but there are existing
+     * fragments already in the field list, they will continue to be rendered.
+     *
+     * Note that in addition, also the "blokkli_fragment" block must be allowed
+     * as a bundle in this field.
+     */
+    allowedFragments?: BlokkliFragmentName[] | BlokkliFragmentName;
+    /**
+     * Force an alignment during drag and drop interactions.
+     */
+    dropAlignment?: FieldDropAlignment;
+    /**
+     * Renders proxy blocks during editing.
+     *
+     * Doing this will *not* render the actual block components.
+     *
+     * During editing, a separate element is rendered with "position: absolute"
+     * that contains "proxy blocks" for drag and drop interactions. This means
+     * that you need to have a wrapper somewhere with "position: relative".
+     */
+    proxyMode?: boolean;
+    /**
+     * Determine whether an item should be rendered.
+     */
+    shouldRenderItem?: (item: FieldListItem | FieldListItemTyped) => boolean;
+};
+type __VLS_Slots = {
+    default(props: {
+        items: FieldListItemTyped[];
+    }): any;
+    after(props: {
+        items: FieldListItemTyped[];
+    }): any;
+};
+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;
+    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 __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 (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/BlokkliField.vue

@@ -50,13 +50,7 @@
 </template>
 
 <script setup>
-import {
-  computed,
-  useAttrs,
-  inject,
-  provide,
-  ref
-} from "#imports";
+import { computed, useAttrs, inject, provide, ref } from "#imports";
 import { isVisibleByOptions } from "#blokkli/helpers/runtimeHelpers";
 import BlokkliItem from "./BlokkliItem.vue";
 import {
@@ -76,7 +70,7 @@ import {
   INJECT_FIELD_PROXY_MODE,
   INJECT_GLOBAL_PROXY_MODE,
   INJECT_FIELD_USES_PROXY
-} from "../helpers/symbols";
+} from "../helpers/injections";
 if (import.meta.hot) {
   import.meta.hot.accept("#blokkli/helpers/runtimeHelpers", () => {
   });
@@ -95,36 +89,25 @@ const props = defineProps({
   proxyMode: { type: Boolean, required: false },
   shouldRenderItem: { type: Function, required: false, default: void 0 }
 });
-const DraggableList = inject(
-  INJECT_EDIT_FIELD_LIST_COMPONENT,
-  null
-);
+const DraggableList = inject(INJECT_EDIT_FIELD_LIST_COMPONENT, null);
 const attrs = useAttrs();
 defineOptions({
   inheritAttrs: false
 });
 defineSlots();
 const isEditing = inject(INJECT_IS_EDITING, false);
-const isGlobalProxyMode = inject(
-  INJECT_GLOBAL_PROXY_MODE,
-  null
-);
+const isGlobalProxyMode = inject(INJECT_GLOBAL_PROXY_MODE, null);
 const isInReusable = inject(INJECT_IS_IN_REUSABLE, false);
 const isPreview = inject(INJECT_IS_PREVIEW, null);
 const isNested = inject(INJECT_IS_NESTED, false);
 const nestingLevel = inject(INJECT_NESTING_LEVEL, 0);
-const mutatedFields = inject(
-  INJECT_MUTATED_FIELDS_MAP,
-  null
-);
+const mutatedFields = inject(INJECT_MUTATED_FIELDS_MAP, null);
 const editContext = inject(INJECT_EDIT_CONTEXT, null);
 const entity = inject(INJECT_ENTITY_CONTEXT);
 if (!entity) {
   throw new Error("Missing entity context.");
 }
-const providerEntity = inject(
-  INJECT_PROVIDER_CONTEXT
-);
+const providerEntity = inject(INJECT_PROVIDER_CONTEXT);
 if (!providerEntity) {
   throw new Error(
     "Missing bl\xF6kkli injection: " + INJECT_PROVIDER_CONTEXT.toString()