@orion-studios/cms 0.5.0

package/dist/chunk-VPUODCNH.js

@@ -0,0 +1,448 @@
+// src/forms/validation.ts
+var MAJOR_EMAIL_PROVIDERS = [
+  "gmail.com",
+  "yahoo.com",
+  "outlook.com",
+  "hotmail.com",
+  "icloud.com",
+  "live.com",
+  "protonmail.com"
+];
+var KNOWN_GOOD_DOMAINS = /* @__PURE__ */ new Set([
+  ...MAJOR_EMAIL_PROVIDERS,
+  "aol.com",
+  "gmx.com",
+  "googlemail.com",
+  "hey.com",
+  "mac.com",
+  "mail.com",
+  "me.com",
+  "msn.com",
+  "pm.me",
+  "proton.me",
+  "ymail.com",
+  "zoho.com"
+]);
+var EXPLICIT_TYPO_MAP = {
+  "gamil.com": "gmail.com",
+  "gmial.com": "gmail.com",
+  "gmai.com": "gmail.com",
+  "gmaill.com": "gmail.com",
+  "gmail.co": "gmail.com",
+  "gmail.con": "gmail.com",
+  "gmail.cmo": "gmail.com",
+  "hotmial.com": "hotmail.com",
+  "hotmall.com": "hotmail.com",
+  "hotmail.co": "hotmail.com",
+  "hotmail.con": "hotmail.com",
+  "iclod.com": "icloud.com",
+  "icloud.co": "icloud.com",
+  "icoud.com": "icloud.com",
+  "outlok.com": "outlook.com",
+  "outloook.com": "outlook.com",
+  "outlook.co": "outlook.com",
+  "outlook.con": "outlook.com",
+  "protonmail.co": "protonmail.com",
+  "yaho.com": "yahoo.com",
+  "yahooo.com": "yahoo.com",
+  "yahoo.co": "yahoo.com",
+  "yahoo.con": "yahoo.com"
+};
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  const rows = a.length + 1;
+  const cols = b.length + 1;
+  const dist = Array.from({ length: cols }, (_, j) => j);
+  for (let i = 1; i < rows; i += 1) {
+    let prevDiagonal = dist[0];
+    dist[0] = i;
+    for (let j = 1; j < cols; j += 1) {
+      const temp = dist[j];
+      dist[j] = Math.min(
+        dist[j] + 1,
+        dist[j - 1] + 1,
+        prevDiagonal + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+      prevDiagonal = temp;
+    }
+  }
+  return dist[cols - 1];
+}
+function normalizeEmail(value) {
+  return value.trim().toLowerCase();
+}
+function validateEmail(value, options = {}) {
+  const normalized = normalizeEmail(value);
+  if (normalized.length === 0) {
+    return { valid: false, normalized, message: "Email is required." };
+  }
+  if (!EMAIL_PATTERN.test(normalized)) {
+    return { valid: false, normalized, message: "Enter a valid email address." };
+  }
+  const [localPart, domain] = normalized.split("@");
+  const knownGood = options.knownGoodDomains ? /* @__PURE__ */ new Set([...KNOWN_GOOD_DOMAINS, ...options.knownGoodDomains.map((entry) => entry.toLowerCase())]) : KNOWN_GOOD_DOMAINS;
+  if (knownGood.has(domain)) {
+    return { valid: true, normalized };
+  }
+  const explicitCorrection = EXPLICIT_TYPO_MAP[domain];
+  if (explicitCorrection) {
+    const suggestion = `${localPart}@${explicitCorrection}`;
+    return {
+      valid: false,
+      normalized,
+      message: `Did you mean ${suggestion}?`,
+      suggestion
+    };
+  }
+  for (const provider of MAJOR_EMAIL_PROVIDERS) {
+    if (levenshtein(domain, provider) === 1) {
+      const suggestion = `${localPart}@${provider}`;
+      return {
+        valid: false,
+        normalized,
+        message: `Did you mean ${suggestion}?`,
+        suggestion
+      };
+    }
+  }
+  return { valid: true, normalized };
+}
+function normalizePhone(value) {
+  const digits = value.replace(/\D+/g, "");
+  if (digits.length === 11 && digits.startsWith("1")) {
+    return digits.slice(1);
+  }
+  return digits;
+}
+function formatPhoneUS(value) {
+  const digits = normalizePhone(value).slice(0, 10);
+  if (digits.length === 0) return "";
+  if (digits.length < 4) return `(${digits}`;
+  if (digits.length < 7) return `(${digits.slice(0, 3)}) ${digits.slice(3)}`;
+  return `(${digits.slice(0, 3)}) ${digits.slice(3, 6)}-${digits.slice(6)}`;
+}
+function validatePhoneUS(value) {
+  const digits = normalizePhone(value);
+  if (digits.length === 0) {
+    return { valid: false, normalized: "", message: "Phone number is required." };
+  }
+  if (digits.length !== 10) {
+    return { valid: false, normalized: digits, message: "Enter a 10-digit phone number." };
+  }
+  return { valid: true, normalized: digits };
+}
+function normalizeUrl(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return "";
+  if (/^https?:\/\//i.test(trimmed)) return trimmed;
+  return `https://${trimmed}`;
+}
+function validateUrl(value) {
+  const normalized = normalizeUrl(value);
+  if (normalized.length === 0) {
+    return { valid: false, normalized, message: "URL is required." };
+  }
+  try {
+    const parsed = new URL(normalized);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+      return { valid: false, normalized, message: "Enter a valid web address." };
+    }
+    if (!parsed.hostname.includes(".")) {
+      return { valid: false, normalized, message: "Enter a valid web address." };
+    }
+    return { valid: true, normalized };
+  } catch {
+    return { valid: false, normalized, message: "Enter a valid web address." };
+  }
+}
+function validateRequired(value, label = "This field") {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  const present = typeof value === "string" ? normalized.length > 0 : Array.isArray(value) ? value.length > 0 : value !== null && value !== void 0 && value !== false;
+  if (!present) {
+    return { valid: false, normalized, message: `${label} is required.` };
+  }
+  return { valid: true, normalized: typeof value === "string" ? normalized : String(value) };
+}
+var FORM_FIELD_TYPES = [
+  "text",
+  "textarea",
+  "email",
+  "phone",
+  "url",
+  "select",
+  "radio",
+  "checkbox",
+  "date",
+  "number",
+  "hidden"
+];
+function normalizeFieldValue(value, fieldType) {
+  switch (fieldType) {
+    case "email":
+      return normalizeEmail(value);
+    case "phone":
+      return normalizePhone(value);
+    case "url":
+      return normalizeUrl(value);
+    default:
+      return value.trim();
+  }
+}
+function validateDate(value) {
+  const normalized = value.trim();
+  if (normalized.length === 0) {
+    return { valid: false, normalized, message: "Date is required." };
+  }
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(normalized) || Number.isNaN(Date.parse(normalized))) {
+    return { valid: false, normalized, message: "Enter a valid date." };
+  }
+  return { valid: true, normalized };
+}
+function validateNumber(value) {
+  const normalized = value.trim().replace(/,/g, "");
+  if (normalized.length === 0) {
+    return { valid: false, normalized, message: "A number is required." };
+  }
+  const parsed = Number(normalized);
+  if (!Number.isFinite(parsed)) {
+    return { valid: false, normalized, message: "Enter a valid number." };
+  }
+  return { valid: true, normalized: String(parsed) };
+}
+function inferFieldType(field) {
+  const type = typeof field.type === "string" ? field.type.toLowerCase() : "";
+  if (type === "tel") return "phone";
+  if (FORM_FIELD_TYPES.includes(type)) return type;
+  const name = typeof field.name === "string" ? field.name.toLowerCase() : "";
+  if (name.includes("email")) return "email";
+  if (name.includes("phone") || name.includes("mobile")) return "phone";
+  if (name.includes("website") || name.endsWith("url")) return "url";
+  return "text";
+}
+function fieldOptions(field) {
+  if (!Array.isArray(field.options)) return [];
+  return field.options.map((option) => {
+    if (typeof option === "string") return { label: option, value: option };
+    if (option && typeof option === "object") {
+      const record = option;
+      const value = typeof record.value === "string" ? record.value : "";
+      const label = typeof record.label === "string" && record.label ? record.label : value;
+      return value ? { label, value } : null;
+    }
+    return null;
+  }).filter((option) => option !== null);
+}
+
+// src/forms/submission.ts
+var HONEYPOT_FIELD_NAME = "website_url_confirm";
+function createMemoryRateLimitStore(options) {
+  const max = options?.max ?? 5;
+  const windowMs = options?.windowMs ?? 6e4;
+  const hits = /* @__PURE__ */ new Map();
+  return {
+    isLimited(key, now) {
+      const windowStart = now - windowMs;
+      const entries = (hits.get(key) || []).filter((timestamp) => timestamp > windowStart);
+      entries.push(now);
+      hits.set(key, entries);
+      if (hits.size > 1e4) {
+        for (const [entryKey, timestamps] of hits) {
+          if (timestamps.every((timestamp) => timestamp <= windowStart)) {
+            hits.delete(entryKey);
+          }
+        }
+      }
+      return entries.length > max;
+    }
+  };
+}
+function collectFieldDefinitions(config) {
+  const definitions = [];
+  for (const step of config.steps || []) {
+    for (const field of step.fields || []) {
+      const name = typeof field.name === "string" ? field.name.trim() : "";
+      if (!name) continue;
+      definitions.push({
+        name,
+        type: inferFieldType(field),
+        required: field.required === true,
+        label: typeof field.label === "string" && field.label.length > 0 ? field.label : name,
+        options: fieldOptions(field)
+      });
+    }
+  }
+  return definitions;
+}
+var MAX_UNKNOWN_FIELDS = 20;
+var MAX_VALUE_LENGTH = 5e3;
+function validateChoice(definition, rawValue) {
+  const allowed = new Set(definition.options.map((option) => option.value));
+  if (Array.isArray(rawValue)) {
+    const values = rawValue.filter((entry) => typeof entry === "string");
+    if (allowed.size > 0 && values.some((entry) => !allowed.has(entry))) {
+      return { ok: false, message: `Choose a valid option for ${definition.label}.` };
+    }
+    return { ok: true, value: values };
+  }
+  if (typeof rawValue === "string") {
+    const value = rawValue.trim();
+    if (allowed.size > 0 && value.length > 0 && !allowed.has(value)) {
+      return { ok: false, message: `Choose a valid option for ${definition.label}.` };
+    }
+    return { ok: true, value };
+  }
+  return { ok: true, value: rawValue };
+}
+function processSubmission(args) {
+  const {
+    config,
+    data,
+    now = Date.now(),
+    minFillTimeMs = 3e3,
+    honeypotFieldName = HONEYPOT_FIELD_NAME,
+    knownGoodEmailDomains
+  } = args;
+  const honeypotValue = data[honeypotFieldName];
+  if (typeof honeypotValue === "string" && honeypotValue.trim().length > 0) {
+    return { outcome: "spam" };
+  }
+  if (minFillTimeMs > 0) {
+    const renderedAt = Number(data._renderedAt);
+    if (Number.isFinite(renderedAt) && renderedAt > 0 && now - renderedAt < minFillTimeMs) {
+      return { outcome: "spam" };
+    }
+  }
+  const definitions = collectFieldDefinitions(config);
+  const normalizedData = {};
+  const fieldErrors = {};
+  const knownNames = new Set(definitions.map((definition) => definition.name));
+  for (const definition of definitions) {
+    const rawValue = data[definition.name];
+    const isString = typeof rawValue === "string";
+    const normalized = isString ? normalizeFieldValue(rawValue.slice(0, MAX_VALUE_LENGTH), definition.type) : "";
+    const missing = rawValue === void 0 || rawValue === null || rawValue === false || isString && normalized.length === 0 || Array.isArray(rawValue) && rawValue.length === 0;
+    if (definition.required && missing) {
+      fieldErrors[definition.name] = `${definition.label} is required.`;
+      continue;
+    }
+    if (definition.type === "select" || definition.type === "radio" || definition.type === "checkbox" && definition.options.length > 0) {
+      if (missing) continue;
+      const choice = validateChoice(definition, rawValue);
+      if (!choice.ok) {
+        fieldErrors[definition.name] = choice.message || "Choose a valid option.";
+        continue;
+      }
+      normalizedData[definition.name] = choice.value;
+      continue;
+    }
+    if (definition.type === "checkbox") {
+      if (rawValue !== void 0 && rawValue !== null) {
+        normalizedData[definition.name] = rawValue === true || rawValue === "true" || rawValue === "on" || rawValue === "yes";
+      }
+      continue;
+    }
+    if (normalized.length > 0) {
+      if (definition.type === "email") {
+        const result = validateEmail(normalized, { knownGoodDomains: knownGoodEmailDomains });
+        if (!result.valid) {
+          fieldErrors[definition.name] = result.message || "Enter a valid email address.";
+          continue;
+        }
+        normalizedData[definition.name] = result.normalized;
+        continue;
+      }
+      if (definition.type === "phone") {
+        const result = validatePhoneUS(normalized);
+        if (!result.valid) {
+          fieldErrors[definition.name] = result.message || "Enter a valid phone number.";
+          continue;
+        }
+        normalizedData[definition.name] = result.normalized;
+        continue;
+      }
+      if (definition.type === "url") {
+        const result = validateUrl(normalized);
+        if (!result.valid) {
+          fieldErrors[definition.name] = result.message || "Enter a valid web address.";
+          continue;
+        }
+        normalizedData[definition.name] = result.normalized;
+        continue;
+      }
+      if (definition.type === "date") {
+        const result = validateDate(normalized);
+        if (!result.valid) {
+          fieldErrors[definition.name] = result.message || "Enter a valid date.";
+          continue;
+        }
+        normalizedData[definition.name] = result.normalized;
+        continue;
+      }
+      if (definition.type === "number") {
+        const result = validateNumber(normalized);
+        if (!result.valid) {
+          fieldErrors[definition.name] = result.message || "Enter a valid number.";
+          continue;
+        }
+        normalizedData[definition.name] = result.normalized;
+        continue;
+      }
+    }
+    if (rawValue !== void 0 && rawValue !== null) {
+      normalizedData[definition.name] = isString ? normalized : rawValue;
+    }
+  }
+  let unknownCount = 0;
+  for (const [key, value] of Object.entries(data)) {
+    if (knownNames.has(key) || key === honeypotFieldName || key.startsWith("_")) continue;
+    if (unknownCount >= MAX_UNKNOWN_FIELDS) break;
+    unknownCount += 1;
+    normalizedData[key] = typeof value === "string" ? value.trim().slice(0, MAX_VALUE_LENGTH) : value;
+  }
+  if (Object.keys(fieldErrors).length > 0) {
+    return { outcome: "invalid", fieldErrors };
+  }
+  return { outcome: "ok", normalizedData };
+}
+function isOriginAllowed(request, allowedOrigins) {
+  const origin = request.headers.get("origin");
+  if (!origin) return false;
+  if (allowedOrigins && allowedOrigins.length > 0) {
+    return allowedOrigins.includes(origin);
+  }
+  const host = request.headers.get("x-forwarded-host") || request.headers.get("host") || (() => {
+    try {
+      return new URL(request.url).host;
+    } catch {
+      return "";
+    }
+  })();
+  if (!host) return false;
+  try {
+    return new URL(origin).host === host;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  normalizeEmail,
+  validateEmail,
+  normalizePhone,
+  formatPhoneUS,
+  validatePhoneUS,
+  normalizeUrl,
+  validateUrl,
+  validateRequired,
+  FORM_FIELD_TYPES,
+  normalizeFieldValue,
+  validateDate,
+  validateNumber,
+  inferFieldType,
+  fieldOptions,
+  HONEYPOT_FIELD_NAME,
+  createMemoryRateLimitStore,
+  processSubmission,
+  isOriginAllowed
+};