@orion-studios/cms 0.5.0

package/dist/chunk-WQDHEQDE.js

@@ -0,0 +1,527 @@
+'use client';
+
+// src/forms/react.tsx
+import { useEffect, useMemo, useRef, useState } from "react";
+
+// 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." };
+  }
+}
+var FORM_FIELD_TYPES = [
+  "text",
+  "textarea",
+  "email",
+  "phone",
+  "url",
+  "select",
+  "radio",
+  "checkbox",
+  "date",
+  "number",
+  "hidden"
+];
+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";
+
+// src/forms/react.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var DEFAULT_CLASSES = {
+  form: "ocf-form",
+  field: "ocf-field",
+  fieldError: "has-error",
+  errorText: "ocf-error",
+  label: "ocf-label",
+  input: "ocf-input",
+  textarea: "ocf-input ocf-textarea",
+  select: "ocf-input",
+  checkbox: "ocf-checkbox",
+  radioGroup: "ocf-radio-group",
+  button: "ocf-button",
+  success: "ocf-success",
+  formError: "ocf-form-error",
+  stepTitle: "ocf-step-title"
+};
+var fieldKey = (field, index) => field.name || `field_${index}`;
+function FormRenderer({
+  slug,
+  config,
+  successMessage,
+  basePath = "/api/cms",
+  classNames,
+  title,
+  intro,
+  submitLabel = "Send",
+  preview = false,
+  onSuccess
+}) {
+  const cls = { ...DEFAULT_CLASSES, ...classNames };
+  const steps = useMemo(
+    () => (config.steps || []).filter((step) => (step.fields || []).length > 0),
+    [config]
+  );
+  const allFields = useMemo(() => steps.flatMap((step) => step.fields || []), [steps]);
+  const [values, setValues] = useState({});
+  const [errors, setErrors] = useState({});
+  const [stepIndex, setStepIndex] = useState(0);
+  const [state, setState] = useState("idle");
+  const [honeypot, setHoneypot] = useState("");
+  const renderedAt = useRef(Date.now());
+  const startedRef = useRef(false);
+  const funnel = (stage) => {
+    if (preview || typeof window === "undefined") return;
+    window.__orionTrack?.(
+      "form",
+      `${slug}:${stage}`
+    );
+  };
+  useEffect(() => {
+    const timer = setTimeout(() => funnel("view"), 100);
+    return () => clearTimeout(timer);
+  }, [slug]);
+  useEffect(() => {
+    setStepIndex((current) => Math.min(current, Math.max(steps.length - 1, 0)));
+  }, [steps.length]);
+  const setValue = (name, next, type) => {
+    if (!startedRef.current) {
+      startedRef.current = true;
+      funnel("start");
+    }
+    setValues((current) => ({
+      ...current,
+      [name]: type === "phone" && typeof next === "string" ? formatPhoneUS(next) : next
+    }));
+    setErrors((current) => current[name] ? { ...current, [name]: "" } : current);
+  };
+  const validateFields = (fields) => {
+    const nextErrors = {};
+    for (const [index, field] of fields.entries()) {
+      const name = fieldKey(field, index);
+      const type = inferFieldType(field);
+      const label = field.label || name;
+      const value = values[name];
+      const text = typeof value === "string" ? value.trim() : "";
+      const empty = value === void 0 || value === false || typeof value === "string" && text.length === 0 || Array.isArray(value) && value.length === 0;
+      if (field.required && empty) {
+        nextErrors[name] = `${label} is required.`;
+        continue;
+      }
+      if (empty) continue;
+      if (type === "email") {
+        const result = validateEmail(text);
+        if (!result.valid) nextErrors[name] = result.message || "Enter a valid email address.";
+      } else if (type === "phone") {
+        const result = validatePhoneUS(text);
+        if (!result.valid) nextErrors[name] = result.message || "Enter a valid phone number.";
+      } else if (type === "url") {
+        const result = validateUrl(text);
+        if (!result.valid) nextErrors[name] = result.message || "Enter a valid web address.";
+      } else if (type === "date") {
+        const result = validateDate(text);
+        if (!result.valid) nextErrors[name] = result.message || "Enter a valid date.";
+      } else if (type === "number") {
+        const result = validateNumber(text);
+        if (!result.valid) nextErrors[name] = result.message || "Enter a valid number.";
+      }
+    }
+    setErrors((current) => ({ ...current, ...nextErrors }));
+    return Object.values(nextErrors).every((message) => !message);
+  };
+  const submit = async (event) => {
+    event.preventDefault();
+    if (preview) return;
+    if (!validateFields(allFields)) return;
+    setState("submitting");
+    try {
+      const data = {
+        ...values,
+        [HONEYPOT_FIELD_NAME]: honeypot,
+        _renderedAt: renderedAt.current
+      };
+      const response = await fetch(`${basePath}/forms/${slug}/submit`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ data })
+      });
+      if (!response.ok) {
+        const body = await response.json().catch(() => ({}));
+        if (body.fieldErrors) setErrors(body.fieldErrors);
+        setState("error");
+        return;
+      }
+      setState("success");
+      funnel("submit");
+      onSuccess?.();
+    } catch {
+      setState("error");
+    }
+  };
+  const nextStep = () => {
+    const fields = steps[stepIndex]?.fields || [];
+    if (!validateFields(fields)) return;
+    setStepIndex((current) => Math.min(current + 1, steps.length - 1));
+  };
+  if (state === "success") {
+    return /* @__PURE__ */ jsxs("div", { className: cls.success, role: "status", children: [
+      /* @__PURE__ */ jsx("strong", { children: "\u2713" }),
+      " ",
+      successMessage || "Thanks \u2014 we received your submission."
+    ] });
+  }
+  const isLastStep = stepIndex >= steps.length - 1;
+  const visibleSteps = steps.length > 0 ? [steps[stepIndex]] : [];
+  const renderField = (field, index) => {
+    const name = fieldKey(field, index);
+    const type = inferFieldType(field);
+    const label = field.label || name;
+    const error = errors[name];
+    const options = fieldOptions(field);
+    const id = `ocf-${slug}-${name}`;
+    const value = values[name];
+    if (type === "hidden") return null;
+    const wrap = (control) => /* @__PURE__ */ jsxs("div", { className: `${cls.field}${error ? ` ${cls.fieldError}` : ""}`, children: [
+      type !== "checkbox" || options.length > 0 ? /* @__PURE__ */ jsxs("label", { className: cls.label, htmlFor: id, children: [
+        label,
+        field.required ? " *" : ""
+      ] }) : null,
+      control,
+      field.help ? /* @__PURE__ */ jsx("p", { className: "ocf-help", children: field.help }) : null,
+      error ? /* @__PURE__ */ jsx("p", { className: cls.errorText, role: "alert", children: error }) : null
+    ] }, name);
+    if (type === "textarea") {
+      return wrap(
+        /* @__PURE__ */ jsx(
+          "textarea",
+          {
+            className: cls.textarea,
+            id,
+            onChange: (event) => setValue(name, event.target.value, type),
+            placeholder: field.placeholder,
+            rows: 4,
+            value: typeof value === "string" ? value : ""
+          }
+        )
+      );
+    }
+    if (type === "select") {
+      return wrap(
+        /* @__PURE__ */ jsxs(
+          "select",
+          {
+            className: cls.select,
+            id,
+            onChange: (event) => setValue(name, event.target.value, type),
+            value: typeof value === "string" ? value : "",
+            children: [
+              /* @__PURE__ */ jsx("option", { value: "", children: field.placeholder || "Choose\u2026" }),
+              options.map((option) => /* @__PURE__ */ jsx("option", { value: option.value, children: option.label }, option.value))
+            ]
+          }
+        )
+      );
+    }
+    if (type === "radio") {
+      return wrap(
+        /* @__PURE__ */ jsx("div", { className: cls.radioGroup, role: "radiogroup", children: options.map((option) => /* @__PURE__ */ jsxs("label", { className: cls.checkbox, children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              checked: value === option.value,
+              name: id,
+              onChange: () => setValue(name, option.value, type),
+              type: "radio"
+            }
+          ),
+          option.label
+        ] }, option.value)) })
+      );
+    }
+    if (type === "checkbox" && options.length > 0) {
+      const selected = Array.isArray(value) ? value : [];
+      return wrap(
+        /* @__PURE__ */ jsx("div", { className: cls.radioGroup, children: options.map((option) => /* @__PURE__ */ jsxs("label", { className: cls.checkbox, children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              checked: selected.includes(option.value),
+              onChange: (event) => setValue(
+                name,
+                event.target.checked ? [...selected, option.value] : selected.filter((entry) => entry !== option.value),
+                type
+              ),
+              type: "checkbox"
+            }
+          ),
+          option.label
+        ] }, option.value)) })
+      );
+    }
+    if (type === "checkbox") {
+      return /* @__PURE__ */ jsxs("div", { className: `${cls.field}${error ? ` ${cls.fieldError}` : ""}`, children: [
+        /* @__PURE__ */ jsxs("label", { className: cls.checkbox, htmlFor: id, children: [
+          /* @__PURE__ */ jsx(
+            "input",
+            {
+              checked: value === true,
+              id,
+              onChange: (event) => setValue(name, event.target.checked, type),
+              type: "checkbox"
+            }
+          ),
+          label,
+          field.required ? " *" : ""
+        ] }),
+        error ? /* @__PURE__ */ jsx("p", { className: cls.errorText, role: "alert", children: error }) : null
+      ] }, name);
+    }
+    const inputType = type === "email" ? "email" : type === "date" ? "date" : type === "number" ? "text" : "text";
+    const inputMode = type === "phone" ? "tel" : type === "email" ? "email" : type === "number" ? "decimal" : void 0;
+    return wrap(
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          className: cls.input,
+          id,
+          inputMode,
+          onChange: (event) => setValue(name, event.target.value, type),
+          placeholder: field.placeholder,
+          type: inputType,
+          value: typeof value === "string" ? value : ""
+        }
+      )
+    );
+  };
+  return /* @__PURE__ */ jsxs("form", { className: cls.form, noValidate: true, onSubmit: submit, children: [
+    title,
+    intro,
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        "aria-hidden": "true",
+        autoComplete: "off",
+        className: "ocf-honeypot",
+        name: HONEYPOT_FIELD_NAME,
+        onChange: (event) => setHoneypot(event.target.value),
+        style: { position: "absolute", left: "-9999px", height: 0, width: 0, opacity: 0 },
+        tabIndex: -1,
+        value: honeypot
+      }
+    ),
+    steps.length > 1 ? /* @__PURE__ */ jsxs("p", { className: cls.stepTitle, children: [
+      "Step ",
+      stepIndex + 1,
+      " of ",
+      steps.length,
+      steps[stepIndex]?.title ? ` \u2014 ${steps[stepIndex].title}` : ""
+    ] }) : null,
+    visibleSteps.map((step) => (step.fields || []).map(renderField)),
+    state === "error" ? /* @__PURE__ */ jsx("p", { className: cls.formError, role: "alert", children: "The request could not be sent. Please try again." }) : null,
+    /* @__PURE__ */ jsxs("div", { className: "ocf-actions", children: [
+      steps.length > 1 && stepIndex > 0 ? /* @__PURE__ */ jsx("button", { className: cls.button, onClick: () => setStepIndex(stepIndex - 1), type: "button", children: "Back" }) : null,
+      !isLastStep ? /* @__PURE__ */ jsx("button", { className: cls.button, onClick: nextStep, type: "button", children: "Next" }) : /* @__PURE__ */ jsx("button", { className: cls.button, disabled: state === "submitting" || preview, type: "submit", children: state === "submitting" ? "Sending\u2026" : submitLabel })
+    ] })
+  ] });
+}
+
+export {
+  FORM_FIELD_TYPES,
+  FormRenderer
+};

