@blokkli/editor 2.0.0-alpha.52 → 2.0.0-alpha.53

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

@@ -6,6 +6,9 @@ fragment pbAgentConversation on ParagraphsBlokkliAgentConversation {
   hash
   createdAt: created
   updatedAt: changed
+  feedback {
+    itemId
+  }
 }
 
 mutation paragraphsBlokkliAgentToken {
@@ -42,6 +45,23 @@ mutation pbAgentConversationDelete($uuid: String!) {
   }
 }
 
+mutation pbAgentConversationFeedback(
+  $uuid: String!
+  $itemId: String!
+  $rating: ParagraphsBlokkliAgentFeedbackRating!
+  $explanation: String
+) {
+  result: paragraphsBlokkliAgentConversationFeedback(
+    uuid: $uuid
+    itemId: $itemId
+    rating: $rating
+    explanation: $explanation
+  ) {
+    success
+    errors
+  }
+}
+
 query pbAgentConversations($hostEntityType: String!, $hostEntityUuid: String!) {
   conversations: paragraphsBlokkliAgentConversations(
     hostEntityType: $hostEntityType

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

@@ -45,7 +45,21 @@ query pbSearchEditStates($page: Int) {
       hostEntityUuid
       hostEntityType
       label
+      url(rel: "blokkli-editing") {
+        path
+      }
       currentUserIsOwner
+      mutations: mutationsRawField {
+        count
+      }
+      uid {
+        name
+      }
+      changedRawField {
+        first {
+          formatted(format: "c")
+        }
+      }
       entity {
         label
         status

package/dist/modules/drupal/graphql/features/referenced-entities.graphql

@@ -0,0 +1,21 @@
+query pbReferencedEntities(
+  $entityType: EntityType!
+  $entityUuid: String!
+  $langcode: String!
+  $uuids: [String!]
+) {
+  state: getParagraphsEditState(
+    entityType: $entityType
+    entityUuid: $entityUuid
+    langcode: $langcode
+  ) {
+    referencedEntities(langcode: $langcode, uuids: $uuids) {
+      editUrl
+      entityBundle
+      entityType
+      entityUuid
+      label
+      uuids
+    }
+  }
+}

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

@@ -0,0 +1,20 @@
+query pbTextFieldValues(
+  $entityType: EntityType!
+  $entityUuid: String!
+  $langcode: String!
+) {
+  state: getParagraphsEditState(
+    entityType: $entityType
+    entityUuid: $entityUuid
+    langcode: $langcode
+  ) {
+    textFieldValues(langcode: $langcode) {
+      uuid
+      fieldName
+      value
+      fieldType
+      entityType
+      entityBundle
+    }
+  }
+}

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

@@ -0,0 +1,23 @@
+query pbEntitiesSearch {
+  paragraphsBlokkliEntitiesSearch {
+    items {
+      id
+      uuid
+      entityType
+      bundle
+      label
+      url
+      lastChanged
+      uid
+      context
+    }
+    bundleLabels {
+      id
+      label
+    }
+    entityTypeLabels {
+      id
+      label
+    }
+  }
+}

package/dist/modules/drupal/graphql/mutations/bulk_translate_field_values.graphql

@@ -0,0 +1,19 @@
+mutation pbBulkTranslateFieldValues(
+  $entityType: EntityType!
+  $entityUuid: String!
+  $langcode: String!
+  $items: [ParagraphsBlokkliBulkTranslateFieldValuesInput]!
+  $clearOutdated: Boolean
+) {
+  state: paragraphsEditMutationState(
+    entityType: $entityType
+    entityUuid: $entityUuid
+  ) {
+    action: bulk_translate_field_values(
+      items: $items
+      clearOutdated: $clearOutdated
+    ) {
+      ...paragraphsBlokkliMutationResult
+    }
+  }
+}

package/dist/modules/drupal/graphql/mutations/clear_outdated_translation.graphql

@@ -0,0 +1,15 @@
+mutation pbClearOutdatedTranslation(
+  $entityType: EntityType!
+  $entityUuid: String!
+  $langcode: String!
+  $uuids: [String!]!
+) {
+  state: paragraphsEditMutationState(
+    entityType: $entityType
+    entityUuid: $entityUuid
+  ) {
+    action: clear_outdated_translation(uuids: $uuids, langcode: $langcode) {
+      ...paragraphsBlokkliMutationResult
+    }
+  }
+}

package/dist/modules/drupal/graphql/mutations/ignore_analyze.graphql

@@ -0,0 +1,15 @@
+mutation pbIgnoreAnalyze(
+  $entityType: EntityType!
+  $entityUuid: String!
+  $langcode: String
+  $ids: [String]!
+) {
+  state: paragraphsEditMutationState(
+    entityType: $entityType
+    entityUuid: $entityUuid
+  ) {
+    action: ignore_analyze(ids: $ids) {
+      ...paragraphsBlokkliMutationResult
+    }
+  }
+}

package/dist/modules/drupal/graphql/mutations/request_translation.graphql

@@ -0,0 +1,10 @@
+mutation pbRequestTranslation($items: [ParagraphsBlokkliTranslationInput!]!) {
+  result: paragraphsBlokkliRequestTranslation(items: $items) {
+    success
+    errors
+    items {
+      key
+      text
+    }
+  }
+}

package/dist/modules/drupal/graphql/mutations/unignore_analyze.graphql

@@ -0,0 +1,15 @@
+mutation pbUnignoreAnalyze(
+  $entityType: EntityType!
+  $entityUuid: String!
+  $langcode: String
+  $ids: [String]!
+) {
+  state: paragraphsEditMutationState(
+    entityType: $entityType
+    entityUuid: $entityUuid
+  ) {
+    action: unignore_analyze(ids: $ids) {
+      ...paragraphsBlokkliMutationResult
+    }
+  }
+}

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

@@ -1,4 +1,4 @@
-import { B as BlokkliModule } from '../../shared/editor.DsGJIlGn.mjs';
+import { B as BlokkliModule } from '../../shared/editor.BTOBvmaz.mjs';
 import 'nuxt/schema';
 import 'consola';
 import '../../../dist/global/types/definitions.js';

package/dist/modules/drupal/index.mjs

@@ -149,6 +149,16 @@ export declare const templateEditRouteName: string|null
     addMutation("add_multiple");
     addMutation("replace_entity_reference");
     addMutation("bulk_update_field_values");
+    addMutation("clear_outdated_translation");
+    addMutation("bulk_translate_field_values");
+    if (mutationFields.has("paragraphsBlokkliRequestTranslation")) {
+      addGraphqlDocument("mutations/request_translation.graphql");
+    }
+    if (editStateFields.has("textFieldValues")) {
+      addGraphqlDocument("features/textFieldValues.graphql");
+    }
+    addMutation("ignore_analyze");
+    addMutation("unignore_analyze");
     if (graphql.schemaHasType("CommentBlokkliNode")) {
       addGraphqlDocument("features/comments.graphql");
     } else {
@@ -197,6 +207,12 @@ export declare const templateEditRouteName: string|null
     } else {
       context.features.disableFeature("media-library");
     }
+    if (queryFields.has("paragraphsBlokkliEntitiesSearch")) {
+      addGraphqlDocument("features/workspace.graphql");
+    }
+    if (editStateFields.has("referencedEntities")) {
+      addGraphqlDocument("features/referenced-entities.graphql");
+    }
     if (editStateFields.has("previewUrl")) {
       addGraphqlDocument("features/preview-grant.graphql");
     } else {

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

@@ -163,9 +163,17 @@ export default defineBlokkliEditAdapter(
             return acc;
           },
           {}
-        )
+        ),
+        entityTypeConfig: v.data.entityTypeConfig
       };
     });
