@vicacha-devs/strapi-plugin-inbox 0.0.0-stage → 1.0.0

package/dist/shared/index.mjs

@@ -0,0 +1,917 @@
+const PLUGIN_ID = "inbox";
+const FORM_BUILDER_CMS_PLUGIN_ID = "strapi-plugin-form-builder-cms";
+const FORM_BUILDER_CMS_FORM_UID = `plugin::${FORM_BUILDER_CMS_PLUGIN_ID}.form`;
+const FORM_BUILDER_CMS_SUBMISSION_UID = `plugin::${FORM_BUILDER_CMS_PLUGIN_ID}.form-submission`;
+const FORM_UID = FORM_BUILDER_CMS_FORM_UID;
+const SUBMISSION_UID = `plugin::${PLUGIN_ID}.submission`;
+const SUBSCRIBER_UID = `plugin::${PLUGIN_ID}.subscriber`;
+const ALERT_BANNER_UID = `plugin::${PLUGIN_ID}.alert-banner`;
+const DECORATIVE_FIELD_TYPES = [
+  "heading",
+  "paragraph",
+  "divider"
+];
+const FORM_FIELD_TYPES = [
+  "text",
+  "email",
+  "number",
+  "phone",
+  "url",
+  "password",
+  "date",
+  "time",
+  "textarea",
+  "select",
+  "radio",
+  "checkbox",
+  "checkbox-group",
+  "file",
+  "hidden",
+  "heading",
+  "paragraph",
+  "divider"
+];
+const FORM_CATEGORIES = [
+  "contact",
+  "service_desk",
+  "inquiry",
+  "application",
+  "volunteer",
+  "custom"
+];
+const SUBMISSION_STATUSES = [
+  "new",
+  "read",
+  "under_review",
+  "scheduled",
+  "completed",
+  "rejected",
+  "archived"
+];
+const SUBMISSION_PRIORITIES = [
+  "low",
+  "normal",
+  "high",
+  "urgent"
+];
+const SUBSCRIBER_STATUSES = [
+  "pending",
+  "confirmed",
+  "unsubscribed"
+];
+const ALERT_SEVERITIES = [
+  "info",
+  "warning",
+  "urgent",
+  "celebration"
+];
+const CAPTCHA_PROVIDERS = [
+  "none",
+  "turnstile",
+  "recaptcha"
+];
+const CAPTCHA_ENDPOINTS = {
+  turnstile: "https://challenges.cloudflare.com/turnstile/v0/siteverify",
+  recaptcha: "https://www.google.com/recaptcha/api/siteverify"
+};
+const DEFAULT_INBOX_SETTINGS = {
+  primaryCalendar: "gregory",
+  secondaryCalendars: ["islamic-umalqura"],
+  defaultLocale: "es",
+  supportedLocales: ["es", "en", "ar"],
+  defaultRateLimitPerHour: 15,
+  defaultHoneypotField: "_website_url",
+  defaultCaptchaProvider: "none",
+  turnstileSiteKey: "",
+  turnstileSecretKey: "",
+  recaptchaSiteKey: "",
+  recaptchaSecretKey: "",
+  enableDoubleOptIn: true,
+  availableTopics: ["announcements", "events", "courses", "newsletter"],
+  availableDepartments: [
+    "general",
+    "administration",
+    "services",
+    "education",
+    "social_aid"
+  ],
+  enableFormBuilderBridge: true,
+  autoSyncFormBuilderForms: true,
+  enableBookingBridge: true,
+  enableCertificateBridge: true,
+  defaultNotifyEmails: [],
+  outboundWebhookUrl: ""
+};
+function isValidEmail(value) {
+  if (/\s/.test(value))
+    return false;
+  const at = value.indexOf("@");
+  if (at < 1 || at !== value.lastIndexOf("@"))
+    return false;
+  const domain = value.slice(at + 1);
+  const dot = domain.indexOf(".");
+  return dot > 0 && dot < domain.length - 1;
+}
+function freezeOptions(items) {
+  return Object.freeze(items.map((item) => Object.freeze({ ...item })));
+}
+freezeOptions([
+  { value: "es", label: "es — Español (Spanish)" },
+  { value: "en", label: "en — English" },
+  { value: "ar", label: "ar — العربية (Arabic)" },
+  { value: "tr", label: "tr — Türkçe (Turkish)" },
+  { value: "fr", label: "fr — Français (French)" },
+  { value: "de", label: "de — Deutsch (German)" },
+  { value: "pt", label: "pt — Português (Portuguese)" },
+  { value: "it", label: "it — Italiano (Italian)" },
+  { value: "nl", label: "nl — Nederlands (Dutch)" },
+  { value: "pl", label: "pl — Polski (Polish)" },
+  { value: "ru", label: "ru — Русский (Russian)" },
+  { value: "id", label: "id — Bahasa Indonesia" },
+  { value: "ur", label: "ur — اردو (Urdu)" },
+  { value: "zh", label: "zh — 中文 (Chinese)" }
+]);
+freezeOptions([
+  {
+    value: "islamic-umalqura",
+    label: "islamic-umalqura (Hijri Umm al-Qura)"
+  },
+  { value: "islamic-civil", label: "islamic-civil (Tabular Islamic Civil)" },
+  { value: "islamic-tbla", label: "islamic-tbla (Tabular Astronomical)" },
+  { value: "hebrew", label: "hebrew (Hebrew)" },
+  { value: "persian", label: "persian (Solar Hijri)" },
+  { value: "none", label: "none (Gregorian Only)" }
+]);
+const LOCALIZED_REQUIRED_FALLBACK = {
+  es: (label) => `${label} es obligatorio`,
+  en: (label) => `${label} is required`,
+  ar: (label) => `${label} مطلوب`
+};
+function isValueEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "boolean") return value === false;
+  return false;
+}
+function resolveRuleMessage(rule, locale, fallback) {
+  if (!rule) return fallback;
+  if (rule.localizedMessages && rule.localizedMessages[locale]) {
+    return rule.localizedMessages[locale];
+  }
+  if (rule.message) return rule.message;
+  return fallback;
+}
+function isValidHttpUrl(strVal) {
+  try {
+    const parsed = new URL(strVal);
+    return ["http:", "https:"].includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+function checkFieldOptions(field, rawValue, strVal, fieldLabel) {
+  if (!Array.isArray(field.options) || field.options.length === 0) return null;
+  const allowed = new Set(field.options.map((o) => o.value));
+  if (field.type === "select" || field.type === "radio") {
+    return allowed.has(strVal) ? null : `${fieldLabel} contains an invalid selection`;
+  }
+  if (field.type === "checkbox-group") {
+    const values = Array.isArray(rawValue) ? rawValue.map(String) : [strVal];
+    return values.some((v) => !allowed.has(v)) ? `${fieldLabel} contains an invalid selection` : null;
+  }
+  return null;
+}
+function validateFieldTypeAndOptions(field, rawValue, strVal, fieldLabel, locale, rules) {
+  const fieldErrors = [];
+  if (field.type === "email" && !isValidEmail(strVal)) {
+    const emailRule = rules.find((r) => r.type === "email");
+    fieldErrors.push(
+      resolveRuleMessage(
+        emailRule,
+        locale,
+        `${fieldLabel} must be a valid email address`
+      )
+    );
+  }
+  if (field.type === "url" && !isValidHttpUrl(strVal)) {
+    const urlRule = rules.find((r) => r.type === "url");
+    fieldErrors.push(
+      resolveRuleMessage(urlRule, locale, `${fieldLabel} must be a valid URL`)
+    );
+  }
+  const optError = checkFieldOptions(field, rawValue, strVal, fieldLabel);
+  if (optError) fieldErrors.push(optError);
+  return fieldErrors;
+}
+function checkLengthRule(rule, limit, strVal, fieldLabel, locale) {
+  if (rule.type === "minLength" && strVal.length < limit) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be at least ${limit} characters`
+    );
+  }
+  if (rule.type === "maxLength" && strVal.length > limit) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be at most ${limit} characters`
+    );
+  }
+  return null;
+}
+function checkNumericBoundRule(rule, limit, rawValue, fieldLabel, locale) {
+  const num = Number(rawValue);
+  if (rule.type === "min" && (Number.isNaN(num) || num < limit)) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be at least ${limit}`
+    );
+  }
+  if (rule.type === "max" && (Number.isNaN(num) || num > limit)) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be at most ${limit}`
+    );
+  }
+  return null;
+}
+function checkLengthOrNumberRule(rule, rawValue, strVal, fieldLabel, locale) {
+  if (typeof rule.value !== "number") return null;
+  return checkLengthRule(rule, rule.value, strVal, fieldLabel, locale) ?? checkNumericBoundRule(rule, rule.value, rawValue, fieldLabel, locale);
+}
+function checkPatternOrEmailRule(rule, fieldType, strVal, fieldLabel, locale) {
+  if (rule.type === "pattern" && typeof rule.value === "string") {
+    try {
+      const regex = new RegExp(rule.value);
+      if (!regex.test(strVal)) {
+        return resolveRuleMessage(
+          rule,
+          locale,
+          `${fieldLabel} format is invalid`
+        );
+      }
+    } catch {
+    }
+  }
+  if (rule.type === "email" && fieldType !== "email" && !isValidEmail(strVal)) {
+    return resolveRuleMessage(
+      rule,
+      locale,
+      `${fieldLabel} must be a valid email address`
+    );
+  }
+  return null;
+}
+function evaluateCustomRules(field, rawValue, strVal, fieldLabel, locale, rules) {
+  const errors = [];
+  for (const rule of rules) {
+    if (rule.type === "required") continue;
+    const lenOrNumErr = checkLengthOrNumberRule(
+      rule,
+      rawValue,
+      strVal,
+      fieldLabel,
+      locale
+    );
+    if (lenOrNumErr) errors.push(lenOrNumErr);
+    const patOrEmailErr = checkPatternOrEmailRule(
+      rule,
+      field.type,
+      strVal,
+      fieldLabel,
+      locale
+    );
+    if (patOrEmailErr) errors.push(patOrEmailErr);
+  }
+  return errors;
+}
+function resolveFieldLabel(field, locale) {
+  return field.localizedLabels?.[locale] || field.label || field.name;
+}
+function buildRequiredError(rules, locale, fieldLabel) {
+  const reqRule = rules.find((r) => r.type === "required");
+  const fallbackFn = LOCALIZED_REQUIRED_FALLBACK[locale] || LOCALIZED_REQUIRED_FALLBACK.en;
+  return resolveRuleMessage(reqRule, locale, fallbackFn(fieldLabel));
+}
+function validateSingleField(field, data, locale) {
+  const rawValue = data[field.name] ?? field.defaultValue;
+  const fieldLabel = resolveFieldLabel(field, locale);
+  const rules = field.validation || [];
+  if (field.required && isValueEmpty(rawValue)) {
+    return {
+      fieldErrors: [buildRequiredError(rules, locale, fieldLabel)],
+      cleanedValue: null
+    };
+  }
+  if (isValueEmpty(rawValue)) {
+    return { fieldErrors: [], cleanedValue: rawValue ?? null };
+  }
+  const strVal = typeof rawValue === "string" ? rawValue.trim() : String(rawValue);
+  const fieldErrors = [
+    ...validateFieldTypeAndOptions(
+      field,
+      rawValue,
+      strVal,
+      fieldLabel,
+      locale,
+      rules
+    ),
+    ...evaluateCustomRules(field, rawValue, strVal, fieldLabel, locale, rules)
+  ];
+  return {
+    fieldErrors,
+    cleanedValue: typeof rawValue === "string" ? strVal : rawValue
+  };
+}
+function validateFormSubmission(fields, data, locale = "en") {
+  const errors = {};
+  const cleanedData = {};
+  for (const field of fields) {
+    if (DECORATIVE_FIELD_TYPES.includes(field.type)) continue;
+    const { fieldErrors, cleanedValue } = validateSingleField(
+      field,
+      data,
+      locale
+    );
+    if (fieldErrors.length > 0) {
+      errors[field.name] = fieldErrors;
+    } else {
+      cleanedData[field.name] = cleanedValue;
+    }
+  }
+  return {
+    valid: Object.keys(errors).length === 0,
+    errors,
+    cleanedData
+  };
+}
+function isHoneypotTriggered(payload, honeypotField = "_website_url") {
+  if (!honeypotField) return false;
+  const val = payload[honeypotField];
+  return typeof val === "string" && val.trim().length > 0;
+}
+class SlidingWindowRateLimiter {
+  hits = /* @__PURE__ */ new Map();
+  check(ip, bucketKey, limitPerHour, nowMs = Date.now()) {
+    if (limitPerHour <= 0) {
+      return { allowed: true, remaining: 999, retryAfterSeconds: 0 };
+    }
+    const windowMs = 60 * 60 * 1e3;
+    const key = `${bucketKey}::${ip || "unknown"}`;
+    const cutoff = nowMs - windowMs;
+    const previous = (this.hits.get(key) || []).filter((ts) => ts > cutoff);
+    if (previous.length >= limitPerHour) {
+      const oldest = previous[0] ?? nowMs;
+      const retryAfterSeconds = Math.max(
+        1,
+        Math.ceil((oldest + windowMs - nowMs) / 1e3)
+      );
+      this.hits.set(key, previous);
+      return {
+        allowed: false,
+        remaining: 0,
+        retryAfterSeconds
+      };
+    }
+    previous.push(nowMs);
+    this.hits.set(key, previous);
+    return {
+      allowed: true,
+      remaining: Math.max(0, limitPerHour - previous.length),
+      retryAfterSeconds: 0
+    };
+  }
+  reset() {
+    this.hits.clear();
+  }
+}
+const defaultRateLimiter = new SlidingWindowRateLimiter();
+function resolveFetchRunner(fetchImpl) {
+  return fetchImpl ?? globalThis.fetch;
+}
+async function postCaptchaVerify(runner, url, params) {
+  try {
+    const res = await runner(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: params.toString()
+    });
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function verifyCaptchaToken(provider, secret, token, ip = "", fetchImpl) {
+  if (provider === "none") return true;
+  const url = CAPTCHA_ENDPOINTS[provider];
+  const trimmedSecret = (secret || "").trim();
+  const trimmedToken = (token || "").trim();
+  const runner = resolveFetchRunner(fetchImpl);
+  if (!url || !trimmedSecret || !trimmedToken || !runner) return false;
+  const params = new URLSearchParams({
+    secret: trimmedSecret,
+    response: trimmedToken
+  });
+  if (ip) params.append("remoteip", ip);
+  const json = await postCaptchaVerify(runner, url, params);
+  return Boolean(json?.success);
+}
+async function testCaptchaSecretKey(provider, secret, fetchImpl) {
+  if (provider === "none") return { ok: true };
+  const url = CAPTCHA_ENDPOINTS[provider];
+  if (!url) return { ok: false, reason: "Unknown CAPTCHA provider" };
+  const trimmedSecret = (secret || "").trim();
+  if (!trimmedSecret) return { ok: false, reason: "Secret key is empty" };
+  const runner = resolveFetchRunner(fetchImpl);
+  if (!runner) return { ok: false, reason: "Fetch implementation unavailable" };
+  const params = new URLSearchParams({
+    secret: trimmedSecret,
+    response: "test-token"
+  });
+  const json = await postCaptchaVerify(runner, url, params);
+  if (!json) {
+    return { ok: false, reason: "Could not reach the CAPTCHA provider" };
+  }
+  const codes = json["error-codes"] || [];
+  if (codes.includes("invalid-input-secret") || codes.includes("missing-input-secret")) {
+    return { ok: false, reason: "Secret key is invalid" };
+  }
+  return { ok: true };
+}
+const STARTER_FORM_TEMPLATES = [
+  {
+    id: "general-contact",
+    name: "General Contact & Inquiry",
+    description: "Multi-language contact form with subject routing and anti-spam protection.",
+    form: {
+      title: "General Contact",
+      slug: "general-contact",
+      description: "Send us a message and our team will respond promptly.",
+      category: "contact",
+      active: true,
+      publishedAt: "2026-01-01T00:00:00.000Z",
+      translations: {
+        es: {
+          title: "Contacto General",
+          description: "Envíanos un mensaje y nuestro equipo te responderá pronto.",
+          submitButtonLabel: "Enviar mensaje",
+          successMessage: "Gracias por contactarnos. Hemos recibido tu mensaje."
+        },
+        en: {
+          title: "General Contact",
+          description: "Send us a message and our team will respond promptly.",
+          submitButtonLabel: "Send message",
+          successMessage: "Thank you for reaching out. We have received your message."
+        },
+        ar: {
+          title: "الاتصال العام",
+          description: "أرسل لنا رسالة وسيرد فريقنا في أقرب وقت.",
+          submitButtonLabel: "إرسال الرسالة",
+          successMessage: "شكراً لتواصلك معنا. لقد استلمنا رسالتك."
+        }
+      },
+      fields: [
+        {
+          id: "fld_full_name",
+          type: "text",
+          name: "fullName",
+          label: "Full Name",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Nombre completo",
+            en: "Full Name",
+            ar: "الاسم الكامل"
+          },
+          validation: [{ type: "minLength", value: 2 }]
+        },
+        {
+          id: "fld_email",
+          type: "email",
+          name: "email",
+          label: "Email Address",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Correo electrónico",
+            en: "Email Address",
+            ar: "البريد الإلكتروني"
+          }
+        },
+        {
+          id: "fld_phone",
+          type: "phone",
+          name: "phone",
+          label: "Phone / WhatsApp",
+          required: false,
+          width: "half",
+          localizedLabels: {
+            es: "Teléfono / WhatsApp",
+            en: "Phone / WhatsApp",
+            ar: "الهاتف / واتساب"
+          }
+        },
+        {
+          id: "fld_subject",
+          type: "select",
+          name: "subject",
+          label: "Subject",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Asunto",
+            en: "Subject",
+            ar: "الموضوع"
+          },
+          options: [
+            {
+              value: "general",
+              label: "General Inquiry",
+              localizedLabels: {
+                es: "Consulta general",
+                en: "General Inquiry",
+                ar: "استفسار عام"
+              }
+            },
+            {
+              value: "visit",
+              label: "Guided Visit",
+              localizedLabels: {
+                es: "Visita guiada",
+                en: "Guided Visit",
+                ar: "زيارة إرشادية"
+              }
+            },
+            {
+              value: "support",
+              label: "Support & Assistance",
+              localizedLabels: {
+                es: "Apoyo y asistencia",
+                en: "Support & Assistance",
+                ar: "الدعم والمساعدة"
+              }
+            }
+          ]
+        },
+        {
+          id: "fld_message",
+          type: "textarea",
+          name: "message",
+          label: "Message",
+          required: true,
+          width: "full",
+          localizedLabels: {
+            es: "Mensaje",
+            en: "Message",
+            ar: "الرسالة"
+          },
+          validation: [
+            { type: "minLength", value: 10 },
+            { type: "maxLength", value: 2e3 }
+          ]
+        }
+      ],
+      settings: {
+        honeypotField: "_website_url",
+        rateLimitPerHour: 15,
+        captchaProvider: "none",
+        defaultPriority: "normal",
+        department: "general"
+      }
+    }
+  },
+  {
+    id: "service-desk-application",
+    name: "Service-Desk Casework & Document Checklist",
+    description: "Casework intake form with document verification checklist, booking bridge, and certificate bridge.",
+    form: {
+      title: "Formal Service Request",
+      slug: "service-request",
+      description: "Submit an official service application and required supporting documents.",
+      category: "service_desk",
+      active: true,
+      publishedAt: "2026-01-01T00:00:00.000Z",
+      translations: {
+        es: {
+          title: "Solicitud Formal de Servicio",
+          description: "Envía una solicitud oficial de servicio con los documentos requeridos.",
+          submitButtonLabel: "Radicar solicitud",
+          successMessage: "Tu solicitud ha sido radicada con éxito."
+        },
+        en: {
+          title: "Formal Service Request",
+          description: "Submit an official service application and required supporting documents.",
+          submitButtonLabel: "Submit application",
+          successMessage: "Your application has been registered."
+        },
+        ar: {
+          title: "طلب خدمة رسمي",
+          description: "قدم طلب خدمة رسمي مع المستندات المطلوبة.",
+          submitButtonLabel: "تقديم الطلب",
+          successMessage: "تم تسجيل طلبك بنجاح."
+        }
+      },
+      fields: [
+        {
+          id: "fld_applicant_name",
+          type: "text",
+          name: "applicantName",
+          label: "Applicant Full Name",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Nombre completo del solicitante",
+            en: "Applicant Full Name",
+            ar: "الاسم الكامل لمقدم الطلب"
+          }
+        },
+        {
+          id: "fld_applicant_email",
+          type: "email",
+          name: "applicantEmail",
+          label: "Applicant Email",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Correo del solicitante",
+            en: "Applicant Email",
+            ar: "البريد الإلكتروني لمقدم الطلب"
+          }
+        },
+        {
+          id: "fld_applicant_phone",
+          type: "phone",
+          name: "applicantPhone",
+          label: "Contact Phone",
+          required: true,
+          width: "half",
+          localizedLabels: {
+            es: "Teléfono de contacto",
+            en: "Contact Phone",
+            ar: "هاتف الاتصال"
+          }
+        },
+        {
+          id: "fld_preferred_date",
+          type: "date",
+          name: "preferredDate",
+          label: "Preferred Appointment Date",
+          required: false,
+          width: "half",
+          localizedLabels: {
+            es: "Fecha preferida de cita",
+            en: "Preferred Appointment Date",
+            ar: "تاريخ الموعد المفضل"
+          }
+        },
+        {
+          id: "fld_details",
+          type: "textarea",
+          name: "details",
+          label: "Case Details & Notes",
+          required: true,
+          width: "full",
+          localizedLabels: {
+            es: "Detalles del caso y observaciones",
+            en: "Case Details & Notes",
+            ar: "تفاصيل الطلب والملاحظات"
+          }
+        }
+      ],
+      checklistTemplate: [
+        {
+          id: "chk_id_document",
+          label: "Government ID / Passport Copy",
+          required: true,
+          verified: false,
+          localizedLabels: {
+            es: "Copia de documento de identidad / Pasaporte",
+            en: "Government ID / Passport Copy",
+            ar: "نسخة من بطاقة الهوية أو جواز السفر"
+          }
+        },
+        {
+          id: "chk_supporting_form",
+          label: "Signed Application Form",
+          required: true,
+          verified: false,
+          localizedLabels: {
+            es: "Formulario de solicitud firmado",
+            en: "Signed Application Form",
+            ar: "نموذج الطلب الموقع"
+          }
+        }
+      ],
+      settings: {
+        honeypotField: "_website_url",
+        rateLimitPerHour: 10,
+        captchaProvider: "none",
+        enableBookingBridge: true,
+        enableCertificateBridge: true,
+        defaultPriority: "normal",
+        department: "services"
+      }
+    }
+  }
+];
+function localizeFormForLocale(form, locale) {
+  const tr = form.translations?.[locale];
+  const localizedFields = (form.fields || []).map((field) => ({
+    ...field,
+    label: field.localizedLabels?.[locale] || field.label,
+    placeholder: field.localizedPlaceholders?.[locale] || field.placeholder,
+    helpText: field.localizedHelpTexts?.[locale] || field.helpText,
+    options: field.options?.map((opt) => ({
+      ...opt,
+      label: opt.localizedLabels?.[locale] || opt.label
+    }))
+  }));
+  const localizedChecklist = form.checklistTemplate?.map((item) => ({
+    ...item,
+    label: item.localizedLabels?.[locale] || item.label
+  }));
+  return {
+    ...form,
+    title: tr?.title || form.title,
+    description: tr?.description || form.description,
+    fields: localizedFields,
+    checklistTemplate: localizedChecklist,
+    settings: {
+      ...form.settings,
+      submitButtonLabel: tr?.submitButtonLabel || form.settings?.localizedSubmitLabels?.[locale] || form.settings?.submitButtonLabel,
+      successMessage: tr?.successMessage || form.settings?.localizedSuccessMessages?.[locale] || form.settings?.successMessage
+    }
+  };
+}
+const FORMULA_PREFIXES = ["=", "+", "-", "@", "	", "\r"];
+function escapeCsvCell(value) {
+  if (value === null || value === void 0) return "";
+  const raw = typeof value === "object" ? JSON.stringify(value) : String(value);
+  const sanitized = raw.length > 0 && FORMULA_PREFIXES.includes(raw[0]) ? `'${raw}` : raw;
+  if (sanitized.includes('"') || sanitized.includes(",") || sanitized.includes("\n") || sanitized.includes("\r")) {
+    return `"${sanitized.replace(/"/g, '""')}"`;
+  }
+  return sanitized;
+}
+function collectDataFieldNames(submissions, fields) {
+  const dataFieldNames = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (!DECORATIVE_FIELD_TYPES.includes(field.type) && !seen.has(field.name)) {
+      seen.add(field.name);
+      dataFieldNames.push(field.name);
+    }
+  }
+  for (const sub of submissions) {
+    for (const key of Object.keys(sub.data || {})) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        dataFieldNames.push(key);
+      }
+    }
+  }
+  return dataFieldNames;
+}
+function getBaseSubmissionValues(sub) {
+  return [
+    sub.referenceCode,
+    sub.formSlug,
+    sub.status,
+    sub.priority,
+    sub.department ?? "",
+    sub.locale,
+    sub.applicantName ?? "",
+    sub.applicantEmail ?? "",
+    sub.applicantPhone ?? "",
+    sub.submittedAt,
+    sub.secondaryDate?.formatted ?? "",
+    sub.linkedBookingId ?? "",
+    sub.linkedCertificateNumber ?? ""
+  ];
+}
+const BASE_CSV_HEADERS = [
+  "referenceCode",
+  "formSlug",
+  "status",
+  "priority",
+  "department",
+  "locale",
+  "applicantName",
+  "applicantEmail",
+  "applicantPhone",
+  "submittedAt",
+  "secondaryDate",
+  "linkedBookingId",
+  "linkedCertificateNumber"
+];
+function submissionsToCsv(submissions, fields = []) {
+  const dataFieldNames = collectDataFieldNames(submissions, fields);
+  const headers = [...BASE_CSV_HEADERS, ...dataFieldNames];
+  const rows = [headers.map(escapeCsvCell).join(",")];
+  for (const sub of submissions) {
+    const baseValues = getBaseSubmissionValues(sub);
+    const dynamicValues = dataFieldNames.map((name) => sub.data?.[name] ?? "");
+    rows.push([...baseValues, ...dynamicValues].map(escapeCsvCell).join(","));
+  }
+  return rows.join("\n");
+}
+const SUPPORTED_INTL_CALENDARS = [
+  { id: "gregory", intlCalendar: "gregory", defaultLabel: "Gregorian" },
+  { id: "iso8601", intlCalendar: "iso8601", defaultLabel: "ISO 8601" },
+  {
+    id: "islamic-umalqura",
+    intlCalendar: "islamic-umalqura",
+    defaultLabel: "Hijri (Umm al-Qura)"
+  },
+  {
+    id: "islamic-civil",
+    intlCalendar: "islamic-civil",
+    defaultLabel: "Hijri (Civil)"
+  },
+  {
+    id: "islamic-tbla",
+    intlCalendar: "islamic-tbla",
+    defaultLabel: "Hijri (Tabular)"
+  },
+  { id: "hebrew", intlCalendar: "hebrew", defaultLabel: "Hebrew" },
+  {
+    id: "persian",
+    intlCalendar: "persian",
+    defaultLabel: "Persian (Solar Hijri)"
+  },
+  { id: "buddhist", intlCalendar: "buddhist", defaultLabel: "Buddhist" },
+  { id: "japanese", intlCalendar: "japanese", defaultLabel: "Japanese" },
+  { id: "chinese", intlCalendar: "chinese", defaultLabel: "Chinese Lunar" },
+  { id: "indian", intlCalendar: "indian", defaultLabel: "Indian National" },
+  { id: "coptic", intlCalendar: "coptic", defaultLabel: "Coptic" },
+  { id: "ethiopic", intlCalendar: "ethiopic", defaultLabel: "Ethiopic" }
+];
+function convertIsoDateToCalendar(isoDateString, calendar = "islamic-umalqura", locale = "en") {
+  if (!isoDateString) {
+    return { calendar, formatted: "" };
+  }
+  const date = new Date(isoDateString);
+  if (Number.isNaN(date.getTime())) {
+    return { calendar, formatted: isoDateString };
+  }
+  try {
+    const formatter = new Intl.DateTimeFormat(`${locale}-u-ca-${calendar}`, {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+    const parts = formatter.formatToParts(date);
+    const year = Number(parts.find((p) => p.type === "year")?.value) || void 0;
+    const month = Number(parts.find((p) => p.type === "month")?.value) || void 0;
+    const day = Number(parts.find((p) => p.type === "day")?.value) || void 0;
+    return {
+      calendar,
+      formatted: formatter.format(date),
+      year,
+      month,
+      day
+    };
+  } catch {
+    return {
+      calendar,
+      formatted: date.toISOString().slice(0, 10)
+    };
+  }
+}
+export {
+  ALERT_BANNER_UID,
+  ALERT_SEVERITIES,
+  CAPTCHA_ENDPOINTS,
+  CAPTCHA_PROVIDERS,
+  DECORATIVE_FIELD_TYPES,
+  DEFAULT_INBOX_SETTINGS,
+  FORM_BUILDER_CMS_FORM_UID,
+  FORM_BUILDER_CMS_PLUGIN_ID,
+  FORM_BUILDER_CMS_SUBMISSION_UID,
+  FORM_CATEGORIES,
+  FORM_FIELD_TYPES,
+  FORM_UID,
+  PLUGIN_ID,
+  STARTER_FORM_TEMPLATES,
+  SUBMISSION_PRIORITIES,
+  SUBMISSION_STATUSES,
+  SUBMISSION_UID,
+  SUBSCRIBER_STATUSES,
+  SUBSCRIBER_UID,
+  SUPPORTED_INTL_CALENDARS,
+  SlidingWindowRateLimiter,
+  convertIsoDateToCalendar,
+  defaultRateLimiter,
+  escapeCsvCell,
+  isHoneypotTriggered,
+  isValueEmpty,
+  localizeFormForLocale,
+  submissionsToCsv,
+  testCaptchaSecretKey,
+  validateFormSubmission,
+  verifyCaptchaToken
+};