@delopay/sdk 0.74.0 → 0.75.0

package/dist/{chunk-5FA2IFIU.js → chunk-5J763YMV.js}

@@ -3911,7 +3911,11 @@ function cloneCustomField(f) {
     labelTranslations: { ...f.labelTranslations },
     placeholderTranslations: { ...f.placeholderTranslations },
     helpTextTranslations: { ...f.helpTextTranslations },
-    options: f.options.map((o) => ({ ...o, labelTranslations: { ...o.labelTranslations } }))
+    options: f.options.map((o) => ({ ...o, labelTranslations: { ...o.labelTranslations } })),
+    visibility: {
+      ...f.visibility,
+      conditions: f.visibility.conditions.map((c) => ({ ...c }))
+    }
   };
 }
 var CUSTOM_CSS_MAX_LENGTH = 5e4;
@@ -3999,6 +4003,46 @@ var ALL_CUSTOM_FIELD_TYPES = [
   "email",
   "select"
 ];
+var CUSTOM_FIELD_CONDITIONS_MAX = 10;
+var ALL_CUSTOM_FIELD_CONDITION_SOURCES = [
+  "metadata",
+  "currency",
+  "amount"
+];
+var ALL_CUSTOM_FIELD_OPERATORS = [
+  "equals",
+  "not_equals",
+  "contains",
+  "not_contains",
+  "starts_with",
+  "ends_with",
+  "in",
+  "not_in",
+  "exists",
+  "not_exists",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+];
+var CUSTOM_FIELD_OPERATORS_BY_SOURCE = {
+  metadata: ALL_CUSTOM_FIELD_OPERATORS,
+  currency: ["equals", "not_equals", "in", "not_in"],
+  amount: ["equals", "not_equals", "gt", "gte", "lt", "lte"]
+};
+var CUSTOM_FIELD_VALUELESS_OPERATORS = [
+  "exists",
+  "not_exists"
+];
+function customFieldOperatorTakesValue(operator) {
+  return !CUSTOM_FIELD_VALUELESS_OPERATORS.includes(operator);
+}
+function defaultOperatorForSource(source) {
+  return CUSTOM_FIELD_OPERATORS_BY_SOURCE[source][0] ?? "equals";
+}
+function defaultCustomFieldVisibility() {
+  return { mode: "always", match: "all", conditions: [] };
+}
 function parseTranslations(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
   const out = {};
@@ -4007,6 +4051,41 @@ function parseTranslations(raw) {
   }
   return out;
 }
+function normalizeCondition(raw, index) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const c = raw;
+  const source = pickEnum(
+    c["source"],
+    ALL_CUSTOM_FIELD_CONDITION_SOURCES,
+    "metadata"
+  );
+  const allowed = CUSTOM_FIELD_OPERATORS_BY_SOURCE[source];
+  const operator = pickEnum(
+    c["operator"],
+    allowed,
+    defaultOperatorForSource(source)
+  );
+  const rawValue = c["value"];
+  return {
+    id: typeof c["id"] === "string" && c["id"] ? c["id"] : `cond-${index}`,
+    source,
+    // Only metadata conditions carry a key; drop anything else so the
+    // encoded form stays canonical.
+    key: source === "metadata" && typeof c["key"] === "string" ? c["key"].trim() : "",
+    operator,
+    value: typeof rawValue === "string" ? rawValue : typeof rawValue === "number" || typeof rawValue === "boolean" ? String(rawValue) : ""
+  };
+}
+function normalizeVisibility(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return defaultCustomFieldVisibility();
+  const v = raw;
+  const conditions = Array.isArray(v["conditions"]) ? v["conditions"].slice(0, CUSTOM_FIELD_CONDITIONS_MAX).map(normalizeCondition).filter((c) => c !== null) : [];
+  return {
+    mode: pickEnum(v["mode"], ["always", "match"], "always"),
+    match: pickEnum(v["match"], ["all", "any"], "all"),
+    conditions
+  };
+}
 function parseBoundedInt(raw) {
   const n = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
   if (!Number.isInteger(n) || n < 0) return null;
@@ -4044,7 +4123,8 @@ function normalizeCustomField(raw, index) {
     // Guard inverted bounds at decode so consumers never see min > max.
     maxLength: maxLength !== null && minLength !== null && maxLength < minLength ? null : maxLength,
     defaultValue: typeof f["defaultValue"] === "string" ? f["defaultValue"] : "",
-    options
+    options,
+    visibility: normalizeVisibility(f["visibility"])
   };
 }
 function parseCustomFieldsLoose(raw) {
@@ -4088,10 +4168,118 @@ function encodeCustomFields(fields) {
       ...f.minLength !== null ? { minLength: f.minLength } : {},
       ...f.maxLength !== null ? { maxLength: f.maxLength } : {},
       ...f.defaultValue ? { defaultValue: f.defaultValue } : {},
-      ...f.type === "select" ? { options: f.options } : {}
+      ...f.type === "select" ? { options: f.options } : {},
+      // Omitted for unconditional fields so the stored blob (and every
+      // pre-feature payload) stays byte-identical to what it was.
+      ...f.visibility.mode === "match" ? { visibility: encodeVisibility(f.visibility) } : {}
     }))
   );
 }
