@wix/himalaya-cli 0.1550.0 → 0.1552.0

package/templates/branded-lite/tier5-src/_shared/branded-form.ts

@@ -0,0 +1,262 @@
+// The Wix Forms schema → what the Branded Lite Form screen can render and send.
+//
+// Pure functions, so the hermetic tests drive them without a worker. The source for every
+// rule here is Wix's "About Form Fields" and "About Submission Values" articles
+// (dev.wix.com/docs/api-reference/crm/forms/…):
+//   • `formFields` is an unordered set; the display order is `steps[].layout.<bp>.items`
+//     sorted by row, then column (a breakpoint may be missing, so fall back across them).
+//   • `identifier`, not `componentType`, names the field: TEXT_INPUT serves a short answer,
+//     a long answer, a link, an email, an address and the contact names.
+//   • a checkbox label is Ricos rich content; every other label is a plain string.
+//   • a submission is keyed by each field's `target`, and its value shape follows `inputType`.
+// A field the app cannot fill (file, signature, payment, appointment, a multi-line address,
+// image choice, rating, time) or any conditional rule makes the whole form "unsupported":
+// a hidden required field would fail the whole send, so the screen offers the website instead.
+import { ricosToPlainText } from "@himalaya/wix-rich-content";
+
+export type FieldKind = "text" | "area" | "email" | "phone" | "number" | "url" | "date" | "checkbox" | "choice" | "multi" | "display";
+
+export interface FormOption { value: string; label: string }
+
+export interface FormFieldModel {
+  id: string;
+  target: string;
+  kind: FieldKind;
+  label: string;
+  required: boolean;
+  placeholder: string;
+  help: string;
+  options: FormOption[];
+  /** `inputOptions.contactMapping.contactField` — EMAIL, FIRST_NAME, … — for member prefill. */
+  contactField: string;
+}
+
+export interface FormModel {
+  id: string;
+  title: string;
+  /** Field ids per page, in display order. A form with no layout is one page in array order. */
+  pages: string[][];
+  fields: Record<string, FormFieldModel>;
+  submitText: string;
+  nextText: string;
+  backText: string;
+  thankYou: string;
+  /** Something on the form the app cannot fill: show the website notice. */
+  unsupported: boolean;
+  /** The form stopped taking submissions (its deadline passed). */
+  closed: boolean;
+}
+
+type Obj = Record<string, unknown>;
+const obj = (v: unknown): Obj => (v && typeof v === "object" && !Array.isArray(v) ? v as Obj : {});
+const arr = (v: unknown): unknown[] => (Array.isArray(v) ? v : []);
+const str = (v: unknown): string => (typeof v === "string" ? v : "");
+
+/** Ricos rich content (or a plain string) → plain text, through the shared Ricos walker. */
+export function plainText(v: unknown): string {
+  if (typeof v === "string") return v.trim();
+  return ricosToPlainText(obj(v) as never).trim();
+}
+
+const TEXT_IDENTIFIERS = new Set([
+  "TEXT_INPUT", "CONTACTS_FIRST_NAME", "CONTACTS_LAST_NAME", "CONTACTS_COMPANY", "CONTACTS_POSITION",
+  "CONTACTS_TAX_ID", "CONTACTS_ADDRESS",
+]);
+const KIND_BY_IDENTIFIER: Record<string, FieldKind> = {
+  TEXT_AREA: "area", CONTACTS_EMAIL: "email", CONTACTS_PHONE: "phone", NUMBER_INPUT: "number", URL_INPUT: "url",
+  CONTACTS_BIRTHDATE: "date", DATE_INPUT: "date", DATE_PICKER: "date",
+  CHECKBOX: "checkbox", CONTACTS_SUBSCRIBE: "checkbox",
+  RADIO_GROUP: "choice", DROPDOWN: "choice", CHECKBOX_GROUP: "multi", TAGS: "multi",
+};
+
+/** The `inputType` options object for an input field: `stringOptions`, `booleanOptions`, … */
+function typeOptions(input: Obj): Obj {
+  const t = str(input.inputType).toLowerCase().replace(/_([a-z])/g, (_m, c: string) => c.toUpperCase());
+  return obj(input[`${t}Options`]);
+}
+
+/** The component options object: `textInputOptions`, `radioGroupOptions`, … */
+function componentOptions(typeOpts: Obj): Obj {
+  const c = str(typeOpts.componentType).toLowerCase().replace(/_([a-z])/g, (_m, ch: string) => ch.toUpperCase());
+  return obj(typeOpts[`${c}Options`]);
+}
+
+/** One `formFields` entry → its model, `null` for the submit button / a hidden field, or
+ *  `"unsupported"` for a field the app cannot fill. */
+export function parseField(raw: unknown): FormFieldModel | null | "unsupported" {
+  const f = obj(raw);
+  const id = str(f.id).toLowerCase();
+  // A hidden field the visitor cannot fill, but Wix requires, would fail every send.
+  if (f.hidden === true) return f.fieldType === "INPUT" && obj(f.inputOptions).required === true ? "unsupported" : null;
+  if (f.fieldType === "DISPLAY") {
+    const d = obj(f.displayOptions);
+    if (d.displayFieldType !== "RICH_CONTENT") return null;
+    const label = plainText(obj(d.richContentOptions).richContent);
+    return label ? { id, target: "", kind: "display", label, required: false, placeholder: "", help: "", options: [], contactField: "" } : null;
+  }
+  if (f.fieldType !== "INPUT") return "unsupported";
+  const identifier = str(f.identifier);
+  const kind: FieldKind | undefined = TEXT_IDENTIFIERS.has(identifier) ? "text" : KIND_BY_IDENTIFIER[identifier];
+  const input = obj(f.inputOptions);
+  const target = str(input.target);
+  if (!kind || !target) return "unsupported";
+  const opts = componentOptions(typeOptions(input));
+  const options = (kind === "choice" || kind === "multi")
+    ? arr(opts.options).map((o) => ({ value: str(obj(o).value), label: str(obj(o).label) || str(obj(o).value) })).filter((o) => o.value)
+    : [];
+  if ((kind === "choice" || kind === "multi") && !options.length) return "unsupported";
+  return {
+    id,
+    target,
+    kind,
+    label: plainText(opts.label),
+    required: input.required === true,
+    placeholder: str(opts.placeholder).trim(),
+    help: plainText(opts.description),
+    options,
+    contactField: str(obj(input.contactMapping).contactField),
+  };
+}
+
+/** Field ids of one step, in display order (row, then column). */
+function stepFieldIds(step: unknown): string[] {
+  const layout = obj(obj(step).layout);
+  const bp = [layout.small, layout.medium, layout.large].map(obj).find((b) => arr(b.items).length) ?? {};
+  return arr(bp.items)
+    .map(obj)
+    .sort((a, b) => (Number(a.row) - Number(b.row)) || (Number(a.column) - Number(b.column)))
+    .map((i) => str(i.fieldId).toLowerCase())
+    .filter(Boolean);
+}
+
+export function parseForm(raw: unknown, now: number = Date.now()): FormModel {
+  const form = obj(obj(raw).form ?? raw);
+  const fields: Record<string, FormFieldModel> = {};
+  let unsupported = arr(form.formRules).length > 0 || arr(form.rules).length > 0;
+  let submitText = "", nextText = "", backText = "";
+  const arrayOrder: string[] = [];
+  for (const rawField of arr(form.formFields)) {
+    const f = obj(rawField);
+    const nav = obj(obj(f.displayOptions).pageNavigationOptions);
+    // A form has one navigation field per step and `formFields` is unordered: keep the first
+    // non-empty text of each kind, so another step's blank value never erases it.
+    if (obj(f.displayOptions).displayFieldType === "PAGE_NAVIGATION") {
+      submitText ||= str(nav.submitText).trim(); nextText ||= str(nav.nextPageText).trim(); backText ||= str(nav.previousPageText).trim();
+    }
+    const model = parseField(rawField);
+    if (model === "unsupported") { unsupported = true; continue; }
+    if (model) { fields[model.id] = model; arrayOrder.push(model.id); }
+  }
+  const steps = arr(form.steps);
+  const placed = steps.filter((st) => obj(st).hidden !== true).map((st) => stepFieldIds(st).filter((id) => fields[id]));
+  // A hidden step's fields are placed too — on no page. Adding them to the last page would show
+  // the visitor fields the owner hid (and block the send on a hidden required one).
+  const hiddenStepIds = steps.filter((st) => obj(st).hidden === true).flatMap(stepFieldIds);
+  const seen = new Set([...placed.flat(), ...hiddenStepIds]);
+  // …and a required field on a hidden step is the same dead end.
+  if (hiddenStepIds.some((id) => fields[id]?.required)) unsupported = true;
+  // A field missing from the layout still renders, on the last page, rather than vanishing.
+  const unplaced = arrayOrder.filter((id) => !seen.has(id));
+  const pages = placed.filter((p) => p.length);
+  if (unplaced.length) pages.length ? pages[pages.length - 1].push(...unplaced) : pages.push(unplaced);
+  const hasInput = Object.values(fields).some((f) => f.kind !== "display");
+  const deadline = Date.parse(str(obj(form.limitationRule).dateTimeDeadline));
+  const thanks = obj(obj(form.submitSettings).thankYouMessageOptions);
+  return {
+    id: str(form.id),
+    title: str(form.name).trim(),
+    pages: pages.length ? pages : [[]],
+    fields,
+    submitText, nextText, backText,
+    thankYou: plainText(thanks.richContent),
+    unsupported: unsupported || !hasInput,
+    closed: Number.isFinite(deadline) && deadline <= now,
+  };
+}
+
+/** A typed number. A locale decimal keyboard types "1,5": one comma and no dot is a decimal comma. */
+export function toNumber(text: string): number {
+  const t = text.trim();
+  return Number(/^[+-]?\d*,\d+$/.test(t) ? t.replace(",", ".") : t);
+}
+
+/** A form a visitor can fill has at least one input field. The demo site has a form with
+ *  no name and no fields; listing it opened a screen with nothing to fill. */
+export function hasInputFields(form: unknown): boolean {
+  return arr(obj(form).formFields).some((f) => obj(f).fieldType === "INPUT");
+}
+
+/** What the screen holds for one field. */
+export interface FieldValue { text: string; checked: boolean; selected: string[] }
+
+export const EMPTY_VALUE: FieldValue = { text: "", checked: false, selected: [] };
+
+function isEmpty(f: FormFieldModel, v: FieldValue): boolean {
+  if (f.kind === "checkbox") return !v.checked;
+  if (f.kind === "choice" || f.kind === "multi") return v.selected.length === 0;
+  return v.text.trim() === "";
+}
+
+export type FieldProblem = "required" | "email" | "number" | "url";
+
+/** The checks the app can make before Wix sees the values. Wix's own validation (format,
+ *  length, allowed values) runs after, through validateFormSubmission. */
+export function localProblems(fields: FormFieldModel[], values: Record<string, FieldValue>): Record<string, FieldProblem> {
+  const out: Record<string, FieldProblem> = {};
+  for (const f of fields) {
+    if (f.kind === "display") continue;
+    const v = values[f.target] ?? EMPTY_VALUE;
+    if (isEmpty(f, v)) { if (f.required) out[f.target] = "required"; continue; }
+    const t = v.text.trim();
+    if (f.kind === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(t)) out[f.target] = "email";
+    else if (f.kind === "number" && !Number.isFinite(toNumber(t))) out[f.target] = "number";
+    else if (f.kind === "url" && !/^(https?:\/\/)?[^\s.]+\.[^\s]+$/i.test(t)) out[f.target] = "url";
+  }
+  return out;
+}
+
+/** The `submissions` map: keyed by target, shaped by input type, empty optional values left out. */
+export function submissionValues(fields: FormFieldModel[], values: Record<string, FieldValue>): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const f of fields) {
+    if (f.kind === "display") continue;
+    const v = values[f.target] ?? EMPTY_VALUE;
+    if (f.kind === "checkbox") { out[f.target] = v.checked; continue; }
+    if (f.kind === "multi") { if (v.selected.length) out[f.target] = [...v.selected]; continue; }
+    if (f.kind === "choice") { if (v.selected[0]) out[f.target] = v.selected[0]; continue; }
+    const t = v.text.trim();
+    if (!t) continue;
+    out[f.target] = f.kind === "number" ? toNumber(t) : t;
+  }
+  return out;
+}
+
+/** Wix's per-field validation errors (`submissionValidationErrors.errors[]`, in a
+ *  validateFormSubmission answer or in a rejected createSubmission body) → target → errorType. */
+export function serverProblems(answerOrError: unknown): Record<string, string> {
+  let source: unknown = answerOrError;
+  if (answerOrError instanceof Error || typeof answerOrError === "string") {
+    const msg = String((answerOrError as Error)?.message ?? answerOrError);
+    const json = msg.slice(msg.indexOf("{"));
+    try { source = JSON.parse(json); } catch { return {}; }
+  }
+  const out: Record<string, string> = {};
+  const visit = (v: unknown): void => {
+    if (Array.isArray(v)) { v.forEach(visit); return; }
+    const o = obj(v);
+    for (const e of arr(obj(o.submissionValidationErrors).errors)) {
+      const path = str(obj(e).errorPath), type = str(obj(e).errorType);
+      if (path && !out[path]) out[path] = type || "INVALID";
+    }
+    for (const k of ["violationErrors", "details", "applicationError", "data", "validationError"]) if (k in o) visit(o[k]);
+  };
+  visit(source);
+  return out;
+}
+
+/** A unix-seconds date (the DatePicker's `args.value`) → the `YYYY-MM-DD` Wix's DATE format takes. */
+export function isoDate(unixSeconds: number): string {
+  const d = new Date(unixSeconds * 1000);
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}

