@blokkli/editor 2.0.0-alpha.58 → 2.0.0-alpha.59

package/dist/modules/charts/runtime/helpers/nextCategoryValue.js

@@ -0,0 +1,160 @@
+export function nextCategoryValue(categories) {
+  const fallback = `Category ${categories.length + 1}`;
+  if (categories.length < 2) {
+    return fallback;
+  }
+  const cleaned = categories.map(stripFootnotes);
+  return detectMonthYear(cleaned) ?? detectYearMonth(cleaned) ?? detectMonthName(cleaned) ?? detectInteger(cleaned) ?? fallback;
+}
+function stripFootnotes(value) {
+  return value.replace(/\{\d\}/g, "");
+}
+function constantStep(values) {
+  if (values.length < 2) return null;
+  const step = values[1] - values[0];
+  if (step === 0) return null;
+  for (let i = 2; i < values.length; i++) {
+    if (values[i] - values[i - 1] !== step) return null;
+  }
+  return step;
+}
+function detectInteger(categories) {
+  const values = [];
+  for (const c of categories) {
+    const trimmed = c.trim();
+    if (!/^-?\d+$/.test(trimmed)) return null;
+    values.push(Number(trimmed));
+  }
+  const step = constantStep(values);
+  if (step === null) return null;
+  return String(values[values.length - 1] + step);
+}
+const MONTH_YEAR_RE = /^(\d{1,2})\/(\d{4})$/;
+function detectMonthYear(categories) {
+  const totals = [];
+  for (const c of categories) {
+    const match = c.trim().match(MONTH_YEAR_RE);
+    if (!match) return null;
+    const month = Number(match[1]);
+    const year = Number(match[2]);
+    if (month < 1 || month > 12) return null;
+    totals.push(year * 12 + (month - 1));
+  }
+  const step = constantStep(totals);
+  if (step === null) return null;
+  const next = totals[totals.length - 1] + step;
+  const nextYear = Math.floor(next / 12);
+  const nextMonth = next % 12 + 1;
+  return `${String(nextMonth).padStart(2, "0")}/${nextYear}`;
+}
+const MONTH_NAMES = {
+  en: [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+  ],
+  de: [
+    "Januar",
+    "Februar",
+    "M\xE4rz",
+    "April",
+    "Mai",
+    "Juni",
+    "Juli",
+    "August",
+    "September",
+    "Oktober",
+    "November",
+    "Dezember"
+  ],
+  fr: [
+    "janvier",
+    "f\xE9vrier",
+    "mars",
+    "avril",
+    "mai",
+    "juin",
+    "juillet",
+    "ao\xFBt",
+    "septembre",
+    "octobre",
+    "novembre",
+    "d\xE9cembre"
+  ],
+  it: [
+    "gennaio",
+    "febbraio",
+    "marzo",
+    "aprile",
+    "maggio",
+    "giugno",
+    "luglio",
+    "agosto",
+    "settembre",
+    "ottobre",
+    "novembre",
+    "dicembre"
+  ]
+};
+function detectMonthName(categories) {
+  const lowered = categories.map((c) => c.trim().toLowerCase());
+  if (lowered.some((v) => !v)) return null;
+  for (const locale of Object.keys(MONTH_NAMES)) {
+    const names = MONTH_NAMES[locale];
+    const lowerNames = names.map((n) => n.toLowerCase());
+    const indices = [];
+    let matched = true;
+    for (const v of lowered) {
+      const idx = lowerNames.indexOf(v);
+      if (idx === -1) {
+        matched = false;
+        break;
+      }
+      indices.push(idx);
+    }
+    if (!matched) continue;
+    const step = cyclicStep(indices, 12);
+    if (step === null) continue;
+    const last = indices[indices.length - 1];
+    const next = ((last + step) % 12 + 12) % 12;
+    return names[next];
+  }
+  return null;
+}
+function cyclicStep(values, cycle) {
+  if (values.length < 2) return null;
+  const first = ((values[1] - values[0]) % cycle + cycle) % cycle;
+  if (first === 0) return null;
+  for (let i = 2; i < values.length; i++) {
+    const s = ((values[i] - values[i - 1]) % cycle + cycle) % cycle;
+    if (s !== first) return null;
+  }
+  return first;
+}
+const YEAR_MONTH_RE = /^(\d{4})-(\d{1,2})$/;
+function detectYearMonth(categories) {
+  const totals = [];
+  for (const c of categories) {
+    const match = c.trim().match(YEAR_MONTH_RE);
+    if (!match) return null;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    if (month < 1 || month > 12) return null;
+    totals.push(year * 12 + (month - 1));
+  }
+  const step = constantStep(totals);
+  if (step === null) return null;
+  const next = totals[totals.length - 1] + step;
+  const nextYear = Math.floor(next / 12);
+  const nextMonth = next % 12 + 1;
+  return `${nextYear}-${String(nextMonth).padStart(2, "0")}`;
+}

