@blokkli/editor 2.0.0-alpha.54 → 2.0.0-alpha.56

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

@@ -0,0 +1,21 @@
+mutation pbUpdateDroppableField(
+  $langcode: String
+  $entityType: EntityType!
+  $entityUuid: String!
+  $paragraphUuid: String
+  $fieldName: String!
+  $itemIds: [String]!
+) {
+  state: paragraphsEditMutationState(
+    entityType: $entityType
+    entityUuid: $entityUuid
+  ) {
+    action: update_droppable_field(
+      paragraphUuid: $paragraphUuid
+      fieldName: $fieldName
+      itemIds: $itemIds
+    ) {
+      ...paragraphsBlokkliMutationResult
+    }
+  }
+}

package/dist/modules/drupal/index.mjs

@@ -148,6 +148,7 @@ export declare const templateEditRouteName: string|null
     addMutation("update_host_options");
     addMutation("add_multiple");
     addMutation("replace_entity_reference");
+    addMutation("update_droppable_field");
     addMutation("bulk_update_field_values");
     addMutation("clear_outdated_translation");
     addMutation("bulk_translate_field_values");
@@ -197,7 +198,7 @@ export declare const templateEditRouteName: string|null
     } else {
       context.features.disableFeature("conversions");
     }
-    if (queryFields.has("pbGetImportSourceEntities")) {
+    if (editMutationStateFields.has("copy_from_existing")) {
       addGraphqlDocument("features/import-existing.graphql");
     } else {
       context.features.disableFeature("import-existing");
@@ -207,12 +208,15 @@ export declare const templateEditRouteName: string|null
     } else {
       context.features.disableFeature("media-library");
     }
-    if (queryFields.has("paragraphsBlokkliEntitiesSearch")) {
+    if (queryFields.has("paragraphsBlokkliEntitiesSearch") && queryFields.has("paragraphsBlokkliEditStatesSummary")) {
       addGraphqlDocument("features/workspace.graphql");
     }
     if (editStateFields.has("referencedEntities")) {
       addGraphqlDocument("features/referenced-entities.graphql");
     }
+    if (editStateFields.has("droppableFieldItems")) {
+      addGraphqlDocument("features/droppable-field-items.graphql");
+    }
     if (editStateFields.has("previewUrl")) {
       addGraphqlDocument("features/preview-grant.graphql");
     } else {

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

@@ -261,6 +261,13 @@ export default defineBlokkliEditAdapter(
           entityType: v.entityType,
           entityBundle: v.entityBundle
         })),
+        droppableFieldValues: (state.droppableFieldValues || []).map((v) => ({
+          uuid: v.uuid,
+          fieldName: v.fieldName,
+          ids: v.ids,
+          entityType: v.entityType,
+          entityBundle: v.entityBundle
+        })),
         ignoredAnalyzeIdentifiers: state.stateSettings?.ignoredAnalyzeIdentifiers || []
       };
     };
@@ -443,31 +450,6 @@ export default defineBlokkliEditAdapter(
         return mapPublishOptions(options);
       });
     }
-    if (hasQuery("pbGetImportSourceEntities")) {
-      adapter.getImportItems = (args) => useGraphqlQuery("pbGetImportSourceEntities", {
-        entityType: ctx.value.entityType.toLowerCase(),
-        entityUuid: ctx.value.entityUuid,
-        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,
-                description: item.description
-              };
-            }
-          }).filter(falsy)
-        };
-      });
-    }
     if (hasQuery("pbConversions")) {
       adapter.getConversions = () => useGraphqlQuery("pbConversions").then(
         (v) => v?.data.paragraphsBlokkliConversions || []
@@ -850,6 +832,30 @@ export default defineBlokkliEditAdapter(
         mediaId: e.mediaId
       }).then(mapMutation);
     }
