@wix/himalaya-cli 0.1614.0 → 0.1616.0

package/templates/salon-spa/tier5-src/_shared/rich-body.ts

@@ -0,0 +1,78 @@
+// [rico] #3370 — an entity's Ricos body, prepared for a RichContent component and its plain-text fallback.
+// One rule for every worker that renders a body (the blog post and the owner post detail today; #3372's
+// verticals next), so they cannot drift apart.
+// Inside the platform source this import is a relative path, so node test runs resolve it; an app's copy
+// imports "@himalaya/wix-rich-content".
+import { encodeRichContent, parseRicosJson, ricosToPlainText } from "@himalaya/wix-rich-content";
+
+/** What a body-rendering worker publishes: `<name>Json` for `documentJsonPath`, and the plain text. */
+export interface RichBody {
+  /** The document as ONE JSON string (media sized, disallowed links dropped); "" when there is no document
+   *  or the encoder rejected it. RichContent draws nothing for "", so a screen gates its plain text on it. */
+  bodyJson: string;
+  /** The plain text: the document's own text when it has any, else `fallback`. */
+  bodyText: string;
+}
+
+/** [rico] #3372 — the media width for a document drawn in a LIST row (a feed post, a comment, a CMS item): the
+ *  list-image size (WIX_LIST_IMAGE), so a scrolling list never downloads every image at detail size. */
+export const ROW_IMAGE_WIDTH = 1000;
+
+/** Prepares `richContent` (a Ricos document, as a Wix API returns it, or its JSON string). No document, or one
+ *  that is not a document, gives `{ bodyJson: "", bodyText: fallback }`. A document past the viewer's limits
+ *  gives bodyJson "" and its plain text — except one rejected as too deep, which is not walked again (the
+ *  plain-text walk has no depth limit), so `fallback` stands in for it. `imageWidth` sizes its media (default
+ *  the 1400 px detail budget). */
+export function richBody(richContent: unknown, fallback = "", imageWidth = 1400): RichBody {
+  const doc = parseRicosJson(richContent);
+  if (!doc) return { bodyJson: "", bodyText: fallback };
+  // 1400 px by default — the detail-image budget, which is also the encoder's maximum; list rows pass
+  // ROW_IMAGE_WIDTH.
+  const { json, rejected } = encodeRichContent(doc, { imageWidth });
+  const text = rejected === "too_deep" ? "" : ricosToPlainText(doc);
+  return { bodyJson: json, bodyText: text || fallback };
+}
+
+/** A Wix description may be Ricos (including serialized JSON), HTML or ordinary text.
+ * Keep rich documents on the existing bounded encoder path. Non-document JSON and
+ * clearly malformed serialization use an independent fallback. Ambiguous bracketed
+ * prose stays readable; this does not attempt to repair arbitrary JSON syntax. */
+export function descriptionBody(value: unknown, fallback = "", imageWidth = 1400): RichBody {
+  if (typeof value !== "string") return richBody(value, fallback, imageWidth);
+  const text = value.trim();
+  if (/^[{[]/.test(text)) {
+    try {
+      const parsed: unknown = JSON.parse(text);
+      // Passing the parsed value avoids parsing a valid Ricos document twice; a
+      // different JSON structure is rejected by the same existing document check.
+      if (parsed && typeof parsed === "object") return richBody(parsed, fallback, imageWidth);
+    } catch {
+      const objectLike = /^\{\s*(?:["'}]|nodes\b)/.test(text);
+      // Only reject scalar-looking malformed arrays when their syntax is clearly
+      // unfinished (or contains JS's non-JSON `undefined`). Balanced bracketed
+      // prose such as "[1,000]" and "[12:30, 13:30]" is not JSON and stays readable.
+      const arrayTokens = text.replace(/"(?:\\.|[^"\\])*"/g, "")
+        .replace(/\b(?:true|false|null|undefined)\b/g, "")
+        .replace(/-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/g, "");
+      const arrayLike = /^\[\s*[{"]/.test(text)
+        || (text.startsWith("[") && /^[\s[\]{},:]*$/.test(arrayTokens)
+          && (/,\s*]?$/.test(text) || /\bundefined\b/.test(text) || !text.endsWith("]")));
+      if (objectLike || arrayLike) return { bodyJson: "", bodyText: fallback };
+    }
+  }
+  // Legacy HTML descriptions stay text. Preserve paragraph breaks and ordinary prose's
+  // bare '<' (e.g. "ages < 8"), without relying on browser-only DOM APIs in workers.
+  const plain = text
+    .replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, "")
+    .replace(/<br\s*\/?\s*>/gi, "\n")
+    .replace(/<\/(?:p|div|h[1-6]|li)\s*>/gi, "\n\n")
+    .replace(/<\/?[a-z][^>]*>/gi, "")
+    .replace(/&(?:nbsp|amp|lt|gt|quot|apos|#39);/gi, (entity) => ({
+      "&nbsp;": " ", "&amp;": "&", "&lt;": "<", "&gt;": ">", "&quot;": '"', "&apos;": "'", "&#39;": "'",
+    })[entity.toLowerCase()] ?? entity)
+    .replace(/[\t\r ]+/g, " ")
+    .replace(/ *\n */g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+  return { bodyJson: "", bodyText: plain || fallback };
+}

package/templates/salon-spa/tier5-src/_shared/rich-content-link.ts

@@ -0,0 +1,34 @@
+// [rico] #3370 — a RichContent `on_link` tap reaches the worker as `{ url }` (the renderers merge the tapped
+// link into the action's args). Only http(s) with a host, mailto and tel ever reach the OS; anything
+// else is dropped here, before any dispatch. The renderers already refuse other schemes, but the action
+// arrives here as plain data, so the worker checks it again rather than trusting whoever sent it.
+import { open, defaultMode } from "@himalaya/open-url";
+
+/** The viewer's link rule, verbatim (`LINK` in @himalaya/wix-rich-content's display.ts, which the package does
+ *  not export); a parity test pins this copy to the original. */
+const LINK = /^(https?:\/\/[^\s/?#]\S*|mailto:\S+|tel:\S+)$/i;
+/** ASCII whitespace only, as the viewer trims a link before applying the rule. */
+const trimAscii = (s: string): string => s.replace(/^[\t\n\v\f\r ]+|[\t\n\v\f\r ]+$/g, "");
+
+/** The url of a link tap (`{ url }`, `{ args: { url } }` or a bare string), or "" when it is missing or
+ *  not an http(s), mailto or tel link. */
+export function richLinkUrl(arg: unknown): string {
+  const a = arg as { url?: unknown; args?: { url?: unknown } } | null | undefined;
+  const raw = typeof arg === "string" ? arg
+    : typeof a?.url === "string" ? a.url
+      : typeof a?.args?.url === "string" ? a.args.url : "";
+  const url = trimAscii(raw);
+  return LINK.test(url) ? url : "";
+}
+
+/** Opens a link tap through `capability.open_url` (http(s) in the in-app browser, mailto/tel in the system
+ *  handler). False when the link is blocked, nothing took it, or the host threw. */
+export async function openRichLink(arg: unknown): Promise<boolean> {
+  const url = richLinkUrl(arg);
+  if (!url) return false;
+  try {
+    return (await open(url, defaultMode(url))).opened;
+  } catch {
+    return false;
+  }
+}

package/templates/salon-spa/tier5-src/_shared/weekly-goal.ts

@@ -0,0 +1,107 @@
+// The weekly session goal (`provisioning.goals.weeklySessions`) over a member's own bookings —
+// shared by the home weekly-goal Gauge (himi-branded-lite-home) and the My Bookings "This week"
+// card (himi-booking-bookings), so the two can never count differently.
+//
+// WHAT COUNTS as a session toward the goal: a CONFIRMED booking whose start falls in the CURRENT
+// calendar week (Monday 00:00 local → now) and is already in the past. An allow-list, not a
+// deny-list: CREATED (checkout never completed), PENDING / PENDING_APPROVAL / PENDING_CHECKOUT,
+// WAITING_LIST, CANCELED and DECLINED — and any status Wix adds later — do not count. That is
+// "booked and it happened", not verified
+// attendance: the member-scoped queryBookings row carries no attendance/check-in field (the Wix
+// Attendance API is owner-scoped), so a no-show still counts. Future bookings this week do not
+// count — they have not happened yet.
+//
+// DETERMINISM: nothing here runs at worker boot; every clock read is an argument. PURE (no network,
+// no bridge) so the rules are unit-tested directly; the read lives with its caller.
+
+import type { MemberBookingRow } from "./member-bookings.js";
+import { copyParam, copyTemplate } from "./himi-copy.js";
+
+export const MAX_WEEKLY_SESSION_GOAL = 21;
+
+/** The one status that means the session was booked and held (as memberBookingRow normalizes
+ *  it: upper-case, `_` → space). */
+const COUNTS_AS_SESSION = /^CONFIRMED$/;
+
+/** At most this many pages of past bookings are read for one week's count. */
+export const MAX_WEEKLY_PAGES = 4;
+
+/** The onAppear `weeklyGoal` param → a goal in [1, 21], or 0 = no goal provisioned. */
+export function parseWeeklyGoal(raw: unknown): number {
+  const n = typeof raw === "number" ? raw : typeof raw === "string" && raw.trim() !== "" ? Number(raw) : NaN;
+  return Number.isInteger(n) && n >= 1 ? Math.min(n, MAX_WEEKLY_SESSION_GOAL) : 0;
+}
+
+/** Monday 00:00 local of `now`'s week, epoch ms. */
+export function weekStartMs(now: number): number {
+  const d = new Date(now);
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() - ((d.getDay() + 6) % 7));
+  return d.getTime();
+}
+
+/** Sessions toward the goal among `rows` — see the file header for what counts. */
+export function weeklySessionsDone(rows: readonly MemberBookingRow[], now: number): number {
+  const from = weekStartMs(now);
+  const seen = new Set<string>();
+  for (const row of rows) {
+    const start = Date.parse(row.start);
+    if (!Number.isFinite(start) || start < from || start >= now) continue;
+    if (!COUNTS_AS_SESSION.test((row.status || "").trim().toUpperCase())) continue;
+    seen.add(row.id || `${row.start}|${row.title}`);
+  }
+  return seen.size;
+}
+
+export interface BookingsPage {
+  items: MemberBookingRow[];
+  nextCursor?: string;
+}
+
+/** Sessions toward the goal from PAST bookings read newest-first: `first` is the first page, and
+ *  `next(cursor)` reads more only while the oldest row so far is still inside this week (a page of
+ *  50 almost always reaches back before Monday). Bounded to MAX_WEEKLY_PAGES reads; a failing
+ *  read rejects, so the caller hides the count rather than under-counting. */
+export async function weeklySessionsFromPages(
+  first: BookingsPage,
+  next: (cursor: string) => Promise<BookingsPage>,
+  now: number,
+): Promise<number> {
+  const from = weekStartMs(now);
+  const rows = [...first.items];
+  let page = first;
+  for (let read = 1; read < MAX_WEEKLY_PAGES && page.nextCursor; read++) {
+    const oldest = page.items[page.items.length - 1];
+    if (oldest && Date.parse(oldest.start) < from) break;
+    page = await next(page.nextCursor);
+    rows.push(...page.items);
+  }
+  return weeklySessionsDone(rows, now);
+}
+
+export interface WeeklyGoalProgress {
+  done: number;
+  goal: number;
+  /** 0..1 — the Gauge / ProgressBar fill. */
+  fraction: number;
+  met: boolean;
+  /** "1 of 2 sessions this week" */
+  label: string;
+  /** "1 more to reach your weekly goal" / "Weekly goal reached. Great consistency." */
+  remainingLabel: string;
+}
+
+export function weeklyGoalProgress(done: number, goal: number): WeeklyGoalProgress {
+  const safeGoal = Math.max(1, goal);
+  const met = done >= safeGoal;
+  return {
+    done,
+    goal: safeGoal,
+    fraction: Math.min(done / safeGoal, 1),
+    met,
+    label: copyTemplate("weeklyGoal.progress", "{done} of {goal} sessions this week", { done, goal: safeGoal }),
+    remainingLabel: met
+      ? copyParam("weeklyGoal.met", "Weekly goal reached. Great consistency.")
+      : copyTemplate("weeklyGoal.remaining", "{count} more to reach your weekly goal", { count: safeGoal - done }),
+  };
+}

package/templates/salon-spa/tier5-src/_shared/wix-service-price.ts

@@ -0,0 +1,146 @@
+// Shared Wix Bookings service-price formatter for himi workers (#816).
+//
+// One door for turning a Wix Bookings SERVICE payload into a display price
+// string, so the four consuming workers (himi-booking-services,
+// himi-booking-service, himi-booking-time, himi-branded-lite-home) can never
+// drift apart again. Each used to read `payment.price ?? service.price` and
+// default the currency to "USD" — but the live Bookings v2 payload nests the
+// fixed price under `payment.fixed.price.{value,currency}` (Money; `value` is a
+// decimal string), so on a real ILS site the amount rendered blank (the flat
+// fields are absent) or, once decoded, in the wrong "$" currency (the ₪ was
+// dropped). This helper reads the v2 nested shape FIRST and derives the currency
+// FROM THE RECORD, falling back to the legacy/flat shapes for older payloads.
+//
+// Pure + dependency-free (structural `unknown` input, no SDK import) so it bundles
+// into every worker and gen-templates copies it verbatim into each tier5-src.
+
+import { formatCurrency } from "../_shared/engine-intl.js";
+/** Coerce a number or numeric string to a finite number, else undefined. */
+function numberOf(value: unknown): number | undefined {
+  if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+  if (typeof value === "string" && value.trim()) {
+    const n = Number(value);
+    return Number.isNaN(n) ? undefined : n;
+  }
+  return undefined;
+}
+
+/** Non-empty trimmed string, else "". */
+function stringOf(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+type LooseService = {
+  payment?: {
+    rateType?: unknown;
+    fixed?: { price?: { value?: unknown; amount?: unknown; currency?: unknown } };
+    price?: unknown;
+    currency?: unknown;
+  };
+  price?: unknown;
+  currency?: unknown;
+};
+
+/**
+ * The numeric price amount for a service, following the same v2-first priority
+ * as {@link formatServicePrice}. Returns undefined when there is no usable
+ * amount or the rate type is non-FIXED — callers use it for "is this a paid
+ * service?" decisions so the flag never disagrees with the rendered price.
+ */
+export function serviceAmount(service: unknown): number | undefined {
+  const s = (service ?? {}) as LooseService;
+  const payment = s.payment ?? {};
+
+  // A declared non-FIXED rate type (VARIED/CUSTOM/NO_FEE) carries no single fixed
+  // amount. An ABSENT rateType (legacy/flat payloads) is NOT treated as non-FIXED.
+  const rateType = stringOf(payment.rateType).toUpperCase();
+  if (rateType && rateType !== "FIXED") return undefined;
+
+  const fixed = payment.fixed?.price;
+  return numberOf(fixed?.value ?? fixed?.amount ?? payment.price ?? s.price);
+}
+
+/**
+ * The currency for a service, derived FROM THE RECORD (v2 nested first, then
+ * legacy nested, then top-level). "USD" is only the absolute last resort when
+ * no currency is present anywhere — it never overrides one the record carries.
+ */
+export function serviceCurrency(service: unknown): string {
+  const s = (service ?? {}) as LooseService;
+  const payment = s.payment ?? {};
+  return (
+    stringOf(payment.fixed?.price?.currency) ||
+    stringOf(payment.currency) ||
+    stringOf(s.currency) ||
+    "USD"
+  );
+}
+
+/**
+ * Whether money is due for this service — a MONEY decision, deliberately not the same
+ * predicate as "do we have a number to display".
+ *
+ * `serviceAmount` returns undefined for any non-FIXED rate type, which is right for
+ * display (there is no single figure to render) and wrong for routing: a VARIED or CUSTOM
+ * service is chargeable, it just has no fixed figure. Deriving "is this paid?" from
+ * `serviceAmount() > 0` therefore sent such a booking down the FREE branch — booked, never
+ * charged. `NO_FEE` is the one non-FIXED type that really is free.
+ *
+ * Fails toward charging: the checkout path already degrades gracefully when nothing is
+ * actually owed (no `paymentGatewayOrderId` ⇒ it completes the booking and stops), so a
+ * false positive costs nothing while a false negative gives the service away.
+ */
+export function serviceIsChargeable(service: unknown): boolean {
+  const s = (service ?? {}) as LooseService;
+  const rateType = stringOf(s.payment?.rateType).toUpperCase();
+  if (rateType === "NO_FEE") return false;
+  if (rateType && rateType !== "FIXED") return true; // VARIED / CUSTOM: priced, just not fixed
+  const amount = serviceAmount(service);
+  return amount != null && amount > 0;
+}
+
+/**
+ * Format one Bookings v2 Money value (`{ value, currency }`, `value` a decimal string) — a
+ * price, a deposit, a VARIED minimum, a cancellation fee. A whole amount drops its cents
+ * ("₪90", not "₪90.00"), as the service screen shows it. "" when it carries no usable
+ * amount. The currency comes from the Money itself, then from `fallbackCurrency`.
+ */
+export function formatServiceMoney(money: unknown, fallbackCurrency = "USD"): string {
+  const m = (money ?? {}) as { value?: unknown; amount?: unknown; currency?: unknown };
+  const amount = numberOf(m.value ?? m.amount);
+  if (amount == null) return "";
+  const currency = stringOf(m.currency) || fallbackCurrency;
+  try {
+    return formatCurrency(amount, currency, undefined, Number.isInteger(amount) ? 0 : undefined);
+  } catch {
+    return `${amount}`;
+  }
+}
+
+/**
+ * Format a Wix Bookings service's price for display, e.g. "₪111" / "$20" / "$19.50".
+ *
+ * Reads, in order of preference:
+ *   1. Bookings v2 fixed price — `payment.fixed.price.{value,currency}` (the
+ *      live shape; `value`/`amount` is a decimal string, currency is real).
+ *   2. Legacy nested — `payment.price` / `payment.currency`.
+ *   3. Top-level — `service.price` / `service.currency`.
+ *
+ * The currency is ALWAYS derived from the record; "USD" is only the absolute
+ * last resort when no currency is present anywhere (so behavior is unchanged
+ * when the data simply carries none). A non-FIXED `rateType`
+ * (VARIED/CUSTOM/NO_FEE) has no single amount to show → returns "".
+ * Returns "" (never throws) when there is no usable numeric amount.
+ */
+export function formatServicePrice(service: unknown): string {
+  const amount = serviceAmount(service);
+  if (amount == null) return "";
+  const currency = serviceCurrency(service);
+  try {
+    // A whole amount drops its cents ("₪70", not "₪70.00"), as formatServiceMoney and the service
+    // screen show it, so the same service reads the same price on every screen.
+    return formatCurrency(amount, currency, undefined, Number.isInteger(amount) ? 0 : undefined);
+  } catch {
+    return `${amount}`;
+  }
+}