package/dist/content/index.d.ts

@@ -0,0 +1,51 @@
+import { PageLayout } from '../blocks/index.js';
+import 'react';
+import 'zod';
+
+/** Cache tag for published content. Frontends tag their reads with it so the
+ *  API's revalidateContent() invalidates them on publish/sync. */
+declare const CONTENT_CACHE_TAG = "orion-content";
+/**
+ * Public read layer for site frontends. Uses the anon key — RLS restricts
+ * anonymous access to published content only, so this client is safe in any
+ * server component. Wrap calls in your framework's cache (the site template
+ * ships with this pre-wired using CONTENT_CACHE_TAG revalidation).
+ */
+type PublicPage = {
+    id: string;
+    slug: string;
+    path: string;
+    title: string;
+    seo: Record<string, unknown>;
+    layout: PageLayout;
+};
+type ContentClientOptions = {
+    supabaseUrl?: string;
+    anonKey?: string;
+};
+type ContentClient = {
+    getPageByPath(path: string): Promise<PublicPage | null>;
+    getPageBySlug(slug: string): Promise<PublicPage | null>;
+    listPublishedPaths(): Promise<string[]>;
+    getGlobal<T extends Record<string, unknown> = Record<string, unknown>>(key: string): Promise<T>;
+    getFormConfig(slug: string): Promise<{
+        slug: string;
+        title: string;
+        config: Record<string, unknown>;
+        successMessage: string;
+    } | null>;
+    /** Looks up a redirect for a path — consulted by sites on would-be 404s. */
+    getRedirect(path: string): Promise<{
+        toPath: string;
+        permanent: boolean;
+    } | null>;
+    /** Builds a Supabase Storage transform URL for a media storage path. */
+    mediaUrl(storagePath: string, options?: {
+        width?: number;
+        height?: number;
+        quality?: number;
+    }): string;
+};
+declare function createContentClient(options?: ContentClientOptions): ContentClient;
+
+export { CONTENT_CACHE_TAG, type ContentClient, type ContentClientOptions, type PublicPage, createContentClient };

