@blokkli/editor 2.0.0-alpha.32 → 2.0.0-alpha.34

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

@@ -3,6 +3,7 @@ import {
 } from "#blokkli/editor/adapter";
 import { falsy } from "#blokkli/helpers";
 import { availableFeaturesAtBuild } from "#blokkli-build/features";
+import { templateEditRouteName } from "#blokkli-build/drupal-config";
 import { operationSources } from "#nuxt-graphql-middleware/sources";
 import {
   useGraphqlQuery,
@@ -23,6 +24,29 @@ function mapPublishOptions(publishOptions) {
     revisionLogMessage: publishOptions.revisionLogMessage ?? null
   };
 }
+const PERMISSION_FIELDS = {
+  use_blokkli: "use_blokkli",
+  take_ownership: "take_ownership",
+  manage_default_templates: "manage_default_templates",
+  create_library_item: "create_library_item",
+  edit_library_item: "edit_library_item",
+  create_comments: "create_comments",
+  view_comments: "view_comments",
+  use_agent: "use_agent"
+};
+function mapUserPermissions(user) {
+  return Object.entries(PERMISSION_FIELDS).filter(([, field]) => user[field] === true).map(([permission]) => permission);
+}
+function valueToFilterString(v) {
+  if (typeof v === "string") {
+    return v;
+  } else if (typeof v === "number") {
+    return v.toString();
+  } else if (typeof v === "boolean") {
+    return v ? "1" : "0";
+  }
+  return "";
+}
 function configObjectToUserConfigInput(values) {
   if (!values) {
     return [];
@@ -30,7 +54,7 @@ function configObjectToUserConfigInput(values) {
   return Object.entries(values).map(([name, value]) => {
     return {
       name,
-      value
+      value: valueToFilterString(value)
     };
   });
 }
@@ -111,6 +135,7 @@ export default defineBlokkliEditAdapter(
     }).then((v) => {
       return {
         clipboard: v.data.clipboards || [],
+        userPermissions: v.data.userPermissions,
         availableFeatures: v.data.features,
         allTypes: (v.data.allTypes.items || []).filter(
           (v2) => v2 && "id" in v2
@@ -255,7 +280,14 @@ export default defineBlokkliEditAdapter(
       }
       return Promise.resolve(disabled);
     };
-    const mapMutation = (v) => v.data?.state?.action;
+    const mapMutation = (v) => {
+      const action = v.data?.state?.action;
+      return {
+        success: !!action?.success,
+        state: action?.state,
+        errors: (action?.errors ?? []).filter(falsy)
+      };
+    };
     const route = useRoute();
     const router = useRouter();
     const changeLanguage = (translation) => {
@@ -332,6 +364,10 @@ export default defineBlokkliEditAdapter(
     const adapter = {
       addNewBlock,
       buildEditableFrameUrl,
+      getUserPermissions: function() {
+        const permissions = config.userPermissions ? mapUserPermissions(config.userPermissions) : [];
+        return Promise.resolve(permissions);
+      },
       changeLanguage,
       formFrameBuilder,
       getAllBundles,
@@ -755,15 +791,20 @@ export default defineBlokkliEditAdapter(
     if (hasQuery("pbSearchTabs")) {
       adapter.getContentSearchTabs = () => {
         return useGraphqlQuery("pbSearchTabs").then((v) => {
-          return (v.data.tabs || []).reduce(
-            (acc, tab) => {
-              if (tab?.id) {
-                acc[tab.id] = tab.label;
-              }
-              return acc;
-            },
-            {}
-          );
+          return (v.data.tabs ?? []).map((tab) => {
+            if (!tab) {
+              return null;
+            }
+            return {
+              id: tab.id,
+              title: tab.label,
+              description: tab.description ?? null,
+              types: tab.types.map((t) => ({
+                type: t.entityType,
+                bundles: t.bundles
+              }))
+            };
+          }).filter(falsy);
         });
       };
     }
@@ -893,21 +934,38 @@ export default defineBlokkliEditAdapter(
       adapter.templatesSearch = (e) => {
         return useGraphqlQuery("pbSearchTemplates", {
           filters: configObjectToUserConfigInput(e.filters),
-          page: e.page
+          page: e.page,
+          includeItems: e.includeItems
         }).then((data) => {
           return {
-            filters: mapPluginConfigInputs(
-              data.data.paragraphsBlokkliGetTemplates?.filters ?? []
-            ),
-            items: (data.data.paragraphsBlokkliGetTemplates?.items || []).filter(falsy).map((v) => {
+            filters: mapPluginConfigInputs(data.data.results?.filters ?? []),
+            items: (data.data.results?.items || []).filter(falsy).map((v) => {
+              const permissions = [];
+              if (v.blokkliMetadata.canDelete) {
+                permissions.push("delete");
+              }
+              if (v.blokkliMetadata.canEdit) {
+                permissions.push("edit");
+              }
               return {
-                ...v,
-                // @TODO: get actual permissions.
-                permissions: ["view", "delete", "edit"]
+                uuid: v.uuid,
+                label: v.label ?? "",
+                description: v.description,
+                isDefault: !!v.isDefault,
+                itemBundles: v.templateBundles,
+                items: (v.items ?? []).filter(falsy),
+                permissions,
+                translationLanguages: v.translationLanguages,
+                metadata: {
+                  description: v.description ?? null,
+                  createdBy: v.blokkliMetadata.createdBy ?? null,
+                  dateUpdated: v.blokkliMetadata.dateUpdated ?? null,
+                  dateCreated: v.blokkliMetadata.dateCreated ?? null
+                }
               };
             }),
-            total: data.data.paragraphsBlokkliGetTemplates?.total || 0,
-            perPage: data.data.paragraphsBlokkliGetTemplates?.perPage || 50
+            total: data.data.results?.total || 0,
+            perPage: data.data.results?.perPage || 50
           };
         });
       };
@@ -924,6 +982,19 @@ export default defineBlokkliEditAdapter(
         }).then(mapMutation);
       };
     }
+    if (hasMutation("pbTemplateDelete")) {
+      adapter.templatesDelete = (e) => {
+        return useGraphqlMutation("pbTemplateDelete", {
+          uuid: e.templateUuid
+        }).then((v) => {
+          return {
+            success: !!v.data.action.success,
+            state: v.data.action.state,
+            errors: (v.data.action.errors ?? []).filter(falsy)
+          };
+        });
+      };
+    }
     if (hasMutation("pbCreateTemplate")) {
       adapter.templatesCreate = (e) => {
         return useGraphqlMutation("pbCreateTemplate", {
@@ -935,6 +1006,23 @@ export default defineBlokkliEditAdapter(
         }).then(mapMutation);
       };
     }
+    if (hasQuery("pbGetTemplateEntity") && templateEditRouteName) {
+      try {
+        const href = router.resolve({
+          name: templateEditRouteName,
+          params: {
+            uuid: "UUID_PLACEHOLDER"
+          }
+        }).path;
+        adapter.templatesGetEditUrl = (e) => {
+          return href.replace("UUID_PLACEHOLDER", e.templateUuid) + "?blokkliEditing=" + e.templateUuid;
+        };
+      } catch {
+        console.error(
+          `The provided templateEditRouteName "${templateEditRouteName}" is not valid. Editing templates will not be possible.`
+        );
+      }
+    }
     if (hasMutation("pbUnschedule")) {
       adapter.unscheduleEditState = (options) => useGraphqlMutation("pbUnschedule", {
         entityType: options.hostEntityType.toUpperCase(),
@@ -957,6 +1045,143 @@ export default defineBlokkliEditAdapter(
         items: blocks
       }).then(mapMutation);
     }
+    if (hasMutation("pbSwapParagraphs")) {
+      adapter.swapBlocks = (uuid1, uuid2) => useGraphqlMutation("pbSwapParagraphs", {
+        entityType: ctx.value.entityType,
+        entityUuid: ctx.value.entityUuid,
+        langcode: ctx.value.langcode,
+        uuid1,
+        uuid2
+      }).then(mapMutation);
+    }
+    if (hasMutation("pbReplaceEntityReference")) {
+      adapter.replaceContentSearchItem = (data) => useGraphqlMutation("pbReplaceEntityReference", {
+        entityType: ctx.value.entityType,
+        entityUuid: ctx.value.entityUuid,
+        langcode: ctx.value.langcode,
+        targetType: data.item.entityType,
+        targetBundle: data.item.entityBundle,
+        targetId: data.item.id,
+        uuid: data.host.uuid
+      }).then(mapMutation);
+    }
+    if (hasMutation("pbAddMultipleParagraphs")) {
+      const mapBlockToGraphQL = (block) => {
+        const values = {};
+        for (const entry of block.values ?? []) {
+          const droppableConfig = config.droppableFieldConfig.find(
+            (f) => f.entityBundle === block.bundle && f.name === entry.fieldName
+          );
+          if (droppableConfig) {
+            if (droppableConfig.type === "reference") {
+              if (typeof entry.fieldValue !== "string") {
+                values[entry.fieldName] = {
+                  target_id: entry.fieldValue.entityId
+                };
+              }
+            } else if (droppableConfig.type === "link") {
+              if (typeof entry.fieldValue === "string") {
+                values[entry.fieldName] = entry.fieldValue;
+              } else {
+                values[entry.fieldName] = `entity:${entry.fieldValue.entityType}/${entry.fieldValue.entityId}`;
+              }
+            }
+          } else if (typeof entry.fieldValue === "string") {
+            values[entry.fieldName] = entry.fieldValue;
+          }
+        }
+        return {
+          bundle: block.bundle,
+          uuid: block.blockUuid,
+          values,
+          options: block.options,
+          children: block.children ? Object.entries(block.children).map(
+            ([fieldName, childBlocks]) => ({
+              fieldName,
+              items: childBlocks.map(mapBlockToGraphQL)
+            })
+          ) : void 0
+        };
+      };
+      adapter.addNewBlocks = (data) => useGraphqlMutation("pbAddMultipleParagraphs", {
+        entityType: ctx.value.entityType,
+        entityUuid: ctx.value.entityUuid,
+        langcode: ctx.value.langcode,
+        hostType: data.host.type,
+        hostUuid: data.host.uuid,
+        hostFieldName: data.host.fieldName,
+        afterUuid: data.afterUuid,
+        items: data.blocks.map(mapBlockToGraphQL)
+      }).then(mapMutation);
+    }
+    if (hasMutation("paragraphsBlokkliAgentToken")) {
+      adapter.getAgentAuthToken = function() {
+        return useGraphqlMutation("paragraphsBlokkliAgentToken").then(
+          (v) => v.data.token ?? null
+        );
+      };
+    }
+    if (hasMutation("pbAgentConversationUpsert") && hasMutation("pbAgentConversationDelete") && hasQuery("pbAgentConversations") && hasQuery("pbAgentConversation")) {
+      const hostParams = () => ({
+        hostEntityType: providedContext.value.entityType,
+        hostEntityUuid: providedContext.value.entityUuid
+      });
+      adapter.agentConversations = {
+        upsert: (data) => useGraphqlMutation("pbAgentConversationUpsert", {
+          ...hostParams(),
+          uuid: data.uuid,
+          title: data.title,
+          dataUser: data.clientState,
+          dataServer: data.serverState,
+          hash: data.hash
+        }).then((v) => v.data.result.success),
+        load: (uuid) => useGraphqlQuery("pbAgentConversation", {
+          ...hostParams(),
+          uuid
+        }).then((v) => v.data.conversation ?? null),
+        loadLatest: () => useGraphqlQuery("pbAgentConversation", hostParams()).then(
+          (v) => v.data.conversation ?? null
+        ),
+        list: () => useGraphqlQuery("pbAgentConversations", hostParams()).then(
+          (v) => v.data.conversations
+        ),
+        delete: (uuid) => useGraphqlMutation("pbAgentConversationDelete", { uuid }).then(
+          (v) => v.data.result.success
+        )
+      };
+    }
+    if (hasMutation("pbBulkUpdateFieldValues")) {
+      adapter.updateFieldValueBatched = (data) => {
+        const entityItems = data.entityItems.map((item) => {
+          return {
+            name: item.fieldName,
+            value: item.fieldValue
+          };
+        });
+        const blockItems = data.items.map((item) => {
+          return {
+            uuid: item.uuid,
+            name: item.fieldName,
+            value: item.fieldValue
+          };
+        });
+        return useGraphqlMutation("pbBulkUpdateFieldValues", {
+          ...ctx.value,
+          items: [...entityItems, ...blockItems]
+        }).then(mapMutation);
+      };
+    }
+    if (hasMutation("pbRearrangeParagraphs")) {
+      adapter.rearrangeBlocks = (data) => {
+        return useGraphqlMutation("pbRearrangeParagraphs", {
+          ...ctx.value,
+          hostType: data.host.type,
+          hostFieldName: data.host.fieldName,
+          hostUuid: data.host.uuid,
+          uuids: data.uuids
+        }).then(mapMutation);
+      };
+    }
     return adapter;
   }
 );

package/dist/modules/drupal/runtime/components/BlokkliDrupalEditTemplate/index.d.vue.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    /**
+     * The UUID of the template.
+     */
+    uuid: 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/modules/drupal/runtime/components/BlokkliDrupalEditTemplate/index.vue

@@ -0,0 +1,26 @@
+<template>
+  <BlokkliProvider v-if="entity" v-bind="entity.blokkliProps">
+    <BlokkliField name="paragraphs" :list="entity.items" />
+  </BlokkliProvider>
+</template>
+
+<script setup>
+import { BlokkliProvider, BlokkliField } from "#components";
+import { useGraphqlQuery, useAsyncData } from "#imports";
+const props = defineProps({
+  uuid: { type: String, required: true }
+});
+const { data: entity } = await useAsyncData(
+  "blokkli-drupal-edit-template-" + props.uuid,
+  () => {
+    return useGraphqlQuery("pbGetTemplateEntity", { uuid: props.uuid }).then(
+      (v) => {
+        if (v.data.paragraphsBlokkliTemplateGet) {
+          return v.data.paragraphsBlokkliTemplateGet;
+        }
+        return null;
+      }
+    );
+  }
+);
+</script>

package/dist/modules/drupal/runtime/components/BlokkliDrupalEditTemplate/index.vue.d.ts

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    /**
+     * The UUID of the template.
+     */
+    uuid: 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/Fragment/index.vue

@@ -5,7 +5,10 @@
 <script setup>
 import { getComponent } from "#blokkli/helpers/imports";
 import { provide, defineBlokkli, inject } from "#imports";
-import { INJECT_ALL_COMPONENTS_CHUNK, INJECT_FRAGMENT_CONTEXT } from "#blokkli/helpers/injections";
+import {
+  INJECT_ALL_COMPONENTS_CHUNK,
+  INJECT_FRAGMENT_CONTEXT
+} from "#blokkli/helpers/injections";
 const componentProps = defineProps({
   name: { type: null, required: true }
 });
@@ -17,6 +20,12 @@ const ctx = defineBlokkli({
   }
 });
 const allComponentsChunk = inject(INJECT_ALL_COMPONENTS_CHUNK, null);
-const component = getComponent("fragment", componentProps.name, void 0, void 0, allComponentsChunk);
+const component = getComponent(
+  "fragment",
+  componentProps.name,
+  void 0,
+  void 0,
+  allComponentsChunk
+);
 provide(INJECT_FRAGMENT_CONTEXT, ctx);
 </script>

package/dist/runtime/components/BlokkliItem.vue

@@ -65,7 +65,9 @@ const itemProps = computed(() => {
   }
   return componentProps.props;
 });
-const component = isProxyMode || isGlobalProxyMode?.value ? defineAsyncComponent(() => import("./../editor/components/BlockProxy/index.vue")) : getComponent(
+const component = isProxyMode || isGlobalProxyMode?.value ? defineAsyncComponent(
+  () => import("./../editor/components/BlockProxy/index.vue")
+) : getComponent(
   "block",
   componentProps.bundle,
   fieldListType?.value || "default",

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

@@ -1,7 +1,8 @@
 import { type ComputedRef } from '#imports';
-import type { BlokkliAdapter, AdapterMethods } from '#blokkli/editor/adapter';
+import type { FullBlokkliAdapter, AdapterMethods } from '#blokkli/editor/adapter';
 import type { ValidFeatureKey } from '#blokkli-build/features';
 import type { DebugLogger } from '#blokkli/editor/providers/debug';
+import type { AdaptersProvider } from '#blokkli/editor/providers/adapters';
 import type { FeatureDefinition } from '#blokkli/editor/types/features';
 type SettingType<S> = S extends {
     type: 'checkbox';
@@ -15,9 +16,10 @@ type SettingType<S> = S extends {
 type SettingsTypes<S> = {
     [P in keyof S]: SettingType<S[P]>;
 };
-type RequireAdapterMethods<T extends BlokkliAdapter<any>, Methods extends readonly AdapterMethods[]> = Omit<T, Methods[number]> & Required<Pick<T, Methods[number] & keyof T>>;
+type RequireAdapterMethods<T extends FullBlokkliAdapter<any>, Methods extends readonly AdapterMethods[]> = Omit<T, Methods[number]> & Required<Pick<T, Methods[number] & keyof T>>;
 type DefineBlokkliFeature<F extends FeatureDefinition<any, any>> = {
-    adapter: F['requiredAdapterMethods'] extends readonly (keyof BlokkliAdapter<any>)[] ? RequireAdapterMethods<BlokkliAdapter<any>, F['requiredAdapterMethods']> : BlokkliAdapter<any>;
+    adapter: F['requiredAdapterMethods'] extends readonly AdapterMethods[] ? RequireAdapterMethods<FullBlokkliAdapter<any>, F['requiredAdapterMethods']> : FullBlokkliAdapter<any>;
+    adapters: AdaptersProvider;
     settings: ComputedRef<SettingsTypes<F['settings']>>;
     logger: DebugLogger;
 };

package/dist/runtime/composables/defineBlokkliFeature.js

@@ -8,7 +8,7 @@ import {
 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 { adapter, adapters, storage, features, debug } = useBlokkli();
   const logger = debug.createLogger(feature.label || feature.id);
   const storageKey = computed(() => `feature:${feature.id}:settings`);
   const defaults = Object.entries(feature.settings || {}).reduce((acc, [key, config]) => {
@@ -56,6 +56,7 @@ export function defineBlokkliFeature(feature) {
   provide(INJECT_EDIT_LOGGER, logger);
   return {
     adapter,
+    adapters,
     settings,
     logger
   };

package/dist/runtime/editor/adapter/index.d.ts

@@ -1,12 +1,13 @@
 import type { ComputedRef } from 'vue';
-import type { AddNewBlockEvent, MoveBlockEvent, MoveMultipleBlocksEvent } from '../events/index.js';
+import type { AddNewBlockEvent, AddNewBlocksEvent, MoveBlockEvent, MoveMultipleBlocksEvent } from '../events/index.js';
 import type { PluginConfigInput } from '../types/pluginConfig.js';
 import type { EntityTranslation, MappedState } from '../types/state.js';
 import type { BlockBundleDefinition, FieldConfig } from '../types/definitions.js';
 import type { EditBlockEvent } from '../features/edit/types.js';
+import type { UserPermissions } from '../types/permissions.js';
 export interface MutationResponseLike<T> {
     success: boolean;
-    state: T;
+    state?: T;
     errors?: string[];
 }
 export type UpdateEntityFieldValueEvent = {
@@ -66,6 +67,7 @@ export interface BlokkliAdapter<T> {
      */
     loadStateAtIndex?: (index: number) => Promise<T | undefined>;
     mapState(state: T): MappedState;
+    getUserPermissions: () => Promise<UserPermissions[]>;
     /**
      * Get disabled features at runtime.
      *
@@ -88,6 +90,10 @@ export interface BlokkliAdapter<T> {
      * Add a new block.
      */
     addNewBlock(e: AddNewBlockEvent): Promise<MutationResponseLike<T>>;
+    /**
+     * Add multiple new blocks at once.
+     */
+    addNewBlocks?(e: AddNewBlocksEvent): Promise<MutationResponseLike<T>>;
     /**
      * Move an item.
      */
@@ -115,7 +121,42 @@ export interface BlokkliAdapter<T> {
         persist: (settings: string) => Promise<undefined>;
     };
 }
-export type BlokkliAdapterFactory<T> = (ctx: ComputedRef<AdapterContext>) => Promise<BlokkliAdapter<T>> | BlokkliAdapter<T>;
-export type AdapterMethods = keyof BlokkliAdapter<any>;
+/**
+ * Methods that adapter extensions can implement.
+ * Features augment this interface via module augmentation to add extensible methods.
+ * These methods can be implemented by both the base adapter AND extensions.
+ */
+export interface AdapterExtensionMethods<T> {
+}
+/**
+ * The full adapter type combining core methods with extensible methods.
+ */
+export type FullBlokkliAdapter<T> = BlokkliAdapter<T> & Partial<AdapterExtensionMethods<T>>;
+export type BlokkliAdapterFactory<T> = (ctx: ComputedRef<AdapterContext>) => Promise<FullBlokkliAdapter<T>> | FullBlokkliAdapter<T>;
+export type AdapterMethods = keyof BlokkliAdapter<any> | keyof AdapterExtensionMethods<any>;
 export declare function defineBlokkliEditAdapter<T>(cb: BlokkliAdapterFactory<T>): BlokkliAdapterFactory<T>;
+/**
+ * An adapter extension (with namespace assigned by build system).
+ */
+export interface BlokkliAdapterExtension<T = any> {
+    /**
+     * Unique namespace (e.g., '@my-org/ai').
+     * Assigned by the build system from registerAdapterExtension().
+     */
+    namespace: string;
+    /**
+     * Extension methods.
+     */
+    methods: Partial<AdapterExtensionMethods<T>>;
+}
+/**
+ * Factory type for extension files.
+ * Just returns methods - namespace is assigned externally.
+ */
+export type BlokkliAdapterExtensionFactory<T> = (ctx: ComputedRef<AdapterContext>) => Promise<Partial<AdapterExtensionMethods<T>>> | Partial<AdapterExtensionMethods<T>>;
+/**
+ * Define an adapter extension.
+ * The namespace is NOT specified here - it's assigned via registerAdapterExtension().
+ */
+export declare function defineBlokkliAdapterExtension<T>(factory: BlokkliAdapterExtensionFactory<T>): BlokkliAdapterExtensionFactory<T>;
 export {};

package/dist/runtime/editor/adapter/index.js

@@ -1,3 +1,6 @@
 export function defineBlokkliEditAdapter(cb) {
   return cb;
 }
+export function defineBlokkliAdapterExtension(factory) {
+  return factory;
+}

package/dist/runtime/editor/components/Actions/ItemDropdown.vue

@@ -3,11 +3,16 @@
     id="bk-blokkli-item-actions-dropdown"
     class="bk-blokkli-item-actions-type-dropdown"
   >
-    <div v-for="group in groups" :key="group.name">
+    <div
+      v-for="group in groups"
+      :key="group.name"
+      :class="'bk-is-' + group.name"
+    >
       <ol>
         <li v-for="action in group.actions" :key="action.id">
           <button
             class="bk-blokkli-item-actions-type-dropdown-button"
+            :class="'bk-is-variant-' + action.variant || 'default'"
             :disabled="action.enabled === false"
             @click.prevent="onActionClick(action)"
           >

package/dist/runtime/editor/components/Actions/index.vue

@@ -87,7 +87,10 @@ import { falsy } from "#blokkli/helpers";
 import { Icon, ItemIconBox } from "#blokkli/editor/components";
 import EditActionsItemDropdown from "./ItemDropdown.vue";
 import { onBlokkliEvent, useStickyToolbar } from "#blokkli/editor/composables";
-import { fragmentBlockBundle, fromLibraryBlockBundle } from "#blokkli-build/config";
+import {
+  fragmentBlockBundle,
+  fromLibraryBlockBundle
+} from "#blokkli-build/config";
 const { selection, $t, types, state, ui, definitions, debug } = useBlokkli();
 const editingEnabled = computed(
   () => state.editMode.value === "editing" || state.editMode.value === "translating"

package/dist/runtime/editor/components/AddListItem/index.d.vue.ts

@@ -10,10 +10,18 @@ export type AddListItemProps = {
     disabled?: boolean;
     isAutoAdd?: boolean;
     noContextMenu?: boolean;
+    useHelp?: boolean;
+    helpActive?: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<AddListItemProps, {
     getElement: () => HTMLElement | null;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AddListItemProps> & Readonly<{}>, {
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    help: (d: HTMLElement) => void;
+    startHelp: (d: HTMLElement) => void;
+}, string, import("vue").PublicProps, Readonly<AddListItemProps> & Readonly<{
+    onHelp?: ((d: HTMLElement) => any) | undefined;
+    onStartHelp?: ((d: HTMLElement) => any) | undefined;
+}>, {
     bundle: string;
     description: string;
     icon: BlokkliIcon;