+    if (hasMutation("pbUpdateDroppableField")) {
+      adapter.updateDroppableField = (e) => useGraphqlMutation("pbUpdateDroppableField", {
+        ...ctx.value,
+        paragraphUuid: e.host.uuid === ctx.value.entityUuid ? null : e.host.uuid,
+        fieldName: e.host.fieldName,
+        itemIds: e.itemIds
+      }).then(mapMutation);
+    }
+    if (hasQuery("pbDroppableFieldItems")) {
+      adapter.getDroppableFieldItems = (e) => useGraphqlQuery("pbDroppableFieldItems", {
+        ...ctx.value,
+        paragraphUuid: e.host.uuid === ctx.value.entityUuid ? null : e.host.uuid,
+        fieldName: e.host.fieldName
+      }).then(
+        (v) => (v.data.state?.droppableFieldItems || []).map((item) => ({
+          id: item.id,
+          entityType: item.entityType,
+          bundle: item.bundle,
+          label: item.label,
+          thumbnailSrc: item.thumbnailSrc ?? void 0,
+          targetBundles: item.targetBundles
+        }))
+      );
+    }
     if (hasMutation("pbUpdateHostEntityFieldValue")) {
       adapter.updateEntityFieldValue = (e) => useGraphqlMutation("pbUpdateHostEntityFieldValue", {
         ...ctx.value,
@@ -890,6 +896,19 @@ export default defineBlokkliEditAdapter(
           afterUuid: e.preceedingUuid
         }).then(mapMutation);
       };
+      adapter.addEntityReferenceBlock = (e) => {
+        return useGraphqlMutation("pbAddEntityReference", {
+          ...ctx.value,
+          targetId: e.entityId,
+          targetType: e.entityType,
+          targetBundle: e.entityBundle,
+          paragraphBundle: e.bundle,
+          hostType: e.host.type,
+          hostUuid: e.host.uuid,
+          hostFieldName: e.host.fieldName,
+          afterUuid: e.afterUuid
+        }).then(mapMutation);
+      };
     }
     if (hasMutation("pbAddEntityReferenceMultiple")) {
       adapter.mediaLibraryAddBlocks = (e) => {
@@ -1063,26 +1082,43 @@ export default defineBlokkliEditAdapter(
         });
       };
     }