package/dist/modules/charts/runtime/helpers/numberFormat.d.ts

@@ -0,0 +1,13 @@
+import type { ChartNumberFormat } from '../types.js';
+/**
+ * Build a value formatter for chart axes, data labels and tooltips. Wraps
+ * `Intl.NumberFormat` with locale, decimals, notation and adds optional
+ * prefix/suffix (currency symbol, units).
+ */
+export declare function createNumberFormatter(format: ChartNumberFormat | undefined): (value: number) => string;
+/**
+ * Build a percentage formatter for pie/donut data labels. ApexCharts feeds
+ * those formatters the slice share (0-100), not the raw value, so currency
+ * prefix/suffix and notation don't apply — only locale and decimals do.
+ */
+export declare function createPercentFormatter(format: ChartNumberFormat | undefined): (value: number) => string;

package/dist/modules/charts/runtime/helpers/numberFormat.js

@@ -0,0 +1,31 @@
+function createIntl(locale, opts) {
+  try {
+    return new Intl.NumberFormat(locale || void 0, opts);
+  } catch {
+    return new Intl.NumberFormat(void 0, opts);
+  }
+}
+export function createNumberFormatter(format) {
+  const opts = {};
+  if (format?.notation) {
+    opts.notation = format.notation;
+  }
+  if (format?.decimals !== void 0) {
+    opts.minimumFractionDigits = format.decimals;
+    opts.maximumFractionDigits = format.decimals;
+  } else if (format?.notation === "compact") {
+    opts.maximumFractionDigits = 1;
+  }
+  const fmt = createIntl(format?.locale, opts);
+  const prefix = format?.prefix ?? "";
+  const suffix = format?.suffix ?? "";
+  return (value) => Number.isFinite(value) ? `${prefix}${fmt.format(value)}${suffix}` : "";
+}
+export function createPercentFormatter(format) {
+  const decimals = format?.decimals ?? 1;
+  const fmt = createIntl(format?.locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+  return (value) => Number.isFinite(value) ? `${fmt.format(value)}%` : "";
+}

package/dist/modules/charts/runtime/helpers/previewInjection.d.ts

@@ -0,0 +1,14 @@
+import type { ComputedRef, InjectionKey } from 'vue';
+import type { ChartDataSourcePayload } from '../types.js';
+/**
+ * Editor-only injection used by the chart editor's `Preview` component to
+ * pass the adapter-fetched dynamic data into the chart block (which renders
+ * `ChartRenderer`).
+ *
+ * At runtime (outside the editor), the integrator passes data via the
+ * `dynamicData` prop on `ChartRenderer` directly. This inject is the
+ * fallback `ChartRenderer` uses when the prop is not provided, so the
+ * integrator's block component doesn't need to know about editor preview
+ * fetching.
+ */
+export declare const INJECT_CHART_PREVIEW_DYNAMIC_DATA: InjectionKey<ComputedRef<ChartDataSourcePayload | null>>;

package/dist/modules/charts/runtime/helpers/previewInjection.js

@@ -0,0 +1,3 @@
+export const INJECT_CHART_PREVIEW_DYNAMIC_DATA = Symbol(
+  "blokkli_chart_preview_dynamic_data"
+);

package/dist/modules/charts/runtime/types.d.ts

@@ -1,14 +1,223 @@
-import type { ChartTypeOptionsMap } from './chartTypes/index.js';
-export type ChartType = 'bar' | 'line' | 'pie' | 'area' | 'donut' | 'heatmap' | 'radialBar' | 'radar';
-export type ChartTypeOptions = ChartTypeOptionsMap[ChartType];
-export type ChartSeries = {
-    name: string;
+import type { BlokkliIcon } from '#blokkli-build/icons';
+import type { BlockOptionDefinitionBase } from '../../../global/types/blockOptions.js';
+export type TranslateFunction = (key: string, fallback: string) => string;
+/**
+ * Context object passed to `ChartOption.shouldRender`. Currently exposes the
+ * current values of all type-options on the block; more fields may be added
+ * here over time (e.g. resolved payload, chart-type id) without breaking
+ * existing predicates.
+ */
+export type ChartOptionRenderContext = {
+    /** Current values of all chart-type options on this block. */
+    options: Record<string, unknown>;
+};
+/**
+ * A chart-type option definition. Extends the generic blökkli block option
+ * schema with chart-specific extras — currently a `shouldRender` predicate
+ * for conditional visibility in the editor.
+ */
+export type ChartOption = BlockOptionDefinitionBase<BlokkliIcon> & {
+    /**
+     * Optional predicate that decides whether this option is rendered in the
+     * editor. Receives a context object so options can react to other
+     * options' current values. When omitted the option is always rendered.
+     *
+     * @example
+     * categoryFilterLabel: {
+     *   type: 'text',
+     *   …,
+     *   shouldRender: ({ options }) => options.categoryFilter === true,
+     * }
+     */
+    shouldRender?: (ctx: ChartOptionRenderContext) => boolean;
+};
+export type ChartTypeDefinitionBody<_T extends Record<string, unknown> = Record<string, unknown>> = {
+    hasSeriesColors: boolean;
+    hasCategoryColors: boolean;
+    editor: {
+        label: string;
+        description: string;
+        icon: BlokkliIcon;
+        options: Record<string, ChartOption>;
+    };
+};
+export type ChartTypeFactory<T extends Record<string, unknown> = Record<string, unknown>> = ($t: TranslateFunction) => ChartTypeDefinitionBody<T>;
+/** What `defineChartType` returns and what the registry stores. */
+export type ChartTypeDefinitionEntry<T extends Record<string, unknown> = Record<string, unknown>> = {
+    id: string;
+    factory: ChartTypeFactory<T>;
+};
+/** Resolved at registry time. What downstream consumers see. */
+export type ChartTypeDefinition<T extends Record<string, unknown> = Record<string, unknown>> = ChartTypeDefinitionBody<T> & {
+    id: string;
+};
+/**
+ * The props every chart-type render component receives from `ChartRenderer`.
+ * Values are fully resolved (translations, date formatting, footnotes,
+ * dynamic-data overrides, hex colors).
+ */
+export type ChartTypeRenderProps = {
+    title: string;
+    categories: string[];
+    series: {
+        name: string;
+        data: number[];
+    }[];
+    /** Hex colors aligned with `series` order. Read by types with series colors. */
+    seriesHexColors: string[];
+    /** Hex colors aligned with `categories` order. Read by types with category colors. */
+    categoryHexColors: string[];
+    typeOptions: Record<string, unknown>;
+    numberFormat?: ChartNumberFormat;
+    isEditing: boolean;
     /**
-     * The color identifier as defined in the module options.
+     * Pre-parsed ECharts option object — only relevant for the `advanced`
+     * chart type. Renderers for other types ignore this field.
      */
+    advancedConfig?: Record<string, unknown>;
+};
+export type XAxisTypeOptions = {
+    xaxisRotation: string;
+};
+export type DataLabelsTypeOptions = {
+    dataLabels: boolean;
+};
+export type LegendTypeOptions = {
+    legendPosition: string;
+};
+export type GridTypeOptions = {
+    gridLines: boolean;
+};
+export type StrokeWidthTypeOptions = {
+    strokeWidth: string;
+};
+export type YAxisMinTypeOptions = {
+    yaxisMin: number | undefined;
+};
+export type CategoryFilterTypeOptions = {
+    categoryFilter: boolean;
+    categoryFilterLabel: string;
+};
+/**
+ * Chart-type id. Plain `string` to avoid a circular type dependency with the
+ * build-time `#blokkli-build/charts-definitions` template (whose generated
+ * `.d.ts` imports types from this file). If you want a strongly-typed
+ * union of known ids, import `ChartTypeId` from
+ * `#blokkli-build/charts-definitions` directly.
+ */
+export type ChartType = string;
+export type ChartTypeOptions = Record<string, unknown>;
+export type ChartSeries = {
+    name: string;
+    /** The color identifier as defined in the module options. */
     color: string;
     data: number[];
 };
+export type ChartNumberFormat = {
+    /** BCP-47 locale tag, e.g. 'de-CH', 'de-DE', 'en-US'. Empty = browser default. */
+    locale?: string;
+    /** Forced fraction digits (0-4). Undefined leaves it to Intl. */
+    decimals?: number;
+    /** String inserted before the formatted number, e.g. 'CHF '. */
+    prefix?: string;
+    /** String appended after the formatted number, e.g. ' kg', '%'. */
+    suffix?: string;
+    /** 'standard' for full numbers (1'234'500), 'compact' for short form (1.2M). */
+    notation?: 'standard' | 'compact';
+};
+/**
+ * Display style applied to category labels when they are detected as dates.
+ * `auto` picks a sensible default based on the detected source granularity.
+ */
+export type ChartDateFormatStyle = 'auto' | 'none' | 'monthYearShort' | 'monthYearLong' | 'monthOnly' | 'monthYearNumeric' | 'iso' | 'dateShort' | 'dateLong' | 'yearOnly';
+export type ChartDateFormat = {
+    /** Display style. Falls back to `auto` if undefined. Locale is reused
+     * from `numberFormat.locale`. */
+    style?: ChartDateFormatStyle;
+};
+/**
+ * Translated strings for one target language.
+ *
+ * Arrays are positionally aligned to the source arrays (categories, series,
+ * footnotes). Empty strings mean "no translation yet, fall back to source".
+ */
+export type ChartTranslation = {
+    title?: string;
+    categories?: string[];
+    seriesNames?: string[];
+    footnotes?: string[];
+    prefix?: string;
+    suffix?: string;
+};
+/**
+ * A backend-provided chart data source descriptor.
+ */
+export type ChartDataSource = {
+    id: string;
+    label: string;
+    description?: string;
+};
+/**
+ * Capabilities flag set returned by the adapter to tell the editor how to
+ * call `getChartDataSources`. Reserved for future flags.
+ */
+export type ChartDataSourceCapabilities = {
+    /**
+     * When true, `getChartDataSources` is called with `text` + `page` args
+     * and is expected to return `BlokkliAdapterSearchResults<ChartDataSource>`.
+     * When false, it is called once with no args and is expected to return
+     * the full list as `ChartDataSource[]` (editor performs fuzzy filtering
+     * client-side).
+     */
+    supportsSearch: boolean;
+};
+/**
+ * Raw data returned by `getChartDataSourceData` (editor) and by the
+ * integrator's runtime fetch (passed via `ChartRenderer`'s `dynamicData`
+ * prop).
+ */
+export type ChartDataSourcePayload = {
+    categories: string[];
+    series: {
+        name: string;
+        data: number[];
+    }[];
+};
+/**
+ * Per-series presentation overrides for dynamic data, keyed by the
+ * fetched series name.
+ */
+export type ChartSeriesOverride = {
+    color?: string;
+    hidden?: boolean;
+};
+/**
+ * Reference to a dynamic data source stored on a chart block.
+ *
+ * When set, the block's inline `categories` / `series` are ignored at
+ * render time. Inline data is preserved as a "shadow" state so the user
+ * can switch back to the custom-data tab without losing their input.
+ */
+export type ChartDataSourceRef = {
+    id: string;
+    /** Cached label for display when the live source has been removed. */
+    label: string;
+    /** Keyed by fetched series name. */
+    seriesOverrides?: Record<string, ChartSeriesOverride>;
+    /** Keyed by fetched category label, used by pie/donut charts. */
+    categoryColorOverrides?: Record<string, string>;
+};
+/**
+ * Storage shape for the `advanced` chart type. The renderer reads `parsed`
+ * directly — no JSON parsing required. `source` is the textarea text
+ * (JSON5-tolerant) and is editor-only: it is stripped before persisting.
+ */
+export type ChartAdvancedConfig = {
+    /** Parsed ECharts option object — what the renderer consumes. */
+    parsed: Record<string, unknown>;
+    /** Raw textarea text. Editor-only; stripped on save. */
+    source?: string;
+};
 type ChartDataBase = {
     title: string;
     categories: string[];
@@ -19,15 +228,29 @@ type ChartDataBase = {
      */
     categoryColors: string[];
     footnotes: string[];
+    numberFormat?: ChartNumberFormat;
+    dateFormat?: ChartDateFormat;
+    /**
+     * Per-language translations of the translatable strings, keyed by
+     * langcode. Chart options are not translatable in blökkli, so
+     * translations live alongside the source data.
+     */
+    translations?: Record<string, ChartTranslation>;
+    /**
+     * Optional reference to a dynamic data source. When set, the block
+     * renders data fetched from the source at runtime (via the integrator's
+     * fetching logic + the `dynamicData` prop on `ChartRenderer`). The
+     * inline `categories` / `series` are kept as a snapshot so switching
+     * back to custom data restores the user's last input.
+     */
+    dataSource?: ChartDataSourceRef;
+    /**
+     * Raw ECharts configuration, used only when `type === 'advanced'`.
+     */
+    advancedConfig?: ChartAdvancedConfig;
 };
-export type BlokkliChartData = {
-    [K in ChartType]: ChartDataBase & {
-        type: K;
-        typeOptions?: Partial<ChartTypeOptionsMap[K]>;
-    };
-}[ChartType];
-export type ChartColor = {
-    color: string;
-    label: string;
+export type BlokkliChartData = ChartDataBase & {
+    type: ChartType;
+    typeOptions?: Record<string, unknown>;
 };
 export {};

package/dist/modules/drupal/graphql/base/fragment.paragraphsBlokkliMutationItem.graphql

@@ -5,5 +5,28 @@ fragment paragraphsBlokkliMutationItem on FieldItemTypeParagraphsBlokkliMutation
   plugin {
     label
     affectedItemUuid: affectedParagraphUuid
+    importSummary {
+      paragraphsImported
+      referencesResolvedByUuid
+      skippedBundles {
+        bundle
+        count
+      }
+      droppedFields {
+        bundle
+        fieldName
+      }
+      referencesResolvedByLabel {
+        entityType
+        label
+        targetId
+      }
+      referencesUnresolved {
+        entityType
+        uuid
+        label
+        reason
+      }
+    }
   }
 }

package/dist/modules/drupal/graphql/base/query.pbConfig.graphql

@@ -1,4 +1,7 @@
-fragment paragraphsBlokkliUserPermissions on ParagraphsBlokkliUser {
+fragment paragraphsBlokkliCurrentUser on ParagraphsBlokkliUser {
+  id
+  name
+  imageUrl
   use_blokkli: hasPermission(permission: "view paragraphs blokkli edit state")
   take_ownership: hasPermission(
     permission: "take ownership of paragraphs blokkli edit state"
@@ -16,10 +19,16 @@ fragment paragraphsBlokkliUserPermissions on ParagraphsBlokkliUser {
   create_comments: hasPermission(permission: "post comments")
   view_comments: hasPermission(permission: "access comments")
   use_agent: hasPermission(permission: "use paragraphs blokkli agent")
+  manage_agent_conversations: hasPermission(
+    permission: "manage all blokkli agent conversations"
+  )
+  list_users: hasPermission(permission: "load id and name of blokkli users")
+  transfer_blocks: hasPermission(permission: "transfer blokkli paragraphs")
 }
+
 query pbConfig($entityType: String!, $entityBundle: String!) {
-  userPermissions: paragraphsBlokkliGetUser {
-    ...paragraphsBlokkliUserPermissions
+  currentUser: paragraphsBlokkliGetUser {
+    ...paragraphsBlokkliCurrentUser
   }
   clipboards: pbGetSupportedClipboards {
     ...paragraphsBlokkliSupportedClipboard

package/dist/modules/drupal/graphql/base/query.pbUsers.graphql

@@ -0,0 +1,10 @@
+fragment paragraphsBlokkliUserListItem on ParagraphsBlokkliUserSearchItem {
+  id
+  name
+}
+
+query pbUsers {
+  users: paragraphsBlokkliGetUsers {
+    ...paragraphsBlokkliUserListItem
+  }
+}

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

@@ -1,13 +1,42 @@
-fragment pbAgentConversation on ParagraphsBlokkliAgentConversation {
+fragment pbAgentConversationItem on ParagraphsBlokkliAgentConversation {
   uuid
   title
+  createdAt: created
+  updatedAt: changed
+  host {
+    entityType
+    entityUuid
+    label
+    editUrl: url
+  }
+  author {
+    id
+    name
+    imageUrl
+  }
+}
+
+fragment pbAgentConversation on ParagraphsBlokkliAgentConversation {
+  ...pbAgentConversationItem
   clientState: dataUser
   serverState: dataServer
   hash
-  createdAt: created
-  updatedAt: changed
   feedback {
-    itemId
+    ...pbAgentFeedbackItem
+  }
+}
+
+fragment pbAgentFeedbackItem on ParagraphsBlokkliAgentFeedback {
+  id
+  createdAt
+  rating
+  explanation
+  itemId
+  conversationUuid
+  author {
+    id
+    name
+    imageUrl
   }
 }
 
@@ -62,28 +91,51 @@ mutation pbAgentConversationFeedback(
   }
 }
 
-query pbAgentConversations($hostEntityType: String!, $hostEntityUuid: String!) {
-  conversations: paragraphsBlokkliAgentConversations(
-    hostEntityType: $hostEntityType
-    hostEntityUuid: $hostEntityUuid
-  ) {
-    uuid
-    title
-    createdAt: created
-    updatedAt: changed
+query pbAgentConversation($uuid: String!) {
+  conversation: paragraphsBlokkliAgentConversation(uuid: $uuid) {
+    ...pbAgentConversation
   }
 }
 
-query pbAgentConversation(
-  $hostEntityType: String!
-  $hostEntityUuid: String!
-  $uuid: String
-) {
-  conversation: paragraphsBlokkliAgentConversation(
-    hostEntityType: $hostEntityType
-    hostEntityUuid: $hostEntityUuid
-    uuid: $uuid
-  ) {
+query pbAgentConversationLatest($host: ParagraphsBlokkliHostEntityInput!) {
+  conversation: paragraphsBlokkliAgentConversationLatest(host: $host) {
     ...pbAgentConversation
   }
 }
+
+query pbAgentConversations($host: ParagraphsBlokkliHostEntityInput!) {
+  result: paragraphsBlokkliAgentConversations(host: $host) {
+    items {
+      uuid
+      title
+      createdAt: created
+      updatedAt: changed
+    }
+  }
+}
+
+query pbAgentConversationsAll($page: Int) {
+  result: paragraphsBlokkliAgentConversations(page: $page) {
+    filters {
+      ...paragraphsBlokkliConfigInput
+    }
+    items {
+      ...pbAgentConversationItem
+    }
+    perPage
+    total
+  }
+}
+
+query pbAgentFeedbackAll($page: Int) {
+  result: paragraphsBlokkliAgentConversationFeedbacks(page: $page) {
+    filters {
+      ...paragraphsBlokkliConfigInput
+    }
+    items {
+      ...pbAgentFeedbackItem
+    }
+    perPage
+    total
+  }
+}