+    const entityTypeConfigMap = /* @__PURE__ */ new Map();
+    config.entityTypeConfig.forEach((entityType) => {
+      entityTypeConfigMap.set(entityType.id, entityType.label);
+      entityType.bundles.forEach((bundle) => {
+        entityTypeConfigMap.set(`${entityType.id}:${bundle.id}`, bundle.label);
+      });
+    });
     const entityConfig = await useGraphqlQuery("pbEntityConfig", {
       entityType: providedContext.value.entityType,
       entityUuid: providedContext.value.entityUuid
@@ -233,6 +241,7 @@ export default defineBlokkliEditAdapter(
         mutations,
         currentUserIsOwner,
         ownerName,
+        ownerId: state.user?.id,
         mutatedState: {
           fields,
           violations,
@@ -243,7 +252,16 @@ export default defineBlokkliEditAdapter(
         publishOptions,
         entity,
         mutatedEntity: state.mutatedEntity,
-        translationState
+        translationState,
+        textFieldValues: (state.textFieldValues || []).map((v) => ({
+          uuid: v.uuid,
+          fieldName: v.fieldName,
+          value: v.value,
+          fieldType: v.fieldType,
+          entityType: v.entityType,
+          entityBundle: v.entityBundle
+        })),
+        ignoredAnalyzeIdentifiers: state.stateSettings?.ignoredAnalyzeIdentifiers || []
       };
     };
     const addNewBlock = (e) => useGraphqlMutation("pbAddParagraph", {
@@ -394,7 +412,27 @@ export default defineBlokkliEditAdapter(
       mapState,
       moveBlock,
       moveMultipleBlocks,
-      buildAnchorLink
+      buildAnchorLink,
+      getEntityTypeInfo(id) {
+        const label = entityTypeConfigMap.get(id);
+        if (label) {
+          return {
+            id,
+            label
+          };
+        }
+        return null;
+      },
+      getEntityBundleInfo(entityTypeId, bundle) {
+        const label = entityTypeConfigMap.get(`${entityTypeId}:${bundle}`);
+        if (label) {
+          return {
+            id: bundle,
+            label
+          };
+        }
+        return null;
+      }
     };
     if (hasQuery("pbPublishOptions")) {
       adapter.getPublishOptions = () => useGraphqlQuery("pbPublishOptions", ctx.value).then((v) => {
@@ -535,6 +573,58 @@ export default defineBlokkliEditAdapter(
         uuids
       }).then(mapMutation);
     }
+    if (hasMutation("pbClearOutdatedTranslation")) {
+      adapter.markTranslationUpToDate = (uuids, langcode) => useGraphqlMutation("pbClearOutdatedTranslation", {
+        ...ctx.value,
+        uuids,
+        langcode
+      }).then(mapMutation);
+    }
+    if (hasMutation("pbBulkTranslateFieldValues")) {
+      adapter.importTranslationsBatched = ({ items, markUpToDate }) => useGraphqlMutation("pbBulkTranslateFieldValues", {
+        ...ctx.value,
+        clearOutdated: !!markUpToDate,
+        items: items.map((item) => ({
+          uuid: item.uuid,
+          name: item.fieldName,
+          value: item.fieldValue,
+          langcode: item.langcode
+        }))
+      }).then(mapMutation);
+    }
+    if (hasQuery("pbTextFieldValues")) {
+      adapter.loadTextFieldValuesForLanguage = (langcode) => useGraphqlQuery("pbTextFieldValues", {
+        ...ctx.value,
+        langcode
+      }).then(
+        (v) => (v.data.state?.textFieldValues || []).map((tfv) => ({
+          uuid: tfv.uuid,
+          fieldName: tfv.fieldName,
+          value: tfv.value,
+          fieldType: tfv.fieldType,
+          entityType: tfv.entityType,
+          entityBundle: tfv.entityBundle
+        }))
+      );
+    }
+    if (hasMutation("pbRequestTranslation")) {
+      adapter.requestTranslation = (items) => useGraphqlMutation("pbRequestTranslation", {
+        items: items.map((item) => ({
+          key: item.key,
+          text: item.text,
+          isMarkup: item.isHtml,
+          sourceLanguage: item.sourceLanguage,
+          targetLanguage: item.targetLanguage
+        }))
+      }).then((v) => ({
+        success: v.data.result?.success ?? false,
+        errors: v.data.result?.errors ?? void 0,
+        data: (v.data.result?.items || []).map((item) => ({
+          key: item.key,
+          translatedText: item.text
+        }))
+      }));
+    }
     if (hasMutation("pbAddReusableParagraph")) {
       adapter.addLibraryItem = (e) => useGraphqlMutation("pbAddReusableParagraph", {
         ...ctx.value,
@@ -603,6 +693,21 @@ export default defineBlokkliEditAdapter(
         uuid
       }).then((v) => mapComments(v.data.action || []));
     }
+    if (hasQuery("pbReferencedEntities")) {
+      adapter.getReferencedEntities = (uuids) => useGraphqlQuery("pbReferencedEntities", {
+        ...ctx.value,
+        uuids
+      }).then(
+        (v) => (v.data.state?.referencedEntities || []).map((entity) => ({
+          editUrl: entity.editUrl,
+          entityBundle: entity.entityBundle,
+          entityType: entity.entityType,
+          entityUuid: entity.entityUuid,
+          label: entity.label ?? "",
+          uuids: entity.uuids || []
+        }))
+      );
+    }
     if (hasQuery("pbLibraryItems")) {
       adapter.getLibraryItems = (data) => {
         return useGraphqlQuery("pbLibraryItems", {
@@ -926,17 +1031,25 @@ export default defineBlokkliEditAdapter(
       }
     };
     if (hasQuery("pbSearchEditStates")) {
-      adapter.getEditStates = (page) => {
-        return useGraphqlQuery("pbSearchEditStates", { page }).then((data) => {
+      adapter.getEditStates = (e) => {
+        return useGraphqlQuery("pbSearchEditStates", {
+          page: e?.page,
+          ...e?.filters
+        }).then((data) => {
           return {
             items: (data.data.pbSearchEditStates?.items || []).map((v) => {
-              if (v && v.uuid && v.hostEntityType && v.hostEntityUuid && v.label) {
+              if (v && v.uuid && v.hostEntityType && v.hostEntityUuid && v.label && v.url?.path) {
                 return {
                   id: v.uuid,
                   hostEntityType: v.hostEntityType,
                   hostEntityUuid: v.hostEntityUuid,
                   label: v.label,
-                  ...v
+                  ownerName: v.uid?.name ?? "",
+                  pendingChanges: v.mutations?.count ?? 0,
+                  lastChanged: v.changedRawField?.first?.formatted ?? "",
+                  url: v.url.path,
+                  entity: v.entity,
+                  currentUserIsOwner: v.currentUserIsOwner
                 };
               }
               return null;
@@ -950,6 +1063,34 @@ export default defineBlokkliEditAdapter(
         });
       };
     }
+    if (hasQuery("pbEntitiesSearch")) {
+      adapter.getHostEntities = () => {
+        return useGraphqlQuery("pbEntitiesSearch").then((data) => {
+          const result = data.data.paragraphsBlokkliEntitiesSearch;
+          const bundles = {};
+          for (const bundle of result?.bundleLabels ?? []) {
+            bundles[bundle.id] = bundle.label;
+          }
+          return {
+            items: (result?.items ?? []).map((v) => ({
+              id: v.id,
+              uuid: v.uuid,
+              entityType: v.entityType,
+              bundle: v.bundle,
+              label: v.label ?? "",
+              url: v.url,
+              lastChanged: v.lastChanged ?? null,
+              uid: v.uid ?? null,
+              context: v.context ?? void 0
+            })),
+            labelMap: {
+              label: result?.entityTypeLabels?.[0]?.label ?? "",
+              bundles
+            }
+          };
+        });
+      };
+    }
     if (hasQuery("pbSearchTemplates")) {
       adapter.templatesSearch = (e) => {
         return useGraphqlQuery("pbSearchTemplates", {
@@ -1158,10 +1299,22 @@ export default defineBlokkliEditAdapter(
         load: (uuid) => useGraphqlQuery("pbAgentConversation", {
           ...hostParams(),
           uuid
-        }).then((v) => v.data.conversation ?? null),
-        loadLatest: () => useGraphqlQuery("pbAgentConversation", hostParams()).then(
-          (v) => v.data.conversation ?? null
-        ),
+        }).then((v) => {
+          const c = v.data.conversation;
+          if (!c) return null;
+          return {
+            ...c,
+            feedbackItemIds: c.feedback.map((f) => f.itemId)
+          };
+        }),
+        loadLatest: () => useGraphqlQuery("pbAgentConversation", hostParams()).then((v) => {
+          const c = v.data.conversation;
+          if (!c) return null;
+          return {
+            ...c,
+            feedbackItemIds: c.feedback.map((f) => f.itemId)
+          };
+        }),
         list: () => useGraphqlQuery("pbAgentConversations", hostParams()).then(
           (v) => v.data.conversations
         ),
@@ -1169,6 +1322,14 @@ export default defineBlokkliEditAdapter(
           (v) => v.data.result.success
         )
       };
+      if (hasMutation("pbAgentConversationFeedback")) {
+        adapter.submitConversationFeedback = (feedback) => useGraphqlMutation("pbAgentConversationFeedback", {
+          uuid: feedback.conversationId,
+          itemId: feedback.lastItemId,
+          rating: feedback.rating,
+          explanation: feedback.comment
+        }).then((v) => v.data.result.success);
+      }
     }
     if (hasMutation("pbBulkUpdateFieldValues")) {
       adapter.updateFieldValueBatched = (data) => {
@@ -1202,6 +1363,14 @@ export default defineBlokkliEditAdapter(
         }).then(mapMutation);
       };
     }
+    adapter.ignoreAnalyzeIdentifiers = (identifiers) => useGraphqlMutation("pbIgnoreAnalyze", {
+      ...ctx.value,
+      ids: identifiers
+    }).then(mapMutation);
+    adapter.unignoreAnalyzeIdentifiers = (identifiers) => useGraphqlMutation("pbUnignoreAnalyze", {
+      ...ctx.value,
+      ids: identifiers
+    }).then(mapMutation);
     return adapter;
   }
 );

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

@@ -0,0 +1,31 @@
+import { B as BlokkliModule } from '../../shared/editor.BTOBvmaz.mjs';
+import 'nuxt/schema';
+import 'consola';
+import '../../../dist/global/types/definitions.js';
+import '../../../dist/global/types/theme.js';
+import '@nuxt/kit';
+import '../../../dist/global/types/features.js';
+
+type IframeViewport = {
+    /**
+     * The human-readable label for this viewport preset.
+     */
+    label: string;
+    /**
+     * The container width in pixels.
+     */
+    width: number;
+};
+type IframesModuleOptions = {
+    /**
+     * Viewport presets keyed by identifier.
+     *
+     * Keys are used internally, values define the label and container width
+     * shown in the iframe heights editor.
+     */
+    viewports: Record<string, IframeViewport>;
+};
+
+declare const _default: (options: IframesModuleOptions) => BlokkliModule<IframesModuleOptions>;
+
+export { _default as default };

package/dist/modules/iframes/index.mjs

@@ -0,0 +1,52 @@
+import { createResolver } from '@nuxt/kit';
+import { defineBlokkliModule } from '../index.mjs';
+import { fileURLToPath } from 'node:url';
+import { d as defineCodeTemplate } from '../../shared/editor.6D5vApr0.mjs';
+
+function iframesConfigTemplate(options) {
+  return defineCodeTemplate(
+    "iframes-config",
+    () => {
+      return `
+export const VIEWPORTS = ${JSON.stringify(options.viewports)}
+`;
+    },
+    () => {
+      return `
+import type { IframeViewport } from '#blokkli/iframes/types'
+
+export const VIEWPORTS: Record<string, IframeViewport>
+`;
+    },
+    {
+      context: "both",
+      write: true
+    }
+  );
+}
+
+const resolve = createResolver(
+  fileURLToPath(new URL("./", import.meta.url))
+).resolve;
+const index = defineBlokkliModule({
+  setup({ context, helper, $t }, options) {
+    context.addTemplate(iframesConfigTemplate(options));
+    helper.addAlias("#blokkli/iframes/types", resolve("./runtime/types"));
+    helper.addAlias(
+      "#blokkli/iframes/components",
+      resolve("./runtime/components")
+    );
+    context.registerComplexOptionType({
+      id: "iframe_heights",
+      typeName: "IframeHeightMap",
+      typePath: resolve("./runtime/types"),
+      editorComponentPath: resolve(
+        "./runtime/features/iframes/Editor/index.vue"
+      ),
+      editTitle: $t("iframesEditTitle", "Edit iframe size"),
+      editorIcon: "bk_mdi_fit_screen"
+    });
+  }
+});
+
+export { index as default };

package/dist/modules/iframes/runtime/components/BlokkliIframe/index.d.vue.ts

@@ -0,0 +1,18 @@
+import type { IframeHeightMap } from '../../types.js';
+type __VLS_Props = {
+    src: string;
+    heights: IframeHeightMap;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: 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: __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/modules/iframes/runtime/components/BlokkliIframe/index.vue

@@ -0,0 +1,61 @@
+<template>
+  <div :data-bk-iframe-id="scopeId" style="container-type: inline-size">
+    <div class="bk-iframe-slot">
+      <slot />
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { computed, inject, onMounted, onBeforeUnmount, watch } from "vue";
+import { useBlokkli, useHead } from "#imports";
+import { INJECT_BLOCK_ITEM } from "#blokkli/helpers/injections";
+const props = defineProps({
+  src: { type: String, required: true },
+  heights: { type: Object, required: true }
+});
+const item = inject(INJECT_BLOCK_ITEM, null);
+const uuid = computed(() => item?.value.uuid || "");
+const scopeId = computed(() => uuid.value || "unknown");
+const app = useBlokkli(true);
+onMounted(() => {
+  if (app && uuid.value) {
+    app.directive.registerValueElement(uuid.value, "iframe", props.src);
+  }
+});
+onBeforeUnmount(() => {
+  if (app && uuid.value) {
+    app.directive.unregisterValueElement(uuid.value, "iframe");
+  }
+});
+watch(
+  () => props.src,
+  (src) => {
+    if (app && uuid.value) {
+      app.directive.registerValueElement(uuid.value, "iframe", src);
+    }
+  }
+);
+const generatedCSS = computed(() => {
+  const entries = Object.entries(props.heights).map(([w, h]) => ({ width: Number(w), height: h })).filter((e) => !Number.isNaN(e.width) && e.height > 0).sort((a, b) => b.width - a.width);
+  if (!entries.length) return "";
+  const sel = `[data-bk-iframe-id="${scopeId.value}"]`;
+  const lines = [];
+  lines.push(`${sel} .bk-iframe-slot { height: ${entries[0].height}px; }`);
+  for (let i = 1; i < entries.length; i++) {
+    const entry = entries[i];
+    lines.push(
+      `@container (max-width: ${entry.width}px) { ${sel} .bk-iframe-slot { height: ${entry.height}px; } }`
+    );
+  }
+  return lines.join("\n");
+});
+useHead({
+  style: [
+    {
+      key: computed(() => `bk-iframe-${scopeId.value}`),
+      innerHTML: generatedCSS
+    }
+  ]
+});
+</script>