@fullgrainsoftware/portal 0.12.0 → 0.13.0

package/README.md

@@ -49,6 +49,55 @@ export default defineSite({
 
 A repeatable section whose items are mostly a picture can take photos in bulk from the panel: set `batchUpload: true` (the section has exactly one image field) or `batchUpload: "<image field key>"`. Each picked image becomes one item with every other field empty, so no other field of that section may be `required`.
 
+### Menu pages
+
+A restaurant's menu is a page with `kind: "menu"`. The panel then gives the
+client a **Menu** page for it: every repeatable section as an editable table
+(one row per item, one column per field), a dropdown for each field that
+declares `options`, export to a spreadsheet (Excel or CSV) and import from one
+with a reviewed diff the client confirms, and undo of the last import.
+Non-menu pages are edited exactly as before.
+
+```ts
+{ slug: "/menu", title: "Menu", kind: "menu", sections: [
+  { key: "originals", title: "Lost Originals", kind: "repeatable", fields: {
+      name: { label: "Name", type: "text", required: true },
+      ingredients: { label: "Ingredients", type: "text" },
+      strength: { label: "Strength", type: "text", options: ["None", "Strong", "Really Strong"], default: "None" },
+      note: { label: "Note", type: "text" },
+      price: { label: "Price", type: "text" },
+  } },
+  { key: "rum", title: "Rum", kind: "repeatable", fields: {
+      name: { label: "Name", type: "text", required: true },
+      "price-15": { label: "1.5 oz", type: "text" },
+      "price-30": { label: "3 oz", type: "text" },
+  } },
+] }
+```
+
+Rules (checked by `siteManifestSchema`, so `fullgrain sync` refuses a manifest
+that breaks one):
+
+- A menu page needs at least one repeatable section. Singleton sections are
+  allowed beside them (a section's own price or rules).
+- Each repeatable section on a menu page needs a `text` field. Its **first**
+  text field, in the order you declare them, is the item's name: the table's
+  row title, the item name in the panel, and the key an imported spreadsheet
+  row is matched by. A seed item's `name` must equal its value for that field
+  (or the field's `default` when the seed leaves it out).
+- `options` (a dropdown's allowed values) goes on `type: "text"` fields only,
+  on any page: 2–50 values, each trimmed, non-empty and at most 60 characters,
+  and no two the same ignoring case and spaces ("Strong" and "strong " are
+  one value). A `default` and every seed value for that field must be one of
+  the options, spelled exactly.
+- A field with `options` still reads as a `string`. The list constrains the
+  panel's editing and import (a typed "strong" becomes "Strong"); a stored
+  value outside the list is possible — say, after the list changes — and the
+  panel shows it as-is with a warning rather than rewriting it. Changing a
+  field's `options` never touches stored values.
+- Prices stay text fields (the site parses them), so "MP", "15/28" and
+  "Market" are all fine.
+
 ## Read content in your pages
 
 ```tsx
@@ -293,6 +342,98 @@ page); a site that wants its own can set a manage URL in the panel and call
 should pass back the `version` it rendered (`cancel(token, { version: booking.version })`)
 so a stale page can't act on a booking that changed since it loaded.
 
+## Business (hours, details, closures)
+
+For sites whose client keeps their hours and closures in the panel. While
+Business is switched on for the site, the content payload carries a
+`website.business` block: name, address, display phone, email, the IANA
+`timezone`, weekly `hours`, an `hoursNote`, and the current and upcoming
+`closures`. It refreshes on the same revalidate ping as any content edit.
+
+```ts
+import { readBusiness, type CMSBusiness } from "@fullgrainsoftware/portal";
+
+// lib/cms.ts — through the same cached fetch as the content
+export async function getBusiness(): Promise<CMSBusiness | null> {
+  const websiteId = process.env.WEBSITE_ID;
+  if (!websiteId) return null;
+  try {
+    return readBusiness((await getPublicSiteData(websiteId)).website);
+  } catch (err) {
+    console.error("[cms] business fetch failed:", err);
+    return null;
+  }
+}
+```
+
+`readBusiness` never throws: seed mode, Business switched off, an older
+panel, or a malformed block all give `null` (keep code-owned hours to fall
+back on); a malformed day, window or closure is dropped on its own. Hours are
+`{ mon: [["17:00", "23:00"]], … }` with `sun … sat` keys; a day absent or
+empty is closed, and an end at or before its start runs into the next day:
+`["17:00", "00:00"]` closes at midnight, `["17:00", "02:00"]` at 2 AM.
+
+**The open badge is a client leaf.** `businessStatus(business, now)` is
+pure and works in the business's zone (an unknown zone reads as UTC), but it
+depends on the clock, so render a fixed-size placeholder on the server and
+fill it in after mount — size the placeholder for the longest label it will
+hold:
+
+```tsx
+"use client";
+import { useSyncExternalStore } from "react";
+import { businessStatus, type CMSBusiness } from "@fullgrainsoftware/portal";
+
+const subscribe = (tick: () => void) => {
+  const id = setInterval(tick, 30_000);
+  return () => clearInterval(id);
+};
+const minute = () => Math.floor(Date.now() / 60_000);
+// closesAt is 24-hour "HH:MM" local time: "23:00" → "11 PM", "17:30" → "5:30 PM"
+const formatTime = (hhmm: string) => {
+  const [h, m] = hhmm.split(":").map(Number);
+  return `${h % 12 || 12}${m ? `:${String(m).padStart(2, "0")}` : ""} ${h < 12 ? "AM" : "PM"}`;
+};
+
+export function OpenBadge({ business }: { business: CMSBusiness }) {
+  const now = useSyncExternalStore(subscribe, minute, () => null);   // null on the server and the first client render
+  const status = now === null ? null : businessStatus(business, new Date(now * 60_000));
+  const label = !status ? " " : status.state === "open" ? (status.closesAt ? `Open until ${formatTime(status.closesAt)}` : "Open") : "Closed";
+  return <span className="inline-block min-w-[16ch]">{label}</span>;
+}
+```
+
+`BusinessStatus` is `{ state: "open", closesAt }` (`"HH:MM"` local, or
+`null` when open around the clock) or `{ state: "closed", because:
+"hours" | "closure", closure?, reopens }`, where `reopens` is `{ date, time }`
+within the next 14 days or `null`. `because` is `"closure"` only when the
+hours alone would have it open now; an all-day closure closes that date's
+windows, their run past midnight included, but never the previous night's
+late close. `todaysClosures(business, now)` lists the closures touching the
+local date, all-day first, for a "tonight: private event 6–10 PM" notice
+while still open.
+
+**Closure copy.** `describeClosure(closure)` gives plain default wording
+per `reason` (`private_event` "Closed for a private event", `holiday`
+"Closed for the holiday", `weather` "Closed due to weather", `maintenance`
+"Closed for maintenance", `staffing` "Closed today", `other` the client's
+`message` or "Closed"). A site with its own voice switches on the reason and
+keeps the default for the rest:
+
+```ts
+const headline = closure.reason === "private_event" ? "Under Private Charter" : describeClosure(closure);
+const when = formatWindow(closure); // "6–10 PM"; "18:00–22:00" with { hour12: false }; null when all day
+```
+
+**Structured data.** `openingHoursSpecification(business)` returns the
+schema.org `OpeningHoursSpecification` entries for your JSON-LD, one per
+distinct window with the days that share it (`dayOfWeek: ["Wednesday",
+"Thursday"], opens: "17:00", closes: "23:00"`); an overnight close stays
+verbatim (`closes: "02:00"`), which is how schema.org reads it. A 24-hour
+day (`["00:00", "00:00"]`) is emitted as `closes: "23:59"`, since Google reads
+`opens` equal to `closes` at midnight as closed all day. Closures are never
+emitted.
+
 ## Reviews
 
 For sites with a review form. Submit reviews through `createInquiries` with

package/dist/business.d.ts

@@ -0,0 +1,39 @@
+import type { CMSBusiness, CMSClosure, CMSWebsite } from "./cms-types.js";
+export type BusinessStatus = {
+    state: "open";
+    closesAt: string | null;
+} | {
+    state: "closed";
+    because: "hours" | "closure";
+    closure?: CMSClosure;
+    reopens: {
+        date: string;
+        time: string;
+    } | null;
+};
+export declare function readBusiness(website: CMSWebsite | null | undefined): CMSBusiness | null;
+export declare function businessStatus(business: CMSBusiness, now?: Date): BusinessStatus;
+/** The closures touching the business's local date today, all-day first —
+ *  for a "tonight: private event 6–10 PM" notice while still open. */
+export declare function todaysClosures(business: CMSBusiness, now?: Date): CMSClosure[];
+/** Plain default copy for a closure. A site with its own voice switches on
+ *  `closure.reason` and uses this as the fallback. */
+export declare function describeClosure(closure: CMSClosure): string;
+/** A closure window as "6–10 PM" (or "18:00–22:00" with hour12: false);
+ *  null for an all-day closure. Formatted by hand, so there is no U+202F
+ *  before the meridiem as Intl would put there. */
+export declare function formatWindow(closure: CMSClosure, opts?: {
+    hour12?: boolean;
+}): string | null;
+/** schema.org OpeningHoursSpecification entries for JSON-LD, one per
+ *  distinct window with the days that share it (Monday first). An overnight
+ *  window keeps its end verbatim (closes "02:00"), as schema.org reads it. A
+ *  24-hour window (end equal to start, e.g. ["00:00", "00:00"]) closes
+ *  "23:59": Google reads opens "00:00" closes "00:00" as closed all day.
+ *  Closures are never emitted. */
+export declare function openingHoursSpecification(business: CMSBusiness): Array<{
+    "@type": "OpeningHoursSpecification";
+    dayOfWeek: string[];
+    opens: string;
+    closes: string;
+}>;

package/dist/business.js

@@ -0,0 +1,325 @@
+/** Sunday first: the weekday index math below depends on this order. */
+const WEEKDAYS = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+const CLOSURE_REASONS = ["private_event", "holiday", "weather", "maintenance", "staffing", "other"];
+const DAY = 1440;
+const HORIZON_DAYS = 14;
+const DATE_SHAPE = /^(\d{4})-(\d{2})-(\d{2})$/;
+const TIME_SHAPE = /^(\d{2}):(\d{2})$/;
+/* ---------- zone math (Intl, no library) ---------- */
+const formatters = new Map();
+function formatter(tz) {
+    let f = formatters.get(tz);
+    if (!f) {
+        f = new Intl.DateTimeFormat("en-US", {
+            timeZone: tz,
+            hourCycle: "h23",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            weekday: "short",
+        });
+        formatters.set(tz, f);
+    }
+    return f;
+}
+function isValidTimeZone(tz) {
+    if (typeof tz !== "string" || !tz)
+        return false;
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: tz });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function localParts(instant, tz) {
+    const parts = {};
+    for (const p of formatter(tz).formatToParts(instant))
+        parts[p.type] = p.value;
+    const hour = parts.hour === "24" ? "00" : parts.hour;
+    return {
+        date: `${parts.year}-${parts.month}-${parts.day}`,
+        time: `${hour}:${parts.minute}`,
+        weekday: parts.weekday.toLowerCase().slice(0, 3),
+    };
+}
+function addLocalDays(date, n) {
+    const dm = DATE_SHAPE.exec(date);
+    if (!dm)
+        throw new Error(`bad date ${date}`);
+    return new Date(Date.UTC(+dm[1], +dm[2] - 1, +dm[3] + n)).toISOString().slice(0, 10);
+}
+/* ---------- minute spans ---------- */
+function toMinutes(hhmm) {
+    const m = TIME_SHAPE.exec(hhmm);
+    if (!m)
+        return null;
+    const h = +m[1];
+    const min = +m[2];
+    if (min > 59)
+        return null;
+    if (h === 24)
+        return min === 0 ? DAY : null;
+    if (h > 23)
+        return null;
+    return h * 60 + min;
+}
+const isTime = (v) => typeof v === "string" && toMinutes(v) !== null;
+/** A window's start: any HH:MM but "24:00", which is only ever an end. */
+const isStartTime = (v) => isTime(v) && toMinutes(v) < DAY;
+function subtractSpans(base, blocked) {
+    let out = base.slice();
+    for (const [bs, be] of blocked) {
+        const next = [];
+        for (const [s, e] of out) {
+            if (be <= s || bs >= e) {
+                next.push([s, e]);
+                continue;
+            }
+            if (bs > s)
+                next.push([s, bs]);
+            if (be < e)
+                next.push([be, e]);
+        }
+        out = next;
+    }
+    return out;
+}
+function windowSpans(windows) {
+    if (!Array.isArray(windows))
+        return [];
+    const out = [];
+    for (const w of windows) {
+        if (!Array.isArray(w) || typeof w[0] !== "string" || typeof w[1] !== "string")
+            continue;
+        const s = toMinutes(w[0]);
+        const e = toMinutes(w[1]);
+        if (s === null || e === null || s >= DAY)
+            continue;
+        out.push([s, e <= s ? e + DAY : e]);
+    }
+    return out;
+}
+const covers = (c, date) => typeof c.from === "string" && typeof c.to === "string" && c.from <= date && date <= c.to;
+const isAllDay = (c) => c.start == null && c.end == null;
+/** A closure window's span on `date` in that date's minutes, or null when it
+ *  does not cover the date, is all day, or its times are malformed. */
+function windowClosureSpan(c, date) {
+    if (!covers(c, date) || isAllDay(c))
+        return null;
+    const s = typeof c.start === "string" ? toMinutes(c.start) : null;
+    const e = typeof c.end === "string" ? toMinutes(c.end) : null;
+    if (s === null || e === null || e <= s)
+        return null;
+    return [s, e];
+}
+function union(spans) {
+    const sorted = spans.slice().sort((a, b) => a[0] - b[0]);
+    const out = [];
+    for (const [s, e] of sorted) {
+        const last = out[out.length - 1];
+        if (last && s <= last[1])
+            last[1] = Math.max(last[1], e);
+        else
+            out.push([s, e]);
+    }
+    return out;
+}
+const clock = (minutes) => {
+    const m = ((minutes % DAY) + DAY) % DAY;
+    return `${String(Math.floor(m / 60)).padStart(2, "0")}:${String(m % 60).padStart(2, "0")}`;
+};
+const inside = (spans, t) => spans.find(([s, e]) => s <= t && t < e);
+/** All-day closures first, then by start time; otherwise input order. An
+ *  all-day closure's start is null, read as "", which sorts before any HH:MM. */
+const byAllDayThenStart = (a, b) => (a.start ?? "").localeCompare(b.start ?? "");
+function localNow(business, now) {
+    return localParts(now, isValidTimeZone(business.timezone) ? business.timezone : "UTC");
+}
+const closuresOf = (business) => (Array.isArray(business.closures) ? business.closures.filter(Boolean) : []);
+/* ---------- reader ---------- */
+const isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function readAddress(value) {
+    if (!isObject(value))
+        return null;
+    const { street, unit, city, region, postalCode, country } = value;
+    if (![street, unit, city, region, postalCode, country].every((v) => typeof v === "string"))
+        return null;
+    return { street, unit, city, region, postalCode, country };
+}
+function readHours(value) {
+    const out = {};
+    for (const [day, windows] of Object.entries(value)) {
+        if (!WEEKDAYS.includes(day) || !Array.isArray(windows))
+            continue;
+        out[day] = windows
+            .filter((w) => Array.isArray(w) && w.length === 2 && isStartTime(w[0]) && isTime(w[1]))
+            .map(([s, e]) => [s, e]);
+    }
+    return out;
+}
+function readClosure(value) {
+    if (!isObject(value))
+        return null;
+    const { id, from, to, start, end, reason, message } = value;
+    if (typeof id !== "string" || typeof message !== "string")
+        return null;
+    if (typeof from !== "string" || typeof to !== "string" || !DATE_SHAPE.test(from) || !DATE_SHAPE.test(to))
+        return null;
+    if (!CLOSURE_REASONS.includes(reason))
+        return null;
+    const allDay = start === null && end === null;
+    // A closure window never wraps past midnight: an end at or before its
+    // start (or a "24:00" start) is dropped, as the status algorithm ignores it.
+    if (!allDay && !(isStartTime(start) && isTime(end) && toMinutes(end) > toMinutes(start)))
+        return null;
+    return { id, from, to, start: allDay ? null : start, end: allDay ? null : end, reason: reason, message };
+}
+export function readBusiness(website) {
+    const raw = website?.business;
+    if (!isObject(raw))
+        return null;
+    const { name, phone, email, timezone, hoursNote, hours, closures } = raw;
+    if (![name, phone, email, timezone, hoursNote].every((v) => typeof v === "string"))
+        return null;
+    const address = readAddress(raw.address);
+    if (!address || !isObject(hours) || !Array.isArray(closures))
+        return null;
+    return {
+        name: name,
+        address,
+        phone: phone,
+        email: email,
+        timezone: timezone,
+        hours: readHours(hours),
+        hoursNote: hoursNote,
+        closures: closures.map(readClosure).filter((c) => c !== null),
+    };
+}
+/* ---------- status ---------- */
+export function businessStatus(business, now = new Date()) {
+    const local = localNow(business, now);
+    const nowMin = toMinutes(local.time) ?? 0;
+    const todayIndex = WEEKDAYS.indexOf(local.weekday);
+    const hours = business.hours && typeof business.hours === "object" ? business.hours : {};
+    const closures = closuresOf(business);
+    const open = [];
+    const shut = [];
+    const cut = [];
+    for (let k = -1; k <= HORIZON_DAYS; k++) {
+        const date = addLocalDays(local.date, k);
+        const weekday = WEEKDAYS[(todayIndex + k + 7) % 7];
+        const base = k * DAY;
+        const allDay = closures.filter((c) => isAllDay(c) && covers(c, date));
+        for (const [s, e] of windowSpans(hours[weekday])) {
+            const span = [base + s, base + e];
+            if (allDay.length)
+                for (const closure of allDay)
+                    shut.push({ span, closure });
+            else
+                open.push(span);
+        }
+        for (const c of closures) {
+            const span = windowClosureSpan(c, date);
+            if (span)
+                cut.push({ span: [base + span[0], base + span[1]], closure: c });
+        }
+    }
+    const remaining = subtractSpans(union(open), union(cut.map((x) => x.span)));
+    const horizonEnd = (HORIZON_DAYS + 1) * DAY;
+    const current = inside(remaining, nowMin);
+    if (current)
+        return { state: "open", closesAt: current[1] >= horizonEnd ? null : clock(current[1]) };
+    const next = remaining.find(([s]) => s > nowMin);
+    const reopens = next ? { date: addLocalDays(local.date, Math.floor(next[0] / DAY)), time: clock(next[0]) } : null;
+    if (inside(union([...open, ...shut.map((x) => x.span)]), nowMin)) {
+        const covering = [...shut, ...cut]
+            .filter(({ span }) => span[0] <= nowMin && nowMin < span[1])
+            .map((x) => x.closure)
+            .sort(byAllDayThenStart);
+        if (covering.length)
+            return { state: "closed", because: "closure", closure: covering[0], reopens };
+    }
+    return { state: "closed", because: "hours", reopens };
+}
+/** The closures touching the business's local date today, all-day first —
+ *  for a "tonight: private event 6–10 PM" notice while still open. */
+export function todaysClosures(business, now = new Date()) {
+    const { date } = localNow(business, now);
+    return closuresOf(business)
+        .filter((c) => covers(c, date))
+        .sort(byAllDayThenStart);
+}
+/* ---------- copy and structured data ---------- */
+const CLOSURE_COPY = {
+    private_event: "Closed for a private event",
+    holiday: "Closed for the holiday",
+    weather: "Closed due to weather",
+    maintenance: "Closed for maintenance",
+    staffing: "Closed today",
+};
+/** Plain default copy for a closure. A site with its own voice switches on
+ *  `closure.reason` and uses this as the fallback. */
+export function describeClosure(closure) {
+    if (closure.reason !== "other" && Object.hasOwn(CLOSURE_COPY, closure.reason))
+        return CLOSURE_COPY[closure.reason];
+    const message = typeof closure.message === "string" ? closure.message.trim() : "";
+    return message || "Closed";
+}
+/** A closure window as "6–10 PM" (or "18:00–22:00" with hour12: false);
+ *  null for an all-day closure. Formatted by hand, so there is no U+202F
+ *  before the meridiem as Intl would put there. */
+export function formatWindow(closure, opts = {}) {
+    const { start, end } = closure;
+    if (!isTime(start) || !isTime(end))
+        return null;
+    if (opts.hour12 === false)
+        return `${start}–${end}`;
+    const part = (hhmm) => {
+        const total = toMinutes(hhmm);
+        const h = Math.floor(total / 60) % 24;
+        const m = total % 60;
+        const h12 = h % 12 || 12;
+        return { text: m ? `${h12}:${String(m).padStart(2, "0")}` : String(h12), meridiem: h < 12 ? "AM" : "PM" };
+    };
+    const a = part(start);
+    const b = part(end);
+    return a.meridiem === b.meridiem ? `${a.text}–${b.text} ${b.meridiem}` : `${a.text} ${a.meridiem}–${b.text} ${b.meridiem}`;
+}
+const SCHEMA_DAYS = [
+    ["mon", "Monday"],
+    ["tue", "Tuesday"],
+    ["wed", "Wednesday"],
+    ["thu", "Thursday"],
+    ["fri", "Friday"],
+    ["sat", "Saturday"],
+    ["sun", "Sunday"],
+];
+/** schema.org OpeningHoursSpecification entries for JSON-LD, one per
+ *  distinct window with the days that share it (Monday first). An overnight
+ *  window keeps its end verbatim (closes "02:00"), as schema.org reads it. A
+ *  24-hour window (end equal to start, e.g. ["00:00", "00:00"]) closes
+ *  "23:59": Google reads opens "00:00" closes "00:00" as closed all day.
+ *  Closures are never emitted. */
+export function openingHoursSpecification(business) {
+    const hours = business.hours && typeof business.hours === "object" ? business.hours : {};
+    const groups = new Map();
+    for (const [day, dayName] of SCHEMA_DAYS) {
+        const windows = Array.isArray(hours[day]) ? hours[day] : [];
+        const valid = windows
+            .filter((w) => Array.isArray(w) && isTime(w[0]) && isTime(w[1]) && toMinutes(w[0]) < DAY)
+            .sort((x, y) => toMinutes(x[0]) - toMinutes(y[0]));
+        for (const [opens, end] of valid) {
+            const closes = toMinutes(end) === toMinutes(opens) ? "23:59" : end;
+            const key = `${opens}|${closes}`;
+            const group = groups.get(key) ?? { opens, closes, days: [] };
+            if (!group.days.includes(dayName))
+                group.days.push(dayName);
+            groups.set(key, group);
+        }
+    }
+    return [...groups.values()].map((g) => ({ "@type": "OpeningHoursSpecification", dayOfWeek: g.days, opens: g.opens, closes: g.closes }));
+}

package/dist/cms-types.d.ts

@@ -83,6 +83,49 @@ export type CMSReview = {
     /** ISO 8601, UTC. */
     createdAt: string;
 };
+/** Why a business is closed (panel business spec 2026-10-26 §3.1). */
+export type ClosureReason = "private_event" | "holiday" | "weather" | "maintenance" | "staffing" | "other";
+/** One closure, in the business's local dates and wall times. `start` and
+ *  `end` are both null for an all-day closure; a window is "HH:MM" on a single
+ *  date (`end` may be "24:00"). `message` is public copy, possibly empty. */
+export type CMSClosure = {
+    id: string;
+    /** "YYYY-MM-DD", inclusive. */
+    from: string;
+    /** "YYYY-MM-DD", inclusive. */
+    to: string;
+    start: string | null;
+    end: string | null;
+    reason: ClosureReason;
+    message: string;
+};
+export type CMSBusinessAddress = {
+    street: string;
+    unit: string;
+    city: string;
+    /** State or province. */
+    region: string;
+    postalCode: string;
+    /** ISO 3166-1 alpha-2. */
+    country: string;
+};
+/** Opening windows per weekday as ["HH:MM", "HH:MM"] pairs; a day absent or
+ *  empty is closed. An end at or before its start runs into the next day
+ *  (["17:00", "02:00"] closes at 2 AM). */
+export type CMSBusinessHours = Partial<Record<"mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun", Array<[string, string]>>>;
+/** The business block (panel business spec 2026-10-26 §5.1). `phone` is the
+ *  display form; `closures` are the current and upcoming ones. */
+export type CMSBusiness = {
+    name: string;
+    address: CMSBusinessAddress;
+    phone: string;
+    email: string;
+    /** IANA zone the hours and closures are written in. */
+    timezone: string;
+    hours: CMSBusinessHours;
+    hoursNote: string;
+    closures: CMSClosure[];
+};
 export type CMSWebsite = {
     id: string;
     user_id: string;
@@ -93,6 +136,8 @@ export type CMSWebsite = {
     pages: CMSPage[];
     /** Present only when the site has reviews switched on in the panel; read it with readReviews. */
     reviews?: CMSReview[];
+    /** Present only when the site has Business switched on in the panel; read it with readBusiness. */
+    business?: CMSBusiness;
 };
 export type PublicSiteData = {
     website: CMSWebsite;

package/dist/index.d.ts

@@ -4,7 +4,9 @@ export { readSiteContent, cmsItemProps } from "./reader.js";
 export type { SiteContent, CmsItemMeta } from "./reader.js";
 export { fetchPublicSiteData } from "./cms-client.js";
 export { readReviews } from "./reviews.js";
-export type { CMSComponent, CMSPage, CMSReview, CMSSection, CMSSectionGroup, CMSStaticRendition, CMSVideo, CMSWebsite, PublicSiteData, } from "./cms-types.js";
+export { businessStatus, describeClosure, formatWindow, openingHoursSpecification, readBusiness, todaysClosures, } from "./business.js";
+export type { BusinessStatus } from "./business.js";
+export type { CMSBusiness, CMSBusinessAddress, CMSBusinessHours, CMSClosure, CMSComponent, CMSPage, CMSReview, CMSSection, CMSSectionGroup, CMSStaticRendition, CMSVideo, CMSWebsite, ClosureReason, PublicSiteData, } from "./cms-types.js";
 export { createCommerce } from "./commerce.js";
 export type { CartPreview, CheckoutInput, CheckoutResult, Commerce, LineIssue, OrderStatus, ProductDetail, ProductSummary, StoreStatus, VariantView, } from "./commerce.js";
 export { createInquiries } from "./inquiries.js";

package/dist/index.js

@@ -2,6 +2,7 @@ export { defineSite, siteManifestSchema } from "./manifest.js";
 export { readSiteContent, cmsItemProps } from "./reader.js";
 export { fetchPublicSiteData } from "./cms-client.js";
 export { readReviews } from "./reviews.js";
+export { businessStatus, describeClosure, formatWindow, openingHoursSpecification, readBusiness, todaysClosures, } from "./business.js";
 export { createCommerce } from "./commerce.js";
 export { createInquiries } from "./inquiries.js";
 export { initCmsPreview, normalizeSectionTitle, parseInbound, readyMessage, sectionClickedMessage, editItemMessage, PREVIEW_PROTOCOL_VERSION, PREVIEW_QUERY_FLAG, } from "./preview.js";

package/dist/manifest.d.ts

@@ -8,6 +8,13 @@ export interface ManifestField {
     allowTypeChange?: boolean;
     allowedTypes?: readonly FieldType[];
     generateMp4?: boolean;
+    /**
+     * A dropdown's allowed values (text fields only, 2–50, unique ignoring case
+     * and spaces). The panel edits the field as a dropdown and checks imported
+     * values against the list. The field still reads as a `string`: a stored
+     * value outside the list is possible and is shown as-is.
+     */
+    options?: readonly string[];
 }
 export interface ManifestSeedItem {
     name: string;
@@ -31,6 +38,13 @@ export interface ManifestSection {
 export interface ManifestPage {
     slug: string;
     title: string;
+    /**
+     * `"menu"` gives the client the panel's Menu page for this page: every
+     * repeatable section as an editable table, spreadsheet export and import.
+     * Needs at least one repeatable section; each repeatable section's first
+     * text field names its items.
+     */
+    kind?: "menu";
     sections: readonly ManifestSection[];
 }
 export interface SiteManifest {
@@ -40,9 +54,10 @@ export interface SiteManifest {
 export declare function defineSite<const T extends SiteManifest>(manifest: T): T;
 export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
     alias: z.ZodString;
-    pages: z.ZodArray<z.ZodObject<{
+    pages: z.ZodArray<z.ZodEffects<z.ZodObject<{
         slug: z.ZodString;
         title: z.ZodString;
+        kind: z.ZodOptional<z.ZodLiteral<"menu">>;
         sections: z.ZodArray<z.ZodEffects<z.ZodObject<{
             key: z.ZodString;
             title: z.ZodString;
@@ -57,12 +72,14 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 allowTypeChange: z.ZodOptional<z.ZodBoolean>;
                 allowedTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["text", "image", "color", "audio", "video"]>, "many">>;
                 generateMp4: z.ZodOptional<z.ZodBoolean>;
+                options: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
             }, "strict", z.ZodTypeAny, {
                 label: string;
                 type: "text" | "image" | "color" | "audio" | "video";
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }, {
@@ -71,6 +88,7 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>>;
@@ -78,11 +96,11 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 name: z.ZodString;
                 values: z.ZodRecord<z.ZodString, z.ZodString>;
             }, "strict", z.ZodTypeAny, {
-                values: Record<string, string>;
                 name: string;
-            }, {
                 values: Record<string, string>;
+            }, {
                 name: string;
+                values: Record<string, string>;
             }>, "many">>;
         }, "strict", z.ZodTypeAny, {
             key: string;
@@ -94,14 +112,15 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
-                values: Record<string, string>;
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }, {
             key: string;
@@ -113,14 +132,15 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
-                values: Record<string, string>;
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }>, {
             key: string;
@@ -132,14 +152,15 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
-                values: Record<string, string>;
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }, {
             key: string;
@@ -151,14 +172,15 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
-                values: Record<string, string>;
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }>, "many">;
     }, "strict", z.ZodTypeAny, {
@@ -174,16 +196,18 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
-                values: Record<string, string>;
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }[];
+        kind?: "menu" | undefined;
     }, {
         title: string;
         slug: string;
@@ -197,16 +221,68 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
+                name: string;
                 values: Record<string, string>;
+            }[] | undefined;
+        }[];
+        kind?: "menu" | undefined;
+    }>, {
+        title: string;
+        slug: string;
+        sections: {
+            key: string;
+            title: string;
+            kind: "repeatable" | "singleton";
+            fields: Record<string, {
+                label: string;
+                type: "text" | "image" | "color" | "audio" | "video";
+                default?: string | undefined;
+                required?: boolean | undefined;
+                allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
+                allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
+                generateMp4?: boolean | undefined;
+            }>;
+            allowGroupCreation?: boolean | undefined;
+            batchUpload?: string | true | undefined;
+            seed?: {
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }[];
+        kind?: "menu" | undefined;
+    }, {
+        title: string;
+        slug: string;
+        sections: {
+            key: string;
+            title: string;
+            kind: "repeatable" | "singleton";
+            fields: Record<string, {
+                label: string;
+                type: "text" | "image" | "color" | "audio" | "video";
+                default?: string | undefined;
+                required?: boolean | undefined;
+                allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
+                allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
+                generateMp4?: boolean | undefined;
+            }>;
+            allowGroupCreation?: boolean | undefined;
+            batchUpload?: string | true | undefined;
+            seed?: {
+                name: string;
+                values: Record<string, string>;
+            }[] | undefined;
+        }[];
+        kind?: "menu" | undefined;
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
     alias: string;
@@ -223,16 +299,18 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
-                values: Record<string, string>;
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }[];
+        kind?: "menu" | undefined;
     }[];
 }, {
     alias: string;
@@ -249,16 +327,18 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
-                values: Record<string, string>;
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }[];
+        kind?: "menu" | undefined;
     }[];
 }>, {
     alias: string;
@@ -275,16 +355,18 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
-                values: Record<string, string>;
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }[];
+        kind?: "menu" | undefined;
     }[];
 }, {
     alias: string;
@@ -301,15 +383,17 @@ export declare const siteManifestSchema: z.ZodEffects<z.ZodObject<{
                 default?: string | undefined;
                 required?: boolean | undefined;
                 allowTypeChange?: boolean | undefined;
+                options?: string[] | undefined;
                 allowedTypes?: ("text" | "image" | "color" | "audio" | "video")[] | undefined;
                 generateMp4?: boolean | undefined;
             }>;
             allowGroupCreation?: boolean | undefined;
             batchUpload?: string | true | undefined;
             seed?: {
-                values: Record<string, string>;
                 name: string;
+                values: Record<string, string>;
             }[] | undefined;
         }[];
+        kind?: "menu" | undefined;
     }[];
 }>;

package/dist/manifest.js

@@ -15,8 +15,12 @@ const fieldSchema = z
     allowTypeChange: z.boolean().optional(),
     allowedTypes: z.array(fieldTypeSchema).optional(),
     generateMp4: z.boolean().optional(),
+    options: z.array(z.string().trim().min(1).max(60)).optional(),
 })
     .strict();
+// The match key for options (and, in the panel, sheet, column and item names):
+// trimmed, lower-case, internal whitespace collapsed.
+const optionKey = (value) => value.trim().toLowerCase().replace(/\s+/g, " ");
 const seedItemSchema = z
     .object({
     name: z.string().trim().min(1),
@@ -107,14 +111,99 @@ const sectionSchema = z
             }
         }
     }
+    // Dropdown options: text fields only, 2–50 of them, unique by their match
+    // key. A default and every seed value must be one of them, exactly.
+    for (const [key, field] of Object.entries(section.fields)) {
+        const options = field.options;
+        if (options === undefined)
+            continue;
+        const where = `field "${key}" on section "${section.title}"`;
+        if (field.type !== "text") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `options on field "${key}" of section "${section.title}" need type: "text"`,
+            });
+        }
+        if (options.length < 2 || options.length > 50) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `${where} needs between 2 and 50 options (found ${options.length})`,
+            });
+        }
+        const seen = new Map();
+        for (const option of options) {
+            const first = seen.get(optionKey(option));
+            if (first !== undefined) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `option "${option}" of ${where} repeats "${first}" (options must differ by more than case and spaces)`,
+                });
+            }
+            else {
+                seen.set(optionKey(option), option);
+            }
+        }
+        if (field.default !== undefined && !options.includes(field.default)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `default "${field.default}" of ${where} is not one of its options`,
+            });
+        }
+        for (const item of section.seed ?? []) {
+            if (Object.hasOwn(item.values, key) && !options.includes(item.values[key])) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `seed "${item.name}" sets "${key}" to "${item.values[key]}", which is not one of its options`,
+                });
+            }
+        }
+    }
 });
 const pageSchema = z
     .object({
     slug: z.string().trim().min(1),
     title: z.string().trim().min(1),
+    kind: z.literal("menu").optional(),
     sections: z.array(sectionSchema),
 })
-    .strict();
+    .strict()
+    .superRefine((page, ctx) => {
+    if (page.kind !== "menu")
+        return;
+    // The panel's Menu page shows repeatable sections as tables; a menu page
+    // without one has nothing to show.
+    if (!page.sections.some((section) => section.kind === "repeatable")) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `menu page ${page.slug} needs at least one repeatable section`,
+        });
+    }
+    // On a menu the first text field (schema order) IS the item's name: the
+    // table's row title, the group name, the import's row key. A seed item's
+    // name must therefore equal the value seeding stores in that field.
+    for (const section of page.sections) {
+        if (section.kind !== "repeatable")
+            continue;
+        const nameEntry = Object.entries(section.fields).find(([, field]) => field.type === "text");
+        if (!nameEntry) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `section "${section.title}" on menu page ${page.slug} needs a text field (its first one names each item)`,
+            });
+            continue;
+        }
+        const [nameKey, nameField] = nameEntry;
+        for (const item of section.seed ?? []) {
+            const value = Object.hasOwn(item.values, nameKey) ? item.values[nameKey] : (nameField.default ?? "");
+            if (value !== item.name) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `seed "${item.name}" on menu section "${section.title}" must have the same name as its "${nameKey}" value ("${value}")`,
+                });
+            }
+        }
+    }
+});
 export const siteManifestSchema = z
     .object({
     alias: z.string().trim().min(1),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fullgrainsoftware/portal",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Fullgrain Portal site SDK: manifest, typed content reader, sync CLI, preview bridge, commerce, inquiries and bookings clients",
   "repository": {
     "type": "git",