package/dist/content/index.js

@@ -0,0 +1,8 @@
+import {
+  CONTENT_CACHE_TAG,
+  createContentClient
+} from "../chunk-HVJCF2IZ.js";
+export {
+  CONTENT_CACHE_TAG,
+  createContentClient
+};

package/dist/forms/index.d.ts

@@ -0,0 +1,70 @@
+export { F as FormConfig, a as FormFieldConfig, b as FormNotifyConfig, H as HONEYPOT_FIELD_NAME, P as ProcessSubmissionArgs, c as ProcessSubmissionResult, R as RateLimitStore, d as createMemoryRateLimitStore, p as processSubmission } from '../submission-BKdBedOe.js';
+
+/**
+ * Shared, isomorphic form validation and normalization.
+ *
+ * This module is the single source of truth mandated by the Studio Website
+ * Setup Guide: the client form renderer and the server submission route must
+ * both use these helpers so values are trimmed, normalized, and validated the
+ * same way everywhere. It has no server-only dependencies and is safe to
+ * import from client components.
+ */
+type FieldValidationResult = {
+    valid: boolean;
+    /** Trimmed/normalized value. Use this for display, persistence, and emails. */
+    normalized: string;
+    /** Human-readable error message when invalid. */
+    message?: string;
+    /** Correction hint, e.g. `name@yahoo.com` when the domain looks like a typo. */
+    suggestion?: string;
+};
+declare function normalizeEmail(value: string): string;
+type ValidateEmailOptions = {
+    /** Additional domains that must never be flagged as typos. */
+    knownGoodDomains?: string[];
+};
+/**
+ * Validates an email per the Studio contract: trims before validation, and
+ * rejects obvious misspellings of major consumer providers with a
+ * `Did you mean …?` suggestion.
+ */
+declare function validateEmail(value: string, options?: ValidateEmailOptions): FieldValidationResult;
+/** Strips formatting and a leading US country code, returning digits only. */
+declare function normalizePhone(value: string): string;
+/**
+ * Progressive US phone formatting for use while typing: `(555) 555-5555`.
+ * Feed it the raw input value on every change and write the result back.
+ */
+declare function formatPhoneUS(value: string): string;
+/** Validates against the normalized 10-digit value, per the Studio contract. */
+declare function validatePhoneUS(value: string): FieldValidationResult;
+/** Normalizes bare domains to `https://…` before validation, per the Studio contract. */
+declare function normalizeUrl(value: string): string;
+declare function validateUrl(value: string): FieldValidationResult;
+declare function validateRequired(value: unknown, label?: string): FieldValidationResult;
+type StudioFormFieldType = 'text' | 'textarea' | 'email' | 'phone' | 'url' | 'select' | 'radio' | 'checkbox' | 'date' | 'number' | 'hidden';
+/** All field types the Studio form editor can assign. */
+declare const FORM_FIELD_TYPES: StudioFormFieldType[];
+/**
+ * Normalizes a single submitted value by field type using the same rules on
+ * client and server. Unknown types are trimmed only.
+ */
+declare function normalizeFieldValue(value: string, fieldType: StudioFormFieldType): string;
+/** Validates a date value (YYYY-MM-DD, per <input type="date">). */
+declare function validateDate(value: string): FieldValidationResult;
+/** Validates a numeric value; normalizes to the canonical decimal string. */
+declare function validateNumber(value: string): FieldValidationResult;
+/** Infers a normalization type from a form field definition (type first, then name heuristics). */
+declare function inferFieldType(field: {
+    name?: unknown;
+    type?: unknown;
+}): StudioFormFieldType;
+/** Normalizes a field's configured options to `{label, value}` pairs. */
+declare function fieldOptions(field: {
+    options?: unknown;
+}): Array<{
+    label: string;
+    value: string;
+}>;
+
+export { FORM_FIELD_TYPES, type FieldValidationResult, type StudioFormFieldType, type ValidateEmailOptions, fieldOptions, formatPhoneUS, inferFieldType, normalizeEmail, normalizeFieldValue, normalizePhone, normalizeUrl, validateDate, validateEmail, validateNumber, validatePhoneUS, validateRequired, validateUrl };

package/dist/forms/index.js

@@ -0,0 +1,38 @@
+import {
+  FORM_FIELD_TYPES,
+  HONEYPOT_FIELD_NAME,
+  createMemoryRateLimitStore,
+  fieldOptions,
+  formatPhoneUS,
+  inferFieldType,
+  normalizeEmail,
+  normalizeFieldValue,
+  normalizePhone,
+  normalizeUrl,
+  processSubmission,
+  validateDate,
+  validateEmail,
+  validateNumber,
+  validatePhoneUS,
+  validateRequired,
+  validateUrl
+} from "../chunk-VPUODCNH.js";
+export {
+  FORM_FIELD_TYPES,
+  HONEYPOT_FIELD_NAME,
+  createMemoryRateLimitStore,
+  fieldOptions,
+  formatPhoneUS,
+  inferFieldType,
+  normalizeEmail,
+  normalizeFieldValue,
+  normalizePhone,
+  normalizeUrl,
+  processSubmission,
+  validateDate,
+  validateEmail,
+  validateNumber,
+  validatePhoneUS,
+  validateRequired,
+  validateUrl
+};