package/templates/branded-lite/tier5-src/_shared/iap-attendance-purchase.ts

@@ -111,7 +111,7 @@ export function createAttendancePurchase(options: { kind: "bookingsService" | "e
     const classified = classifyForApple(metadata, currency);
     const candidate = platform === "ios" && classified === "appleIap";
     const price = iapPriceFields(commerce.pricing.view(reference), iapPriceCopy(prefix));
-    const copy = { ...iapPurchaseCopy(prefix), buy: copyParam(`${prefix}.appleBuyCta`, options.kind === "bookingsService" ? "Book with Apple" : "Buy ticket with Apple"), buyAnother: copyParam(`${prefix}.buyAnotherCta`, options.kind === "bookingsService" ? "Book again" : "Buy another ticket") };
+    const copy = iapPurchaseCopy(prefix);
     const purchase = commerce.purchaseFields(reference, copy);
     const apple = candidate || (platform === "ios" && classified !== "wixPayments" && purchase.appleRoute);
     const enabled = attendanceCheckoutRoute(metadata, currency, platform) === "appleIap";

package/templates/branded-lite/tier5-src/_shared/iap-worker.ts

@@ -20,7 +20,7 @@ export function iapPriceCopy(prefix: string): IapPriceCopy {
  *  `iapPurchaseFields`. Customer copy only: no backend names, ids or diagnostics. */
 export function iapPurchaseCopy(prefix: string): IapPurchaseCopy {
   return {
-    buy: copyParam(`${prefix}.buyCta`, "Get access"),
+    buy: copyParam(`${prefix}.buyCta`, "Buy now"),
     processing: copyParam(`${prefix}.purchaseProcessingText`, "Processing your purchase…"),
     awaitingApproval: copyParam(`${prefix}.purchaseAwaitingApprovalText`, "Waiting for approval"),
     unavailable: copyParam(`${prefix}.purchaseTemporarilyUnavailableText`, "Purchasing is temporarily unavailable."),