-    if (hasQuery("pbEntitiesSearch")) {
+    if (hasQuery("pbEntitiesSearch") && hasQuery("pbEditStatesSummary")) {
       adapter.getHostEntities = () => {
-        return useGraphqlQuery("pbEntitiesSearch").then((data) => {
-          const result = data.data.paragraphsBlokkliEntitiesSearch;
+        return Promise.all([
+          useGraphqlQuery("pbEntitiesSearch"),
+          useGraphqlQuery("pbEditStatesSummary")
+        ]).then(([entitiesData, statesData]) => {
+          const result = entitiesData.data.paragraphsBlokkliEntitiesSearch;
+          const summaries = statesData.data.paragraphsBlokkliEditStatesSummary ?? [];
+          const stateMap = /* @__PURE__ */ new Map();
+          for (const summary of summaries) {
+            stateMap.set(
+              `${summary.hostEntityType}:${summary.hostEntityUuid}`,
+              {
+                lastChanged: summary.lastChanged,
+                uid: summary.uid ?? null
+              }
+            );
+          }
           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
-            })),
+            items: (result?.items ?? []).map((v) => {
+              const state = stateMap.get(`${v.entityType}:${v.uuid}`);
+              return {
+                id: v.id,
+                uuid: v.uuid,
+                entityType: v.entityType,
+                bundle: v.bundle,
+                label: v.label ?? "",
+                url: v.url,
+                lastChanged: state?.lastChanged ?? null,
+                uid: state?.uid ?? null,
+                context: v.context ?? void 0
+              };
+            }),
             labelMap: {
               label: result?.entityTypeLabels?.[0]?.label ?? "",
               bundles

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

@@ -0,0 +1,11 @@
+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';
+
+declare const _default: (options?: object) => BlokkliModule<object>;
+
+export { _default as default };

package/dist/modules/readability/index.mjs

@@ -0,0 +1,17 @@
+import { createResolver } from '@nuxt/kit';
+import { defineBlokkliModule } from '../index.mjs';
+import { fileURLToPath } from 'node:url';
+
+const resolve = createResolver(
+  fileURLToPath(new URL("./", import.meta.url))
+).resolve;
+const index = defineBlokkliModule({
+  setup({ context }) {
+    context.registerAdapterExtension(
+      "@blokkli/readability",
+      resolve("./runtime/adapter-extension")
+    );
+  }
+});
+
+export { index as default };

package/dist/modules/readability/runtime/adapter-extension.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/readability/runtime/adapter-extension.js

@@ -0,0 +1,5 @@
+import { defineBlokkliAdapterExtension } from "#blokkli/editor/adapter";
+import { createBuiltinReadabilityAnalyzer } from "./analyzers/builtin.js";
+export default defineBlokkliAdapterExtension(() => ({
+  getReadabilityAnalyzer: () => createBuiltinReadabilityAnalyzer()
+}));

package/dist/modules/readability/runtime/analyzers/builtin.d.ts

@@ -0,0 +1,10 @@
+import type { ReadabilityAnalyzer } from '#blokkli/editor/features/analyze/readability/types';
+/**
+ * Create the built-in readability analyzer using language-specific algorithms:
+ * Flesch Reading Ease → CEFR (en), Wiener Sachtextformel (de), LIX (fr),
+ * Gulpease (it). English syllable counting uses the `syllable` npm package,
+ * loaded lazily on the first `analyze()` call. German syllable counting uses
+ * a local vowel-group heuristic. French and Italian formulas don't need
+ * syllables at all.
+ */
+export declare function createBuiltinReadabilityAnalyzer(): ReadabilityAnalyzer;

package/dist/modules/readability/runtime/analyzers/builtin.js

@@ -0,0 +1,340 @@
+function fleschReadingEase(sentences, syllablesPerWord, coefficients) {
+  return coefficients.base - coefficients.sentences * sentences - coefficients.syllablesPerWord * syllablesPerWord;
+}
+function gulpeaseIndex(sentences, chars, words) {
+  const BASE = 89;
+  const SENTENCES_COEF = 300;
+  const CHARS_COEF = 10;
+  return (SENTENCES_COEF * sentences - CHARS_COEF * chars) / words + BASE;
+}
+function lix(words, longWords, wordsPerSentence) {
+  if (words === 0) return 0;
+  return wordsPerSentence + longWords * 100 / words;
+}
+const WSTF_VARIANT_1 = {
+  ms: 0.1935,
+  sl: 0.1672,
+  iw: 0.1297,
+  es: -0.0327,
+  base: -0.875
+};
+function wienerSachtextformel(words, sentences, longWords, polysyllables, monosyllables) {
+  const { ms, sl, iw, es, base } = WSTF_VARIANT_1;
+  const msVal = 100 * polysyllables / words;
+  const slVal = words / sentences;
+  const iwVal = 100 * longWords / words;
+  const esVal = 100 * monosyllables / words;
+  return base + ms * msVal + sl * slVal + iw * iwVal + es * esVal;
+}
+const FRE_COEFFICIENTS = {
+  en: { base: 206.835, sentences: 1.015, syllablesPerWord: 84.6 },
+  de: { base: 180, sentences: 1, syllablesPerWord: 58.5 },
+  fr: { base: 207, sentences: 1.015, syllablesPerWord: 73.6 },
+  it: { base: 217, sentences: 1.3, syllablesPerWord: 0.6 }
+};
+function getWords(text) {
+  return text.replace(/[^\p{L}\p{N}\s']/gu, "").toLowerCase().split(/\s+/g).filter(Boolean);
+}
+function getSentences(text) {
+  return text.match(/[^.!?。！？\n\r]+[.!?。！？]*[\n\r]*/gu) || [];
+}
+function sentenceCount(text) {
+  const sentences = getSentences(text);
+  let ignored = 0;
+  for (const s of sentences) {
+    if (getWords(s).length <= 2) ignored += 1;
+  }
+  return Math.max(1, sentences.length - ignored);
+}
+function wordCount(text) {
+  return getWords(text).length;
+}
+function longWordCount(text, threshold = 6) {
+  return getWords(text).filter((w) => w.length > threshold).length;
+}
+function charCount(text) {
+  return text.replace(/\s+/g, "").length;
+}
+function avgSentenceLength(text) {
+  const sentences = sentenceCount(text);
+  return sentences ? wordCount(text) / sentences : 0;
+}
+function avgWordsPerSentence(text) {
+  return avgSentenceLength(text);
+}
+function avgSyllablesPerWord(text, ctx, interval) {
+  const words = getWords(text);
+  if (!words.length) return 0;
+  let syllables = 0;
+  for (const w of words) syllables += ctx.syllableCount(w);
+  return interval ? syllables * interval / words.length : syllables / words.length;
+}
+function polysyllableCount(text, ctx) {
+  let count = 0;
+  for (const w of getWords(text)) {
+    if (ctx.syllableCount(w) > 2) count += 1;
+  }
+  return count;
+}
+function monosyllableCount(text, ctx) {
+  let count = 0;
+  for (const w of getWords(text)) {
+    if (ctx.syllableCount(w) === 1) count += 1;
+  }
+  return count;
+}
+const DE_VOWELS = /[aeiouäöüy]/i;
+const DE_DIPHTHONGS = /^(?:au|ei|eu|äu|ai|ie)/i;
+function countSyllablesDe(word) {
+  const w = word.toLowerCase();
+  if (!w) return 0;
+  let count = 0;
+  let i = 0;
+  let inVowelGroup = false;
+  while (i < w.length) {
+    const two = w.substring(i, i + 2);
+    if (DE_DIPHTHONGS.test(two)) {
+      if (!inVowelGroup) count += 1;
+      inVowelGroup = true;
+      i += 2;
+      continue;
+    }
+    if (DE_VOWELS.test(w[i])) {
+      if (!inVowelGroup) count += 1;
+      inVowelGroup = true;
+    } else {
+      inVowelGroup = false;
+    }
+    i += 1;
+  }
+  return Math.max(1, count);
+}
+let englishSyllable = null;
+async function loadEnglishSyllable() {
+  if (!englishSyllable) {
+    const mod = await import("syllable");
+    englishSyllable = mod.syllable;
+  }
+  return englishSyllable;
+}
+function fleschToCefr(score) {
+  if (score >= 90) return "A1";
+  if (score >= 80) return "A2";
+  if (score >= 70) return "B1";
+  if (score >= 60) return "B2";
+  if (score >= 50) return "C1";
+  return "C2";
+}
+const SCORE_CONFIGS = {
+  en: {
+    label: "CEFR",
+    compute: (text, ctx) => fleschReadingEase(
+      avgSentenceLength(text),
+      avgSyllablesPerWord(text, ctx),
+      FRE_COEFFICIENTS.en
+    ),
+    direction: "higher_easier",
+    // Aligned to CEFR buckets: easy = A1–B2 (FRE ≥ 60), ok = C1 (50–60),
+    // hard = C2 (< 50). Keeps each CEFR level in exactly one analyze section.
+    bands: { easy: 60, ok: 50 },
+    impactThresholds: [40, 25, 10],
+    minWords: 15,
+    formatScore: fleschToCefr,
+    referenceTable: [
+      { range: "FRE 90\u2013100", label: "A1 \u2014 beginners" },
+      { range: "FRE 80\u201390", label: "A2 \u2014 elementary" },
+      { range: "FRE 70\u201380", label: "B1 \u2014 intermediate" },
+      { range: "FRE 60\u201370", label: "B2 \u2014 upper intermediate (target)" },
+      { range: "FRE 50\u201360", label: "C1 \u2014 advanced (could be simpler)" },
+      {
+        range: "FRE 0\u201350",
+        label: "C2 \u2014 mastery \u2014 this is what gets flagged"
+      }
+    ]
+  },
+  de: {
+    label: "WSTF",
+    compute: (text, ctx) => wienerSachtextformel(
+      wordCount(text),
+      sentenceCount(text),
+      longWordCount(text),
+      polysyllableCount(text, ctx),
+      monosyllableCount(text, ctx)
+    ),
+    direction: "higher_harder",
+    bands: { easy: 15, ok: 18 },
+    impactThresholds: [16, 20, 24],
+    minWords: 5,
+    referenceTable: [
+      { range: "Below 8", label: "Very easy (children's books)" },
+      { range: "8\u201315", label: "Easy (standard website content)" },
+      { range: "15\u201318", label: "Moderately difficult (could be simpler)" },
+      {
+        range: "Above 18",
+        label: "Difficult \u2014 this is what gets flagged"
+      },
+      { range: "Above 24", label: "Critical \u2014 must be simplified" }
+    ]
+  },
+  fr: {
+    label: "LIX",
+    compute: (text) => lix(wordCount(text), longWordCount(text), avgWordsPerSentence(text)),
+    direction: "higher_harder",
+    bands: { easy: 40, ok: 59 },
+    impactThresholds: [50, 60, 70],
+    minWords: 5,
+    referenceTable: [
+      { range: "Below 25", label: "Very easy (children's books)" },
+      { range: "25\u201340", label: "Easy (simple articles)" },
+      { range: "40\u201350", label: "Medium (newspapers)" },
+      { range: "50\u201360", label: "Difficult (official documents)" },
+      {
+        range: "Above 60",
+        label: "Very difficult \u2014 this is what gets flagged"
+      },
+      { range: "Above 70", label: "Critical \u2014 must be simplified" }
+    ]
+  },
+  it: {
+    label: "Gulpease",
+    compute: (text) => gulpeaseIndex(sentenceCount(text), charCount(text), wordCount(text)),
+    direction: "higher_easier",
+    bands: { easy: 80, ok: 60 },
+    impactThresholds: [60, 50, 40],
+    minWords: 5,
+    referenceTable: [
+      { range: "Above 80", label: "Very easy (children's books)" },
+      { range: "60\u201380", label: "Easy (simple articles)" },
+      { range: "50\u201360", label: "Medium (newspapers)" },
+      { range: "40\u201350", label: "Difficult (official documents)" },
+      {
+        range: "Below 40",
+        label: "Very difficult \u2014 this is what gets flagged"
+      },
+      { range: "Below 30", label: "Critical \u2014 must be simplified" }
+    ]
+  }
+};
+const SUPPORTED_LANGUAGES = ["en", "de", "fr", "it"];
+function getConfig(langcode) {
+  if (isSupportedLangcode(langcode)) {
+    return SCORE_CONFIGS[langcode];
+  }
+  return SCORE_CONFIGS.en;
+}
+function isSupportedLangcode(v) {
+  return v === "en" || v === "de" || v === "fr" || v === "it";
+}
+function segmentWords(text) {
+  if ("Segmenter" in Intl) {
+    const seg = new Intl.Segmenter(void 0, { granularity: "word" });
+    const out = [];
+    for (const s of seg.segment(text)) {
+      if (s.isWordLike)
+        out.push(text.slice(s.index, s.index + s.segment.length));
+    }
+    return out;
+  }
+  return text.match(/\p{Letter}+(?:'\p{Letter}+)?/gu) ?? [];
+}
+function safe(fn) {
+  try {
+    const n = fn();
+    return Number.isFinite(n) ? n : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function round(n) {
+  return Math.round(n * 10) / 10;
+}
+function classifyBandGeneric(score, config) {
+  if (config.direction === "higher_easier") {
+    if (score >= config.bands.easy) return "easy";
+    if (score >= config.bands.ok) return "ok";
+    return "hard";
+  }
+  if (score <= config.bands.easy) return "easy";
+  if (score <= config.bands.ok) return "ok";
+  return "hard";
+}
+function impactForScoreGeneric(score, config) {
+  const [moderate, serious, critical] = config.impactThresholds;
+  if (config.direction === "higher_easier") {
+    if (score < critical) return "critical";
+    if (score < serious) return "serious";
+    if (score < moderate) return "moderate";
+    return "minor";
+  }
+  if (score >= critical) return "critical";
+  if (score >= serious) return "serious";
+  if (score >= moderate) return "moderate";
+  return "minor";
+}
+function buildAgentContext(config) {
+  const rows = config.referenceTable.map((row) => `- ${row.range}: ${row.label}`).join("\n");
+  return `## ${config.label} Score Reference
+
+${rows}`;
+}
+export function createBuiltinReadabilityAnalyzer() {
+  return {
+    id: "builtin",
+    label: (langcode) => {
+      if (langcode === "de") return "Lesbarkeit";
+      return "Readability";
+    },
+    description: "Analyzes text readability using language-specific algorithms (LIX, Wiener Sachtextformel, Gulpease).",
+    supportedLanguages: SUPPORTED_LANGUAGES,
+    minWordsForConfidence(langcode) {
+      return getConfig(langcode).minWords;
+    },
+    scoreLabel(langcode) {
+      return getConfig(langcode).label;
+    },
+    async analyze(texts, langcode) {
+      if (!isSupportedLangcode(langcode)) {
+        return texts.map(() => null);
+      }
+      const syllableCount = langcode === "en" ? await loadEnglishSyllable() : countSyllablesDe;
+      const ctx = { syllableCount };
+      const config = getConfig(langcode);
+      return texts.map((text) => {
+        const trimmed = text.trim();
+        if (!trimmed) return null;
+        const words = segmentWords(trimmed);
+        if (words.length < config.minWords) return null;
+        const score = safe(() => config.compute(trimmed, ctx));
+        return score != null ? round(score) : null;
+      });
+    },
+    classifyBand(score, langcode) {
+      return classifyBandGeneric(score, getConfig(langcode));
+    },
+    impactForScore(score, langcode) {
+      return impactForScoreGeneric(score, getConfig(langcode));
+    },
+    getAgentContext(langcode) {
+      return buildAgentContext(getConfig(langcode));
+    },
+    formatScore(value, langcode) {
+      const config = getConfig(langcode);
+      if (config.formatScore) {
+        return config.formatScore(value);
+      }
+      return Number.isFinite(value) ? value.toFixed(1) : String(value);
+    },
+    getScaleInfo(langcode) {
+      const config = getConfig(langcode);
+      const t1 = Math.min(config.bands.easy, config.bands.ok);
+      const t2 = Math.max(config.bands.easy, config.bands.ok);
+      const padding = Math.round((t2 - t1) * 0.5);
+      return {
+        thresholds: [t1, t2],
+        direction: config.direction,
+        scaleMin: Math.max(0, t1 - padding),
+        scaleMax: t2 + padding
+      };
+    }
+  };
+}