@bygghammar/cms-platform 0.3.1 → 0.5.0

package/src/forms/field-sets.ts

@@ -0,0 +1,590 @@
+import type { LocalizedString } from "../i18n";
+import { tripNumber } from "../trips";
+import { getTripTerminology } from "../trips";
+
+export type FormFieldType =
+  | "text"
+  | "email"
+  | "tel"
+  | "url"
+  | "textarea"
+  | "select"
+  | "trip"
+  /** @deprecated Stored forms may still contain this legacy type. */
+  | "course"
+  | "checkbox"
+  | "date"
+  | "time"
+  | "number";
+
+/**
+ * Field types offered by the form builder. A function, not a constant, so the
+ * trip label reflects the terminology the host site registered at startup.
+ */
+export function fieldTypes(): { value: FormFieldType; label: string }[] {
+  const trip = getTripTerminology();
+  return [
+  { value: "text", label: "Short text" },
+  { value: "textarea", label: "Long text" },
+  { value: "email", label: "Email" },
+  { value: "tel", label: "Phone" },
+  { value: "url", label: "URL" },
+  { value: "number", label: "Number" },
+  { value: "date", label: "Date" },
+  { value: "time", label: "Time" },
+  { value: "select", label: "Dropdown" },
+  {
+    value: "trip",
+      label: `${trip.singular} (from ${trip.plural})`,
+  },
+    { value: "checkbox", label: "Checkbox" },
+  ];
+}
+
+/** One trip row, displayed with site-specific terminology. */
+export type TripSource = {
+  id?: string;
+  year?: string;
+  tripNo?: Partial<LocalizedString>;
+  /** @deprecated Compatibility with data saved before the trips module. */
+  courseNo?: Partial<LocalizedString>;
+  location?: Partial<LocalizedString>;
+  dates?: Partial<LocalizedString>;
+};
+
+const loc = (v: Partial<LocalizedString> | undefined, locale: string): string =>
+  (v?.[locale as keyof LocalizedString] as string | undefined) ?? v?.sv ?? v?.en ?? "";
+
+/** Distinct years present in the Trips section, newest first. */
+export function tripYears(items: TripSource[]): string[] {
+  const years = new Set<string>();
+  for (const c of items) if (c.year) years.add(String(c.year));
+  return [...years].sort().reverse();
+}
+
+/**
+ * Build dropdown choices from the Courses section (single source of truth).
+ * Value is the readable course name including the year
+ * ("Kurs 1, Stockholm–Tallinn 2027") so stored answers stay unambiguous even after
+ * the course list changes and course numbers repeat across years.
+ */
+export function tripFieldOptions(items: TripSource[], year?: string): FormFieldOption[] {
+  const filtered = year ? items.filter((c) => String(c.year ?? "") === String(year)) : items;
+  return filtered.map((c, i) => {
+    const build = (locale: string) => {
+      const no = loc(tripNumber(c), locale);
+      const place = loc(c.location, locale);
+      const dates = loc(c.dates, locale);
+      // Prefer the explicit year; otherwise read a 4-digit year off the dates.
+      const y = String(c.year ?? "").trim() || (dates.match(/\b(20\d{2})\b/)?.[1] ?? "");
+      const base = [no, place].filter(Boolean).join(", ") || `#${i + 1}`;
+      const name = y && !base.includes(y) ? `${base} ${y}` : base;
+      return { name, label: dates ? `${name} — ${dates}` : name };
+    };
+    const sv = build("sv");
+    const en = build("en");
+    return { value: sv.name, label: { sv: sv.label, en: en.label } };
+  });
+}
+
+/** @deprecated Use TripSource. */
+export type CourseSource = TripSource;
+/** @deprecated Use tripYears. */
+export const courseYears = tripYears;
+/** @deprecated Use tripFieldOptions. */
+export const courseFieldOptions = tripFieldOptions;
+
+export type FormFieldOption = {
+  value: string;
+  label: Partial<LocalizedString>;
+};
+
+/** One comparison against another field's current answer. */
+export type FieldCondition = {
+  /** Key of the field being compared. */
+  field: string;
+  op:
+    | "equals"
+    | "not_equals"
+    | "contains"
+    | "not_contains"
+    | "starts_with"
+    | "gt"
+    | "lt"
+    | "is_empty"
+    | "is_not_empty"
+    | "checked"
+    | "unchecked";
+  value?: string;
+};
+
+/** A set of conditions combined with all/any. Empty = always true. */
+export type ConditionRule = {
+  mode: "all" | "any";
+  conditions: FieldCondition[];
+};
+
+export type FormFieldDef = {
+  /** Stable identifier — never renamed, submissions are keyed by it. */
+  key: string;
+  type: FormFieldType;
+  label: Partial<LocalizedString>;
+  placeholder?: Partial<LocalizedString>;
+  help?: Partial<LocalizedString>;
+  enabled: boolean;
+  required: boolean;
+  /** Full width in the two-column grid. */
+  wide?: boolean;
+  options?: FormFieldOption[];
+  /** True for editor-created fields that are not part of the canonical set. */
+  custom?: boolean;
+  /**
+   * Built-in field the editor removed. The key is kept as a tombstone so old
+   * submissions still resolve a label; the field never renders on the site.
+   */
+  removed?: boolean;
+  /** Show this field only when the rule matches. Empty = always shown. */
+  showWhen?: ConditionRule;
+  /** Make this field required only when the rule matches. */
+  requireWhen?: ConditionRule;
+  /** Validation. */
+  minLength?: number;
+  maxLength?: number;
+  /** Numeric bounds (type "number"). */
+  min?: number;
+  max?: number;
+  /** Date bounds as YYYY-MM-DD (type "date"). */
+  minDate?: string;
+  maxDate?: string;
+  /** Named format preset, see FIELD_FORMATS in ./conditions. */
+  format?: string;
+  pattern?: string;
+  /** Overrides every generated validation message for this field. */
+  errorMessage?: Partial<LocalizedString>;
+  /**
+   * Browser autofill token (HTML `autocomplete`). Undefined = automatic,
+   * resolved from the field key and type. "off" disables autofill.
+   */
+  autocomplete?: string;
+  /** Type "trip": only show trips of this year. Empty = all years. */
+  tripYear?: string;
+  /** @deprecated Compatibility with saved course fields. */
+  courseYear?: string;
+};
+
+/** Autofill tokens offered in the form editor. */
+export const AUTOCOMPLETE_OPTIONS: { value: string; label: string }[] = [
+  { value: "off", label: "Off" },
+  { value: "name", label: "Full name" },
+  { value: "given-name", label: "Given name" },
+  { value: "family-name", label: "Family name" },
+  { value: "email", label: "Email" },
+  { value: "tel", label: "Phone" },
+  { value: "organization", label: "Organisation" },
+  { value: "organization-title", label: "Job title" },
+  { value: "street-address", label: "Street address" },
+  { value: "postal-code", label: "Postal code" },
+  { value: "address-level2", label: "City" },
+  { value: "country-name", label: "Country" },
+  { value: "bday", label: "Birthday" },
+  { value: "url", label: "Website" },
+];
+
+/** Canonical field key -> autofill token. */
+const DEFAULT_AUTOCOMPLETE: Record<string, string> = {
+  firstName: "given-name",
+  lastName: "family-name",
+  name: "name",
+  fullName: "name",
+  email: "email",
+  phone: "tel",
+  tel: "tel",
+  mobile: "tel",
+  company: "organization",
+  organization: "organization",
+  jobTitle: "organization-title",
+  address: "street-address",
+  street: "street-address",
+  postalCode: "postal-code",
+  zip: "postal-code",
+  city: "address-level2",
+  country: "country-name",
+  website: "url",
+  birthday: "bday",
+};
+
+const TYPE_AUTOCOMPLETE: Partial<Record<FormFieldType, string>> = {
+  email: "email",
+  tel: "tel",
+  url: "url",
+};
+
+/**
+ * Resolve the `autocomplete` attribute for a field:
+ * explicit setting -> key default -> type default -> "off".
+ */
+export function resolveAutocomplete(f: FormFieldDef): string {
+  if (f.autocomplete) return f.autocomplete;
+  if (f.type === "checkbox" || f.type === "textarea") return "off";
+  return DEFAULT_AUTOCOMPLETE[f.key] ?? TYPE_AUTOCOMPLETE[f.type] ?? "off";
+}
+
+export type FormType = "contact" | "booking" | "interest" | "newsletter" | "callback";
+
+export const FORM_TYPES: { value: FormType; label: string; description: string }[] = [
+  { value: "contact", label: "Contact", description: "Name, email, phone and a message." },
+  {
+    value: "booking",
+    label: "Booking request",
+    description: "Contact details plus course, date and participants.",
+  },
+  {
+    value: "interest",
+    label: "Interest / lead",
+    description: "Short lead capture with a free-text note.",
+  },
+  { value: "newsletter", label: "Newsletter", description: "Email only (plus optional name)." },
+  { value: "callback", label: "Call me back", description: "Name, phone and preferred time." },
+];
+
+const f = (
+  key: string,
+  type: FormFieldType,
+  sv: string,
+  en: string,
+  extra: Partial<FormFieldDef> = {},
+): FormFieldDef => ({
+  key,
+  type,
+  label: { sv, en },
+  enabled: true,
+  required: false,
+  ...extra,
+});
+
+/** Fixed field sets per form type. Keys are stable and must never change. */
+export const FIELD_SETS: Record<FormType, FormFieldDef[]> = {
+  contact: [
+    f("firstName", "text", "Förnamn", "First name", { required: true }),
+    f("lastName", "text", "Efternamn", "Last name", { required: true }),
+    f("email", "email", "E-post", "Email", { required: true, wide: true }),
+    f("phone", "tel", "Telefon", "Phone", { wide: true }),
+    f("message", "textarea", "Meddelande", "Message", { wide: true }),
+  ],
+  booking: [
+    f("firstName", "text", "Förnamn", "First name", { required: true }),
+    f("lastName", "text", "Efternamn", "Last name", { required: true }),
+    f("email", "email", "E-post", "Email", { required: true }),
+    f("phone", "tel", "Telefon", "Phone", { required: true }),
+    f("course", "trip", "Kryssning", "Cruise", { wide: true }),
+    f("startDate", "date", "Önskat startdatum", "Preferred start date"),
+    f("participants", "number", "Antal deltagare", "Number of participants"),
+    f("message", "textarea", "Övrigt", "Anything else", { wide: true }),
+  ],
+  interest: [
+    f("name", "text", "Namn", "Name", { required: true }),
+    f("email", "email", "E-post", "Email", { required: true }),
+    f("phone", "tel", "Telefon", "Phone"),
+    f("message", "textarea", "Berätta kort om dig", "Tell us briefly about yourself", {
+      wide: true,
+    }),
+  ],
+  newsletter: [
+    f("name", "text", "Namn", "Name"),
+    f("email", "email", "E-post", "Email", { required: true, wide: true }),
+  ],
+  callback: [
+    f("name", "text", "Namn", "Name", { required: true }),
+    f("phone", "tel", "Telefon", "Phone", { required: true }),
+    f("preferredTime", "text", "Önskad tid", "Preferred time", { wide: true }),
+    f("message", "textarea", "Meddelande", "Message", { wide: true }),
+  ],
+};
+
+export function defaultFieldsFor(type: string): FormFieldDef[] {
+  const set = FIELD_SETS[(type as FormType) in FIELD_SETS ? (type as FormType) : "contact"];
+  return set.map((x) => ({ ...x, label: { ...x.label } }));
+}
+
+const VALID_TYPES = new Set<string>([...fieldTypes().map((type) => type.value), "course"]);
+
+const VALID_OPS = new Set([
+  "equals",
+  "not_equals",
+  "contains",
+  "not_contains",
+  "starts_with",
+  "gt",
+  "lt",
+  "is_empty",
+  "is_not_empty",
+  "checked",
+  "unchecked",
+]);
+
+/** Drop malformed conditions so a bad save can never break a live form. */
+function normalizeRule(r: unknown): ConditionRule | undefined {
+  if (!r || typeof r !== "object") return undefined;
+  const raw = r as Partial<ConditionRule>;
+  const conditions = (Array.isArray(raw.conditions) ? raw.conditions : [])
+    .filter(
+      (c): c is FieldCondition =>
+        !!c && typeof c.field === "string" && c.field.length > 0 && VALID_OPS.has(c.op),
+    )
+    .map((c) => ({ field: c.field, op: c.op, value: c.value ?? "" }));
+  if (conditions.length === 0) return undefined;
+  return { mode: raw.mode === "any" ? "any" : "all", conditions };
+}
+
+function normalizeStored(s: Partial<FormFieldDef>): Partial<FormFieldDef> {
+  const out: Partial<FormFieldDef> = { ...s };
+  if (out.type && !VALID_TYPES.has(out.type)) delete out.type;
+  if (Array.isArray(out.options)) {
+    out.options = out.options
+      .filter((o) => o && typeof o.value === "string")
+      .map((o) => ({ value: o.value, label: { ...(o.label ?? {}) } }));
+  }
+  if (typeof out.autocomplete === "string") {
+    const token = out.autocomplete.trim();
+    out.autocomplete =
+      token && AUTOCOMPLETE_OPTIONS.some((o) => o.value === token) ? token : undefined;
+  } else if (out.autocomplete !== undefined) {
+    delete out.autocomplete;
+  }
+  out.showWhen = normalizeRule(out.showWhen);
+  out.requireWhen = normalizeRule(out.requireWhen);
+  return out;
+}
+
+/**
+ * Merge stored field config over the canonical field set.
+ *
+ * - Canonical fields keep their key/type from code; the editor may override
+ *   label, placeholder, help, enabled, required, width, options, conditional
+ *   logic and validation rules.
+ * - Editor-created custom fields are appended (they only exist in storage).
+ * - The stored order decides the render order; unknown/new canonical fields
+ *   fall back to their position in the canonical set.
+ *
+ * Keys are never rewritten, so historical submissions always stay readable.
+ */
+export function mergeFields(type: string, stored: unknown): FormFieldDef[] {
+  const base = defaultFieldsFor(type);
+  if (!Array.isArray(stored)) return base;
+
+  const storedList = (stored as Partial<FormFieldDef>[])
+    .filter((s) => s && typeof s.key === "string" && s.key.length > 0)
+    .map(normalizeStored);
+
+  const byKey = new Map<string, Partial<FormFieldDef>>();
+  for (const s of storedList) byKey.set(s.key as string, s);
+
+  const merged: FormFieldDef[] = base.map((b) => {
+    const s = byKey.get(b.key);
+    if (!s) return b;
+    if (s.removed === true) return { ...b, removed: true, enabled: false };
+    return {
+      ...b,
+      enabled: typeof s.enabled === "boolean" ? s.enabled : b.enabled,
+      required: typeof s.required === "boolean" ? s.required : b.required,
+      wide: typeof s.wide === "boolean" ? s.wide : b.wide,
+      label: { ...b.label, ...(s.label ?? {}) },
+      placeholder: { ...(b.placeholder ?? {}), ...(s.placeholder ?? {}) },
+      help: { ...(b.help ?? {}), ...(s.help ?? {}) },
+      options: s.options?.length ? s.options : b.options,
+      showWhen: s.showWhen ?? b.showWhen,
+      requireWhen: s.requireWhen ?? b.requireWhen,
+      minLength: s.minLength ?? b.minLength,
+      maxLength: s.maxLength ?? b.maxLength,
+      min: s.min ?? b.min,
+      max: s.max ?? b.max,
+      minDate: s.minDate ?? b.minDate,
+      maxDate: s.maxDate ?? b.maxDate,
+      format: s.format ?? b.format,
+      pattern: s.pattern ?? b.pattern,
+      autocomplete: s.autocomplete ?? b.autocomplete,
+      courseYear: s.courseYear ?? b.courseYear,
+      errorMessage: { ...(b.errorMessage ?? {}), ...(s.errorMessage ?? {}) },
+    };
+  });
+
+  const baseKeys = new Set(base.map((b) => b.key));
+  for (const s of storedList) {
+    const key = s.key as string;
+    if (baseKeys.has(key)) continue;
+    if (s.removed === true) continue;
+    merged.push({
+      key,
+      type: (s.type ?? "text") as FormFieldType,
+      label: { ...(s.label ?? {}) },
+      placeholder: { ...(s.placeholder ?? {}) },
+      help: { ...(s.help ?? {}) },
+      enabled: s.enabled !== false,
+      required: s.required === true,
+      wide: s.wide === true,
+      options: s.options ?? [],
+      custom: true,
+      showWhen: s.showWhen,
+      requireWhen: s.requireWhen,
+      minLength: s.minLength,
+      maxLength: s.maxLength,
+      min: s.min,
+      max: s.max,
+      minDate: s.minDate,
+      maxDate: s.maxDate,
+      format: s.format,
+      pattern: s.pattern,
+      autocomplete: s.autocomplete,
+      courseYear: s.courseYear,
+      errorMessage: { ...(s.errorMessage ?? {}) },
+    });
+  }
+
+  const order = new Map<string, number>();
+  storedList.forEach((s, i) => order.set(s.key as string, i));
+  return merged
+    .map((fld, i) => ({ fld, i, o: order.get(fld.key) ?? 1000 + i }))
+    .sort((a, b) => a.o - b.o || a.i - b.i)
+    .map((x) => x.fld);
+}
+
+/** Suggest a stable, unique key for a new custom field. */
+export function makeFieldKey(label: string, taken: Iterable<string>): string {
+  const used = new Set(taken);
+  const base =
+    label
+      .toLowerCase()
+      .normalize("NFD")
+      .replace(/[\u0300-\u036f]/g, "")
+      .replace(/[^a-z0-9]+/g, "_")
+      .replace(/^_+|_+$/g, "")
+      .slice(0, 40) || "field";
+  if (!used.has(base)) return base;
+  let n = 2;
+  while (used.has(`${base}_${n}`)) n += 1;
+  return `${base}_${n}`;
+}
+
+/** ---- Settings shapes (shared defaults + per-form overrides) ---- */
+
+export type FormPublicSettings = {
+  title?: Partial<LocalizedString>;
+  intro?: Partial<LocalizedString>;
+  submitLabel?: Partial<LocalizedString>;
+  consentText?: Partial<LocalizedString>;
+  requireConsent?: boolean;
+  thankyouMode?: "inline" | "redirect";
+  thankyouMessage?: Partial<LocalizedString>;
+  thankyouRedirect?: string;
+};
+
+/**
+ * Extra notification recipients that only apply when the answers match.
+ * Example: route "Företag = ja" leads to the sales inbox.
+ */
+export type NotificationRule = {
+  id: string;
+  label?: string;
+  to: string;
+  /** Undefined means the rule always applies. */
+  when?: ConditionRule;
+
+  /** Skip the normal recipients when this rule matches. */
+  exclusive?: boolean;
+  enabled?: boolean;
+};
+
+export type FormPrivateSettings = {
+  notifyTo?: string;
+  /** Per-form notification override. undefined = inherit shared defaults. */
+  notifyEnabled?: boolean;
+  notifySubject?: Partial<LocalizedString>;
+  notifyBody?: Partial<LocalizedString>;
+  notifyFromName?: string;
+  notifyFromEmail?: string;
+  notifyReplyTo?: string;
+  /** Conditional routing on top of the normal recipients. */
+  notificationRules?: NotificationRule[];
+  sheetId?: string;
+  sheetTab?: string;
+  sheetLiveAppend?: boolean;
+  /** Per-form autoreply override. undefined = inherit shared defaults. */
+  autoreplyEnabled?: boolean;
+  autoreplySubject?: Partial<LocalizedString>;
+  autoreplyBody?: Partial<LocalizedString>;
+  /** Per-form spam override. undefined = inherit shared defaults. */
+  spamMinSeconds?: number;
+  spamMaxPerHour?: number;
+  /**
+   * Keep a draft of what the visitor typed even if they never submit.
+   * undefined = inherit the shared default (which ships as on).
+   */
+  savePartials?: boolean;
+  /** Optional external endpoint that receives every submission as JSON. */
+  webhookUrl?: string;
+  /** Shared secret used to sign the webhook body (X-Signature, HMAC-SHA256). */
+  webhookSecret?: string;
+  webhookEnabled?: boolean;
+};
+
+/** Fields a form can inherit from the shared defaults. */
+export function isInherited(v: unknown): boolean {
+  if (v === undefined || v === null) return true;
+  if (typeof v === "string") return v.trim() === "";
+  if (typeof v === "object") {
+    return Object.values(v as Record<string, unknown>).every(
+      (x) => typeof x !== "string" || x.trim() === "",
+    );
+  }
+  return false;
+}
+
+export type FormDefaults = {
+  notify_to: string;
+  notify_enabled: boolean;
+  notify_subject: Partial<LocalizedString>;
+  notify_body: Partial<LocalizedString>;
+  notify_from_name: string;
+  notify_from_email: string;
+  notify_reply_to: string;
+  autoreply_enabled: boolean;
+  autoreply_subject: Partial<LocalizedString>;
+  autoreply_body: Partial<LocalizedString>;
+  spam_honeypot: boolean;
+  spam_min_seconds: number;
+  spam_max_per_hour: number;
+  thankyou_mode: string;
+  thankyou_message: Partial<LocalizedString>;
+  thankyou_redirect: string;
+  consent_text: Partial<LocalizedString>;
+  /** Shared target for `[text](privacy)` links in consent wording. */
+  privacy_policy_url: string;
+  retention_days: number;
+  sheet_id: string;
+  sheet_tab: string;
+  sheet_live_append: boolean;
+  save_partials: boolean;
+};
+
+/** Public, render-time view of a managed form. */
+export type PublicForm = {
+  id: string;
+  key: string;
+  name: string;
+  form_type: string;
+  fields: FormFieldDef[];
+  title?: Partial<LocalizedString>;
+  intro?: Partial<LocalizedString>;
+  submitLabel: Partial<LocalizedString>;
+  consentText: Partial<LocalizedString>;
+  /** Resolved URL used by `[text](privacy)` in the consent text. */
+  privacyPolicyUrl: string;
+  requireConsent: boolean;
+  thankyouMode: "inline" | "redirect";
+  thankyouMessage: Partial<LocalizedString>;
+  thankyouRedirect: string;
+  honeypot: boolean;
+  minSeconds: number;
+  /** Store part-filled answers as the visitor types. */
+  savePartials: boolean;
+};