+function encodeVisibility(v) {
+  return {
+    mode: v.mode,
+    match: v.match,
+    conditions: v.conditions.map((c) => ({
+      id: c.id,
+      source: c.source,
+      ...c.source === "metadata" && c.key ? { key: c.key } : {},
+      operator: c.operator,
+      ...customFieldOperatorTakesValue(c.operator) && c.value ? { value: c.value } : {}
+    }))
+  };
+}
+function customFieldContextFromMetadata(raw) {
+  const out = {};
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return out;
+  for (const [key, value] of Object.entries(raw)) {
+    const flat = flattenMetadataValue(value);
+    if (flat !== null) out[key] = flat;
+  }
+  return out;
+}
+function flattenMetadataValue(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (value === null || value === void 0) return null;
+  if (Array.isArray(value)) {
+    return value.map((v) => flattenMetadataValue(v)).filter((v) => v !== null).join(",");
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}
+function norm(value) {
+  return value.trim().toLowerCase();
+}
+var DECIMAL_NUMBER_PATTERN = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+function numeric(value) {
+  const trimmed = value.trim();
+  if (!DECIMAL_NUMBER_PATTERN.test(trimmed)) return null;
+  const n = Number(trimmed);
+  return Number.isFinite(n) ? n : null;
+}
+function splitList(value) {
+  return value.split(",").map((part) => norm(part)).filter((part) => part.length > 0);
+}
+function operandFor(condition, ctx) {
+  switch (condition.source) {
+    case "currency":
+      return ctx.currency;
+    case "amount":
+      return String(ctx.amount);
+    case "metadata":
+      return Object.prototype.hasOwnProperty.call(ctx.metadata, condition.key) ? ctx.metadata[condition.key] : void 0;
+  }
+}
+function evaluateCustomFieldCondition(condition, ctx) {
+  const raw = operandFor(condition, ctx);
+  const actual = raw ?? "";
+  const expected = condition.value;
+  switch (condition.operator) {
+    case "exists":
+      return raw !== void 0 && raw.trim().length > 0;
+    case "not_exists":
+      return raw === void 0 || raw.trim().length === 0;
+    case "equals":
+      return norm(actual) === norm(expected);
+    case "not_equals":
+      return norm(actual) !== norm(expected);
+    case "contains":
+      return norm(actual).includes(norm(expected));
+    case "not_contains":
+      return !norm(actual).includes(norm(expected));
+    case "starts_with":
+      return norm(actual).startsWith(norm(expected));
+    case "ends_with":
+      return norm(actual).endsWith(norm(expected));
+    case "in":
+      return splitList(expected).includes(norm(actual));
+    case "not_in":
+      return !splitList(expected).includes(norm(actual));
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const a = numeric(actual);
+      const b = numeric(expected);
+      if (a === null || b === null) return false;
+      if (condition.operator === "gt") return a > b;
+      if (condition.operator === "gte") return a >= b;
+      if (condition.operator === "lt") return a < b;
+      return a <= b;
+    }
+  }
+}
+function evaluateCustomFieldVisibility(field, ctx) {
+  const { mode, match, conditions } = field.visibility;
+  if (mode !== "match" || conditions.length === 0) return true;
+  return match === "any" ? conditions.some((c) => evaluateCustomFieldCondition(c, ctx)) : conditions.every((c) => evaluateCustomFieldCondition(c, ctx));
+}
+function visibleCustomFields(fields, ctx) {
+  return fields.filter((f) => f.enabled && evaluateCustomFieldVisibility(f, ctx));
+}
 function translationFor(map, locale) {
   if (!locale) return null;
   const own = (k) => {
@@ -4515,9 +4703,21 @@ export {
   CUSTOM_FIELDS_MAX,
   CUSTOM_FIELD_KEY_PATTERN,
   ALL_CUSTOM_FIELD_TYPES,
+  CUSTOM_FIELD_CONDITIONS_MAX,
+  ALL_CUSTOM_FIELD_CONDITION_SOURCES,
+  ALL_CUSTOM_FIELD_OPERATORS,
+  CUSTOM_FIELD_OPERATORS_BY_SOURCE,
+  CUSTOM_FIELD_VALUELESS_OPERATORS,
+  customFieldOperatorTakesValue,
+  defaultOperatorForSource,
+  defaultCustomFieldVisibility,
   parseCustomFieldsLoose,
   decodeCustomFields,
   encodeCustomFields,
+  customFieldContextFromMetadata,
+  evaluateCustomFieldCondition,
+  evaluateCustomFieldVisibility,
+  visibleCustomFields,
   customFieldText,
   customFieldOptionLabel,
   decodeBranding,
@@ -4529,4 +4729,4 @@ export {
   applyBrandingVariables,
   shadowFor
 };
-//# sourceMappingURL=chunk-5FA2IFIU.js.map
+//# sourceMappingURL=chunk-5J763YMV.js.map