@open-mercato/core 0.9.1-develop.7473.1.de5b22888f → 0.9.1-develop.7475.1.28ca93ed97

package/dist/modules/catalog/components/OmnibusSettings.js

@@ -0,0 +1,703 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { Plus, Trash2 } from "lucide-react";
+import { Alert, AlertDescription, AlertTitle } from "@open-mercato/ui/primitives/alert";
+import { Button } from "@open-mercato/ui/primitives/button";
+import { IconButton } from "@open-mercato/ui/primitives/icon-button";
+import { Input } from "@open-mercato/ui/primitives/input";
+import { FormField } from "@open-mercato/ui/primitives/form-field";
+import { SwitchField } from "@open-mercato/ui/primitives/switch-field";
+import { TagInput } from "@open-mercato/ui/primitives/tag-input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue
+} from "@open-mercato/ui/primitives/select";
+import { LoadingMessage, ErrorMessage } from "@open-mercato/ui/backend/detail";
+import { flash } from "@open-mercato/ui/backend/FlashMessages";
+import { useBackendChrome } from "@open-mercato/ui/backend/BackendChromeProvider";
+import { useGuardedMutation } from "@open-mercato/ui/backend/injection/useGuardedMutation";
+import { apiCall } from "@open-mercato/ui/backend/utils/apiCall";
+import { hasFeature } from "@open-mercato/shared/security/features";
+import { useOrganizationScopeDetail, useOrganizationScopeVersion } from "@open-mercato/shared/lib/frontend/useOrganizationScope";
+import { useT } from "@open-mercato/shared/lib/i18n/context";
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import { getTelemetryRuntime } from "@open-mercato/shared/lib/telemetry/runtime";
+import { PriceChannelSelect, PricePriceKindSelect } from "./prices/PriceScopeSelectors.js";
+const logger = createLogger("catalog").child({ component: "OmnibusSettings" });
+const OMNIBUS_CONFIG_PATH = "/api/catalog/config/omnibus";
+const MUTATION_CONTEXT_ID = "catalog-omnibus-settings";
+const DEFAULT_LOOKBACK_DAYS = 30;
+const MIN_LOOKBACK_DAYS = 1;
+const MAX_LOOKBACK_DAYS = 365;
+const COUNTRY_CODE_PATTERN = /^[A-Z]{2}$/;
+class OmnibusSaveError extends Error {
+  constructor(status, body) {
+    super(`[internal] catalog omnibus config save failed with status ${status}`);
+    this.status = status;
+    this.body = body;
+  }
+}
+let rowSequence = 0;
+function nextRowKey() {
+  rowSequence += 1;
+  return `omnibus-channel-${rowSequence}`;
+}
+function toFormState(config) {
+  const channels = Object.entries(config?.channels ?? {}).map(([channelId, channel]) => ({
+    key: nextRowKey(),
+    channelId,
+    presentedPriceKindId: channel.presentedPriceKindId ?? "",
+    countryCode: channel.countryCode ?? "",
+    lookbackDays: typeof channel.lookbackDays === "number" ? String(channel.lookbackDays) : "",
+    minimizationAxis: channel.minimizationAxis ?? "inherit"
+  }));
+  return {
+    enabled: config?.enabled === true,
+    lookbackDays: String(config?.lookbackDays ?? DEFAULT_LOOKBACK_DAYS),
+    enabledCountryCodes: Array.isArray(config?.enabledCountryCodes) ? [...config.enabledCountryCodes] : [],
+    noChannelMode: config?.noChannelMode ?? "best_effort",
+    minimizationAxis: config?.minimizationAxis ?? "gross",
+    defaultPresentedPriceKindId: config?.defaultPresentedPriceKindId ?? "",
+    channels
+  };
+}
+function parseLookbackDays(raw) {
+  const trimmed = raw.trim();
+  if (!/^\d+$/.test(trimmed)) return null;
+  const value = Number(trimmed);
+  if (!Number.isInteger(value) || value < MIN_LOOKBACK_DAYS || value > MAX_LOOKBACK_DAYS) return null;
+  return value;
+}
+function channelErrorKey(rowKey, field) {
+  return `channels.${rowKey}.${field}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asStoredConfig(value) {
+  return isRecord(value) ? value : null;
+}
+function listStaleBackfillScopes(stored, form) {
+  const coverage = stored?.backfillCoverage ?? {};
+  const globalLookback = parseLookbackDays(form.lookbackDays);
+  if (globalLookback === null) return [];
+  const channelLookbacks = new Map(
+    form.channels.filter((row) => row.channelId).map((row) => [row.channelId, parseLookbackDays(row.lookbackDays) ?? globalLookback])
+  );
+  return Object.entries(coverage).filter(([scopeId, entry]) => {
+    const effective = scopeId ? channelLookbacks.get(scopeId) ?? globalLookback : globalLookback;
+    return entry.lookbackDays < effective;
+  }).map(([scopeId]) => scopeId).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+}
+function OmnibusSettings() {
+  const t = useT();
+  const scopeVersion = useOrganizationScopeVersion();
+  const scopeTenantId = useOrganizationScopeDetail().tenantId;
+  const { payload: chromePayload, isReady: chromeReady } = useBackendChrome();
+  const grantedFeatures = chromePayload?.grantedFeatures;
+  const canManage = hasFeature(grantedFeatures, "catalog.settings.manage");
+  const canView = canManage || hasFeature(grantedFeatures, "catalog.settings.view");
+  const [stored, setStored] = React.useState(null);
+  const [form, setForm] = React.useState(() => toFormState(null));
+  const [loading, setLoading] = React.useState(true);
+  const [loadError, setLoadError] = React.useState(null);
+  const [saving, setSaving] = React.useState(false);
+  const [fieldErrors, setFieldErrors] = React.useState({});
+  const [formError, setFormError] = React.useState(null);
+  const [backfillChannels, setBackfillChannels] = React.useState(null);
+  const [backfillChannelNames, setBackfillChannelNames] = React.useState({});
+  const [reloadToken, setReloadToken] = React.useState(0);
+  const loadedSourceRef = React.useRef(null);
+  const { runMutation, retryLastMutation } = useGuardedMutation({
+    contextId: MUTATION_CONTEXT_ID,
+    blockedMessage: t("ui.forms.flash.saveBlocked", "Save blocked by validation")
+  });
+  const readOnly = !canManage || saving;
+  const errorMessages = React.useMemo(() => ({
+    omnibus_country_code_alpha2_required: t("catalog.omnibus.errors.countryCodeFormat", "Use a two-letter ISO country code."),
+    omnibus_country_code_eu_not_allowed: t("catalog.omnibus.errors.countryCodeEu", 'List individual member states instead of "EU".'),
+    omnibus_country_code_unknown: t("catalog.omnibus.errors.countryCodeUnknown", "Unknown country code."),
+    omnibus_presented_price_kind_required: t("catalog.omnibus.errors.presentedPriceKindRequired", "Select a default presented price kind, or configure a channel with its own price kind."),
+    omnibus_field_not_supported: t("catalog.omnibus.errors.fieldNotSupported", "This setting is not supported."),
+    omnibus_derogation_not_supported: t("catalog.omnibus.errors.fieldNotSupported", "This setting is not supported."),
+    omnibus_backfill_coverage_read_only: t("catalog.omnibus.errors.fieldNotSupported", "This setting is not supported.")
+  }), [t]);
+  const invalidValueMessage = t("catalog.omnibus.errors.invalidValue", "Invalid value.");
+  const lookbackRangeMessage = t("catalog.omnibus.errors.lookbackRange", "Enter a whole number of days between 1 and 365.");
+  const requiredMessage = t("catalog.omnibus.errors.required", "This field is required.");
+  const duplicateChannelMessage = t("catalog.omnibus.errors.duplicateChannel", "This channel is already configured.");
+  const saveErrorMessage = t("catalog.omnibus.errors.save", "Failed to save Omnibus settings.");
+  const staleBackfillScopes = React.useMemo(() => listStaleBackfillScopes(stored, form), [form, stored]);
+  const channelNameLookupKey = React.useMemo(
+    () => Array.from(new Set([...backfillChannels ?? [], ...staleBackfillScopes].filter((channelId) => channelId.length > 0))).sort((left, right) => left < right ? -1 : left > right ? 1 : 0).join(","),
+    [backfillChannels, staleBackfillScopes]
+  );
+  React.useEffect(() => {
+    const channelIds = channelNameLookupKey ? channelNameLookupKey.split(",") : [];
+    if (!channelIds.length) return;
+    let cancelled = false;
+    const query = new URLSearchParams({ ids: channelIds.join(","), pageSize: String(Math.min(channelIds.length, 100)) });
+    apiCall(`/api/sales/channels?${query.toString()}`).then((call) => {
+      if (cancelled || !call?.ok) return;
+      const items = Array.isArray(call.result?.items) ? call.result.items : [];
+      const names = {};
+      for (const item of items) {
+        if (typeof item.id === "string" && typeof item.name === "string" && item.name.length) names[item.id] = item.name;
+      }
+      setBackfillChannelNames((previous) => ({ ...previous, ...names }));
+    }).catch((err) => {
+      logger.warn("catalog.omnibus.settings.backfillChannelNames failed", { err });
+      getTelemetryRuntime()?.reportError(err, { module: "catalog", code: "catalog.omnibus_channel_names_load_failed" });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [channelNameLookupKey]);
+  const loadErrorMessage = t("catalog.omnibus.errors.load", "Failed to load Omnibus settings.");
+  React.useEffect(() => {
+    if (!chromeReady || !canView) return;
+    let cancelled = false;
+    const previous = loadedSourceRef.current;
+    if (!previous) setLoading(true);
+    setLoadError(null);
+    apiCall(OMNIBUS_CONFIG_PATH).then((call) => {
+      if (cancelled) return;
+      if (!call.ok) {
+        loadedSourceRef.current = null;
+        setLoadError(loadErrorMessage);
+        return;
+      }
+      const config = asStoredConfig(call.result);
+      const configKey = JSON.stringify(config);
+      const keepsEdits = previous !== null && previous.configKey === configKey && (previous.tenantId === null || previous.tenantId === scopeTenantId);
+      loadedSourceRef.current = { tenantId: scopeTenantId, configKey };
+      setStored(config);
+      if (keepsEdits) return;
+      setForm(toFormState(config));
+      setFieldErrors({});
+      setFormError(null);
+      setBackfillChannels(null);
+    }).catch((err) => {
+      logger.error("catalog.omnibus.settings.load failed", { err });
+      getTelemetryRuntime()?.reportError(err, { module: "catalog", code: "catalog.omnibus_settings_load_failed" });
+      if (!cancelled) setLoadError(loadErrorMessage);
+    }).finally(() => {
+      if (!cancelled) setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [canView, chromeReady, loadErrorMessage, reloadToken, scopeTenantId, scopeVersion]);
+  const translateServerError = React.useCallback(
+    (messages) => {
+      const first = Array.isArray(messages) ? messages.find((entry) => typeof entry === "string") : null;
+      if (typeof first !== "string") return invalidValueMessage;
+      return errorMessages[first] ?? invalidValueMessage;
+    },
+    [errorMessages, invalidValueMessage]
+  );
+  const mapServerFieldErrors = React.useCallback(
+    (raw) => {
+      const fields = {};
+      let unmatched = null;
+      for (const [path, messages] of Object.entries(raw)) {
+        const message = translateServerError(messages);
+        const segments = path.split(".");
+        const head = segments[0];
+        if (head === "channels" && segments.length >= 2) {
+          const row = form.channels.find((entry) => entry.channelId === segments[1]);
+          const field = segments[2] ?? "channelId";
+          if (row) {
+            fields[channelErrorKey(row.key, field)] = message;
+            continue;
+          }
+        } else if (head && head !== "_root" && head in form) {
+          fields[head] = fields[head] ?? message;
+          continue;
+        }
+        unmatched = unmatched ?? message;
+      }
+      return { fields, unmatched };
+    },
+    [form, translateServerError]
+  );
+  const buildPatch = React.useCallback(() => {
+    const errors = {};
+    const lookbackDays = parseLookbackDays(form.lookbackDays);
+    if (lookbackDays === null) errors.lookbackDays = lookbackRangeMessage;
+    const channels = {};
+    for (const row of form.channels) {
+      const channelId = row.channelId.trim();
+      if (!channelId) {
+        errors[channelErrorKey(row.key, "channelId")] = requiredMessage;
+      } else if (channels[channelId]) {
+        errors[channelErrorKey(row.key, "channelId")] = duplicateChannelMessage;
+      }
+      if (!row.presentedPriceKindId) errors[channelErrorKey(row.key, "presentedPriceKindId")] = requiredMessage;
+      const countryCode = row.countryCode.trim().toUpperCase();
+      if (countryCode && !COUNTRY_CODE_PATTERN.test(countryCode)) {
+        errors[channelErrorKey(row.key, "countryCode")] = errorMessages.omnibus_country_code_alpha2_required;
+      }
+      const channelLookback = row.lookbackDays.trim() ? parseLookbackDays(row.lookbackDays) : void 0;
+      if (channelLookback === null) errors[channelErrorKey(row.key, "lookbackDays")] = lookbackRangeMessage;
+      if (!channelId || channels[channelId]) continue;
+      channels[channelId] = {
+        presentedPriceKindId: row.presentedPriceKindId,
+        ...countryCode ? { countryCode } : {},
+        ...typeof channelLookback === "number" ? { lookbackDays: channelLookback } : {},
+        ...row.minimizationAxis !== "inherit" ? { minimizationAxis: row.minimizationAxis } : {}
+      };
+    }
+    if (Object.keys(errors).length > 0 || lookbackDays === null) return { patch: null, errors };
+    return {
+      patch: {
+        enabled: form.enabled,
+        lookbackDays,
+        enabledCountryCodes: form.enabledCountryCodes,
+        noChannelMode: form.noChannelMode,
+        minimizationAxis: form.minimizationAxis,
+        defaultPresentedPriceKindId: form.defaultPresentedPriceKindId || null,
+        channels
+      },
+      errors
+    };
+  }, [duplicateChannelMessage, errorMessages, form, lookbackRangeMessage, requiredMessage]);
+  const handleSubmit = React.useCallback(async () => {
+    if (!canManage || saving) return;
+    const { patch, errors } = buildPatch();
+    setFormError(null);
+    setBackfillChannels(null);
+    setFieldErrors(errors);
+    if (!patch) return;
+    setSaving(true);
+    try {
+      const saved = await runMutation({
+        operation: async () => {
+          const call = await apiCall(OMNIBUS_CONFIG_PATH, {
+            method: "PATCH",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(patch)
+          });
+          if (!call.ok) {
+            throw new OmnibusSaveError(call.status, isRecord(call.result) ? call.result : null);
+          }
+          return asStoredConfig(call.result);
+        },
+        context: {
+          formId: MUTATION_CONTEXT_ID,
+          resourceKind: "catalog.settings",
+          resourceId: "omnibus",
+          retryLastMutation
+        },
+        mutationPayload: patch
+      });
+      loadedSourceRef.current = { tenantId: scopeTenantId, configKey: JSON.stringify(saved) };
+      setStored(saved);
+      setForm(toFormState(saved));
+      setFieldErrors({});
+      flash(t("catalog.omnibus.messages.saved", "Omnibus settings saved."), "success");
+    } catch (err) {
+      if (err instanceof OmnibusSaveError) {
+        const body = err.body;
+        if (err.status === 422 && body?.error === "backfill_required_before_enable") {
+          const channels = Array.isArray(body.channels) ? body.channels.filter((entry) => typeof entry === "string") : [];
+          setBackfillChannels(channels);
+          return;
+        }
+        const detailFieldErrors = body?.details?.fieldErrors;
+        const rawFieldErrors = isRecord(detailFieldErrors) ? detailFieldErrors : null;
+        if (err.status === 400 && rawFieldErrors) {
+          const mapped = mapServerFieldErrors(rawFieldErrors);
+          setFieldErrors(mapped.fields);
+          setFormError(mapped.unmatched ?? t("catalog.omnibus.errors.invalid", "Fix the highlighted fields and try again."));
+          return;
+        }
+        setFormError(saveErrorMessage);
+        return;
+      }
+      logger.error("catalog.omnibus.settings.save failed", { err });
+      getTelemetryRuntime()?.reportError(err, { module: "catalog", code: "catalog.omnibus_settings_save_failed" });
+      setFormError(err instanceof Error && !err.message.startsWith("[internal]") ? err.message : saveErrorMessage);
+    } finally {
+      setSaving(false);
+    }
+  }, [buildPatch, canManage, mapServerFieldErrors, retryLastMutation, runMutation, saveErrorMessage, saving, scopeTenantId, t]);
+  const handleCancel = React.useCallback(() => {
+    setForm(toFormState(stored));
+    setFieldErrors({});
+    setFormError(null);
+    setBackfillChannels(null);
+  }, [stored]);
+  const handleKeyDown = React.useCallback(
+    (event) => {
+      if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
+        event.preventDefault();
+        void handleSubmit();
+        return;
+      }
+      if (event.key === "Escape" && !event.defaultPrevented && canManage) {
+        event.preventDefault();
+        handleCancel();
+      }
+    },
+    [canManage, handleCancel, handleSubmit]
+  );
+  const updateForm = React.useCallback((patch) => {
+    setForm((prev) => ({ ...prev, ...patch }));
+  }, []);
+  const updateChannel = React.useCallback((rowKey, patch) => {
+    setForm((prev) => ({
+      ...prev,
+      channels: prev.channels.map((row) => row.key === rowKey ? { ...row, ...patch } : row)
+    }));
+  }, []);
+  const addChannel = React.useCallback(() => {
+    setForm((prev) => ({
+      ...prev,
+      channels: [
+        ...prev.channels,
+        { key: nextRowKey(), channelId: "", presentedPriceKindId: "", countryCode: "", lookbackDays: "", minimizationAxis: "inherit" }
+      ]
+    }));
+  }, []);
+  const removeChannel = React.useCallback((rowKey) => {
+    setForm((prev) => ({ ...prev, channels: prev.channels.filter((row) => row.key !== rowKey) }));
+  }, []);
+  const formatChannel = React.useCallback(
+    (channelId) => backfillChannelNames[channelId] ? `${backfillChannelNames[channelId]} (${channelId})` : channelId,
+    [backfillChannelNames]
+  );
+  const formatScope = React.useCallback(
+    (scopeId) => scopeId ? formatChannel(scopeId) : t("catalog.omnibus.settings.backfill.globalScope", "All channels (unscoped)"),
+    [formatChannel, t]
+  );
+  if (!chromeReady) {
+    return /* @__PURE__ */ jsx(LoadingMessage, { label: t("catalog.omnibus.settings.loading", "Loading Omnibus settings\u2026") });
+  }
+  if (!canView) return null;
+  const noChannelModeLabels = {
+    best_effort: t("catalog.omnibus.settings.noChannelMode.bestEffort", "Best effort (use global settings)"),
+    require_channel: t("catalog.omnibus.settings.noChannelMode.requireChannel", "Require a channel")
+  };
+  const axisLabels = {
+    gross: t("catalog.omnibus.settings.axis.gross", "Gross (B2C)"),
+    net: t("catalog.omnibus.settings.axis.net", "Net (B2B)")
+  };
+  return /* @__PURE__ */ jsxs("section", { className: "border bg-card text-card-foreground shadow-sm", "data-testid": "catalog-omnibus-settings", children: [
+    /* @__PURE__ */ jsxs("div", { className: "border-b px-6 py-4 space-y-1", children: [
+      /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold", children: t("catalog.omnibus.settings.title", "Omnibus price tracking") }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: t(
+        "catalog.omnibus.settings.description",
+        "Show the lowest price from the lookback period next to announced price reductions (EU Directive 2019/2161)."
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "px-6 py-4", children: loading ? /* @__PURE__ */ jsx(LoadingMessage, { label: t("catalog.omnibus.settings.loading", "Loading Omnibus settings\u2026") }) : loadError ? /* @__PURE__ */ jsx(
+      ErrorMessage,
+      {
+        label: loadError,
+        action: /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", size: "sm", onClick: () => setReloadToken((token) => token + 1), children: t("catalog.omnibus.settings.actions.retry", "Retry") })
+      }
+    ) : /* @__PURE__ */ jsxs(
+      "form",
+      {
+        className: "space-y-6",
+        noValidate: true,
+        onKeyDown: handleKeyDown,
+        onSubmit: (event) => {
+          event.preventDefault();
+          void handleSubmit();
+        },
+        children: [
+          !canManage ? /* @__PURE__ */ jsx(Alert, { status: "information", children: /* @__PURE__ */ jsx(AlertDescription, { children: t("catalog.omnibus.settings.readOnly", "You can view these settings but not change them.") }) }) : null,
+          backfillChannels ? /* @__PURE__ */ jsxs(Alert, { status: "error", "data-testid": "catalog-omnibus-backfill-required", children: [
+            /* @__PURE__ */ jsx(AlertTitle, { children: t("catalog.omnibus.settings.backfill.requiredTitle", "Backfill required before enabling") }),
+            /* @__PURE__ */ jsxs(AlertDescription, { children: [
+              /* @__PURE__ */ jsx("p", { children: t(
+                "catalog.omnibus.settings.backfill.requiredDescription",
+                'Price history must be backfilled for every in-scope EU channel before Omnibus can be enabled. Run "mercato catalog omnibus:backfill --tenant <tenantId>" (add "--channel-id <channelId>" per channel), then save again.'
+              ) }),
+              backfillChannels.length > 0 ? /* @__PURE__ */ jsx("p", { className: "mt-1", children: t("catalog.omnibus.settings.backfill.channels", "Channels without backfill: {{channels}}", {
+                channels: backfillChannels.map(formatChannel).join(", ")
+              }) }) : null
+            ] })
+          ] }) : null,
+          staleBackfillScopes.length > 0 ? /* @__PURE__ */ jsxs(Alert, { status: "warning", "data-testid": "catalog-omnibus-backfill-stale", children: [
+            /* @__PURE__ */ jsx(AlertTitle, { children: t("catalog.omnibus.settings.backfill.staleTitle", "Lookback increased since the last backfill") }),
+            /* @__PURE__ */ jsx(AlertDescription, { children: t(
+              "catalog.omnibus.settings.backfill.staleDescription",
+              "Re-run the backfill so the longer window has baseline history: {{scopes}}",
+              { scopes: staleBackfillScopes.map(formatScope).join(", ") }
+            ) })
+          ] }) : null,
+          formError ? /* @__PURE__ */ jsx(ErrorMessage, { label: formError }) : null,
+          /* @__PURE__ */ jsx(
+            SwitchField,
+            {
+              label: t("catalog.omnibus.settings.enabled", "Enable Omnibus reference prices"),
+              description: t(
+                "catalog.omnibus.settings.enabledDescription",
+                "When enabled, products in EU channels expose the lowest price from the lookback window."
+              ),
+              checked: form.enabled,
+              disabled: readOnly,
+              onCheckedChange: (next) => updateForm({ enabled: next })
+            }
+          ),
+          /* @__PURE__ */ jsxs("div", { className: "grid gap-4 md:grid-cols-2", children: [
+            /* @__PURE__ */ jsx(
+              FormField,
+              {
+                label: t("catalog.omnibus.settings.lookbackDays", "Lookback window (days)"),
+                description: t("catalog.omnibus.settings.lookbackDaysDescription", "Between 1 and 365 days. The directive requires at least 30."),
+                error: fieldErrors.lookbackDays,
+                required: true,
+                disabled: readOnly,
+                children: /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    type: "number",
+                    inputMode: "numeric",
+                    min: MIN_LOOKBACK_DAYS,
+                    max: MAX_LOOKBACK_DAYS,
+                    value: form.lookbackDays,
+                    onChange: (event) => updateForm({ lookbackDays: event.target.value }),
+                    "data-testid": "catalog-omnibus-lookback"
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              FormField,
+              {
+                label: t("catalog.omnibus.settings.enabledCountryCodes", "EU member states"),
+                description: t(
+                  "catalog.omnibus.settings.enabledCountryCodesDescription",
+                  "Two-letter ISO codes of the member states where Omnibus applies. Leave empty to disable it for every channel."
+                ),
+                error: fieldErrors.enabledCountryCodes,
+                disabled: readOnly,
+                children: /* @__PURE__ */ jsx(
+                  TagInput,
+                  {
+                    value: form.enabledCountryCodes,
+                    onChange: (next) => updateForm({ enabledCountryCodes: Array.from(new Set(next.map((code) => code.trim().toUpperCase()))) }),
+                    validate: (tag) => {
+                      const code = tag.trim().toUpperCase();
+                      if (code === "EU") return errorMessages.omnibus_country_code_eu_not_allowed;
+                      return COUNTRY_CODE_PATTERN.test(code) || errorMessages.omnibus_country_code_alpha2_required;
+                    },
+                    placeholder: t("catalog.omnibus.settings.enabledCountryCodesPlaceholder", "e.g. PL, DE"),
+                    "aria-label": t("catalog.omnibus.settings.enabledCountryCodes", "EU member states"),
+                    removeTagLabel: (tag) => t("catalog.omnibus.settings.removeCountry", "Remove {{code}}", { code: tag }),
+                    disabled: readOnly
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              FormField,
+              {
+                label: t("catalog.omnibus.settings.noChannelModeLabel", "Requests without a channel"),
+                error: fieldErrors.noChannelMode,
+                disabled: readOnly,
+                children: /* @__PURE__ */ jsxs(
+                  Select,
+                  {
+                    value: form.noChannelMode,
+                    onValueChange: (next) => updateForm({ noChannelMode: next }),
+                    disabled: readOnly,
+                    children: [
+                      /* @__PURE__ */ jsx(SelectTrigger, { children: /* @__PURE__ */ jsx(SelectValue, { children: noChannelModeLabels[form.noChannelMode] }) }),
+                      /* @__PURE__ */ jsx(SelectContent, { children: Object.keys(noChannelModeLabels).map((mode) => /* @__PURE__ */ jsx(SelectItem, { value: mode, children: noChannelModeLabels[mode] }, mode)) })
+                    ]
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              FormField,
+              {
+                label: t("catalog.omnibus.settings.minimizationAxis", "Compare prices by"),
+                error: fieldErrors.minimizationAxis,
+                disabled: readOnly,
+                children: /* @__PURE__ */ jsxs(
+                  Select,
+                  {
+                    value: form.minimizationAxis,
+                    onValueChange: (next) => updateForm({ minimizationAxis: next }),
+                    disabled: readOnly,
+                    children: [
+                      /* @__PURE__ */ jsx(SelectTrigger, { children: /* @__PURE__ */ jsx(SelectValue, { children: axisLabels[form.minimizationAxis] }) }),
+                      /* @__PURE__ */ jsx(SelectContent, { children: Object.keys(axisLabels).map((axis) => /* @__PURE__ */ jsx(SelectItem, { value: axis, children: axisLabels[axis] }, axis)) })
+                    ]
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              FormField,
+              {
+                label: t("catalog.omnibus.settings.defaultPresentedPriceKind", "Default presented price kind"),
+                description: t(
+                  "catalog.omnibus.settings.defaultPresentedPriceKindDescription",
+                  "The price kind shown to shoppers, used when a channel has no override. Required when Omnibus is enabled without channel overrides."
+                ),
+                error: fieldErrors.defaultPresentedPriceKindId,
+                disabled: readOnly,
+                className: "md:col-span-2",
+                children: /* @__PURE__ */ jsx(
+                  PricePriceKindSelect,
+                  {
+                    value: form.defaultPresentedPriceKindId,
+                    onChange: (next) => updateForm({ defaultPresentedPriceKindId: next }),
+                    disabled: readOnly,
+                    clearable: true
+                  }
+                )
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between gap-4", children: [
+              /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+                /* @__PURE__ */ jsx("h3", { className: "text-sm font-semibold", children: t("catalog.omnibus.settings.channels.title", "Channel overrides") }),
+                /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: t(
+                  "catalog.omnibus.settings.channels.description",
+                  "Map sales channels to a member state and override the presented price kind, lookback or comparison axis per channel."
+                ) })
+              ] }),
+              canManage ? /* @__PURE__ */ jsxs(Button, { type: "button", variant: "outline", size: "sm", onClick: addChannel, disabled: saving, children: [
+                /* @__PURE__ */ jsx(Plus, { className: "size-4", "aria-hidden": true }),
+                t("catalog.omnibus.settings.channels.add", "Add channel")
+              ] }) : null
+            ] }),
+            form.channels.length === 0 ? /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: t("catalog.omnibus.settings.channels.empty", "No channel overrides. Global settings apply to every channel.") }) : form.channels.map((row) => {
+              const rowError = (field) => fieldErrors[channelErrorKey(row.key, field)];
+              return /* @__PURE__ */ jsx("div", { className: "space-y-3 rounded-md border p-4", "data-testid": "catalog-omnibus-channel-row", children: /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between gap-2", children: [
+                /* @__PURE__ */ jsxs("div", { className: "grid flex-1 gap-4 md:grid-cols-2", children: [
+                  /* @__PURE__ */ jsx(
+                    FormField,
+                    {
+                      label: t("catalog.omnibus.settings.channels.channel", "Channel"),
+                      error: rowError("channelId"),
+                      disabled: readOnly,
+                      children: /* @__PURE__ */ jsx(
+                        PriceChannelSelect,
+                        {
+                          value: row.channelId,
+                          onChange: (next) => updateChannel(row.key, { channelId: next }),
+                          disabled: readOnly
+                        }
+                      )
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    FormField,
+                    {
+                      label: t("catalog.omnibus.settings.channels.presentedPriceKind", "Presented price kind"),
+                      error: rowError("presentedPriceKindId"),
+                      disabled: readOnly,
+                      children: /* @__PURE__ */ jsx(
+                        PricePriceKindSelect,
+                        {
+                          value: row.presentedPriceKindId,
+                          onChange: (next) => updateChannel(row.key, { presentedPriceKindId: next }),
+                          disabled: readOnly
+                        }
+                      )
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    FormField,
+                    {
+                      label: t("catalog.omnibus.settings.channels.countryCode", "Member state"),
+                      description: t("catalog.omnibus.settings.channels.countryCodeDescription", "Leave empty for non-EU channels."),
+                      error: rowError("countryCode"),
+                      disabled: readOnly,
+                      children: /* @__PURE__ */ jsx(
+                        Input,
+                        {
+                          value: row.countryCode,
+                          maxLength: 2,
+                          onChange: (event) => updateChannel(row.key, { countryCode: event.target.value.toUpperCase() }),
+                          placeholder: t("catalog.omnibus.settings.channels.countryCodePlaceholder", "e.g. PL")
+                        }
+                      )
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    FormField,
+                    {
+                      label: t("catalog.omnibus.settings.channels.lookbackDays", "Lookback override (days)"),
+                      description: t("catalog.omnibus.settings.channels.lookbackDaysDescription", "Leave empty to use the global window."),
+                      error: rowError("lookbackDays"),
+                      disabled: readOnly,
+                      children: /* @__PURE__ */ jsx(
+                        Input,
+                        {
+                          type: "number",
+                          inputMode: "numeric",
+                          min: MIN_LOOKBACK_DAYS,
+                          max: MAX_LOOKBACK_DAYS,
+                          value: row.lookbackDays,
+                          onChange: (event) => updateChannel(row.key, { lookbackDays: event.target.value })
+                        }
+                      )
+                    }
+                  ),
+                  /* @__PURE__ */ jsx(
+                    FormField,
+                    {
+                      label: t("catalog.omnibus.settings.channels.minimizationAxis", "Compare prices by"),
+                      error: rowError("minimizationAxis"),
+                      disabled: readOnly,
+                      children: /* @__PURE__ */ jsxs(
+                        Select,
+                        {
+                          value: row.minimizationAxis,
+                          onValueChange: (next) => updateChannel(row.key, { minimizationAxis: next }),
+                          disabled: readOnly,
+                          children: [
+                            /* @__PURE__ */ jsx(SelectTrigger, { children: /* @__PURE__ */ jsx(SelectValue, { children: row.minimizationAxis === "inherit" ? t("catalog.omnibus.settings.channels.axisInherit", "Use global setting") : axisLabels[row.minimizationAxis] }) }),
+                            /* @__PURE__ */ jsxs(SelectContent, { children: [
+                              /* @__PURE__ */ jsx(SelectItem, { value: "inherit", children: t("catalog.omnibus.settings.channels.axisInherit", "Use global setting") }),
+                              Object.keys(axisLabels).map((axis) => /* @__PURE__ */ jsx(SelectItem, { value: axis, children: axisLabels[axis] }, axis))
+                            ] })
+                          ]
+                        }
+                      )
+                    }
+                  )
+                ] }),
+                canManage ? /* @__PURE__ */ jsx(
+                  IconButton,
+                  {
+                    type: "button",
+                    variant: "ghost",
+                    size: "sm",
+                    "aria-label": t("catalog.omnibus.settings.channels.remove", "Remove channel override"),
+                    onClick: () => removeChannel(row.key),
+                    disabled: saving,
+                    children: /* @__PURE__ */ jsx(Trash2, { className: "size-4", "aria-hidden": true })
+                  }
+                ) : null
+              ] }) }, row.key);
+            })
+          ] }),
+          canManage ? /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-end gap-2", children: [
+            /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", onClick: handleCancel, disabled: saving, children: t("catalog.omnibus.settings.actions.cancel", "Cancel") }),
+            /* @__PURE__ */ jsx(Button, { type: "submit", disabled: saving, "data-testid": "catalog-omnibus-save", children: saving ? t("catalog.omnibus.settings.actions.saving", "Saving\u2026") : t("catalog.omnibus.settings.actions.save", "Save") })
+          ] }) : null
+        ]
+      }
+    ) })
+  ] });
+}
+export {
+  OmnibusSettings
+};
+//# sourceMappingURL=OmnibusSettings.js.map