@trypattern/sdk 0.1.12 → 0.1.13

package/dist/bookings.d.ts

@@ -0,0 +1,400 @@
+import { z } from 'zod';
+import type { Row } from './table.ts';
+export declare const WEEKDAYS: readonly ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+export declare const BOOKING_STATUSES: readonly ["requested", "accepted", "declined", "cancelled"];
+export declare const RULES_ID = "rules";
+export declare const DEFAULT_RULES: {
+    windows: never[];
+    leadTimeHours: number;
+    daysAhead: number;
+    autoAccept: false;
+    blackouts: never[];
+};
+export declare const bookingRules: import("./table.ts").TableOf<"bookingRules", {
+    readonly columns: {
+        readonly windows: z.ZodString;
+        readonly leadTimeHours: z.ZodNumber;
+        readonly daysAhead: z.ZodNumber;
+        readonly autoAccept: z.ZodBoolean;
+    };
+    readonly access: {
+        readonly read: "server";
+        readonly create: "server";
+        readonly update: "server";
+        readonly delete: "server";
+    };
+    readonly writes: "confirmed";
+}>;
+export declare const bookingBlackouts: import("./table.ts").TableOf<"bookingBlackouts", {
+    readonly columns: {
+        readonly date: z.ZodString;
+        readonly reason: z.ZodString;
+    };
+    readonly access: {
+        readonly read: "server";
+        readonly create: "server";
+        readonly update: "server";
+        readonly delete: "server";
+    };
+    readonly writes: "confirmed";
+}>;
+export declare const bookingRequests: import("./table.ts").TableOf<"bookingRequests", {
+    readonly columns: {
+        readonly offering: z.ZodString;
+        readonly date: z.ZodString;
+        readonly window: z.ZodString;
+        readonly name: z.ZodString;
+        readonly email: z.ZodEmail;
+        readonly phone: z.ZodString;
+        readonly address: z.ZodString;
+        readonly notes: z.ZodString;
+        readonly status: z.ZodEnum<{
+            requested: "requested";
+            accepted: "accepted";
+            declined: "declined";
+            cancelled: "cancelled";
+        }>;
+    };
+    readonly access: {
+        readonly read: "server";
+        readonly create: "server";
+        readonly update: "server";
+        readonly delete: "server";
+    };
+    readonly writes: "confirmed";
+}>;
+export declare const bookingTables: {
+    bookingRules: import("./table.ts").TableOf<"bookingRules", {
+        readonly columns: {
+            readonly windows: z.ZodString;
+            readonly leadTimeHours: z.ZodNumber;
+            readonly daysAhead: z.ZodNumber;
+            readonly autoAccept: z.ZodBoolean;
+        };
+        readonly access: {
+            readonly read: "server";
+            readonly create: "server";
+            readonly update: "server";
+            readonly delete: "server";
+        };
+        readonly writes: "confirmed";
+    }>;
+    bookingBlackouts: import("./table.ts").TableOf<"bookingBlackouts", {
+        readonly columns: {
+            readonly date: z.ZodString;
+            readonly reason: z.ZodString;
+        };
+        readonly access: {
+            readonly read: "server";
+            readonly create: "server";
+            readonly update: "server";
+            readonly delete: "server";
+        };
+        readonly writes: "confirmed";
+    }>;
+    bookingRequests: import("./table.ts").TableOf<"bookingRequests", {
+        readonly columns: {
+            readonly offering: z.ZodString;
+            readonly date: z.ZodString;
+            readonly window: z.ZodString;
+            readonly name: z.ZodString;
+            readonly email: z.ZodEmail;
+            readonly phone: z.ZodString;
+            readonly address: z.ZodString;
+            readonly notes: z.ZodString;
+            readonly status: z.ZodEnum<{
+                requested: "requested";
+                accepted: "accepted";
+                declined: "declined";
+                cancelled: "cancelled";
+            }>;
+        };
+        readonly access: {
+            readonly read: "server";
+            readonly create: "server";
+            readonly update: "server";
+            readonly delete: "server";
+        };
+        readonly writes: "confirmed";
+    }>;
+};
+export type BookingRequest = Row<typeof bookingRequests>;
+export type BookingStatus = (typeof BOOKING_STATUSES)[number];
+export type Weekday = (typeof WEEKDAYS)[number];
+export declare const bookingWindow: z.ZodObject<{
+    weekday: z.ZodEnum<{
+        Sunday: "Sunday";
+        Monday: "Monday";
+        Tuesday: "Tuesday";
+        Wednesday: "Wednesday";
+        Thursday: "Thursday";
+        Friday: "Friday";
+        Saturday: "Saturday";
+    }>;
+    label: z.ZodString;
+    start: z.ZodString;
+    end: z.ZodString;
+    capacity: z.ZodNumber;
+}, z.core.$strip>;
+export type BookingWindow = z.output<typeof bookingWindow>;
+export declare const bookingBlackout: z.ZodObject<{
+    date: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const bookingRulesReply: z.ZodObject<{
+    windows: z.ZodArray<z.ZodObject<{
+        weekday: z.ZodEnum<{
+            Sunday: "Sunday";
+            Monday: "Monday";
+            Tuesday: "Tuesday";
+            Wednesday: "Wednesday";
+            Thursday: "Thursday";
+            Friday: "Friday";
+            Saturday: "Saturday";
+        }>;
+        label: z.ZodString;
+        start: z.ZodString;
+        end: z.ZodString;
+        capacity: z.ZodNumber;
+    }, z.core.$strip>>;
+    leadTimeHours: z.ZodNumber;
+    daysAhead: z.ZodNumber;
+    autoAccept: z.ZodBoolean;
+    blackouts: z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BookingRules = z.output<typeof bookingRulesReply>;
+export declare const bookingDay: z.ZodObject<{
+    date: z.ZodString;
+    state: z.ZodEnum<{
+        open: "open";
+        closed: "closed";
+        full: "full";
+    }>;
+}, z.core.$strip>;
+export type BookingDay = z.output<typeof bookingDay>;
+export declare const bookingSlot: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    start: z.ZodString;
+    end: z.ZodString;
+    remaining: z.ZodNumber;
+}, z.core.$strip>;
+export type BookingSlot = z.output<typeof bookingSlot>;
+declare const requestShape: {
+    offering: z.ZodString;
+    date: z.ZodString;
+    window: z.ZodString;
+    name: z.ZodString;
+    email: z.ZodEmail;
+    phone: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+};
+export type BookingRequestFields = z.output<z.ZodObject<typeof requestShape>>;
+export declare const bookingServices: {
+    readonly bookings: {
+        readonly days: NoInfer<import("./services.ts").ServiceCall<"/bookings/days", {
+            month: z.ZodString;
+        }, z.ZodArray<z.ZodObject<{
+            date: z.ZodString;
+            state: z.ZodEnum<{
+                open: "open";
+                closed: "closed";
+                full: "full";
+            }>;
+        }, z.core.$strip>>>>;
+        readonly windows: NoInfer<import("./services.ts").ServiceCall<"/bookings/windows", {
+            date: z.ZodString;
+        }, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            start: z.ZodString;
+            end: z.ZodString;
+            remaining: z.ZodNumber;
+        }, z.core.$strip>>>>;
+        readonly request: NoInfer<import("./services.ts").ServiceCall<"/bookings/requests", {
+            offering: z.ZodString;
+            date: z.ZodString;
+            window: z.ZodString;
+            name: z.ZodString;
+            email: z.ZodEmail;
+            phone: z.ZodOptional<z.ZodString>;
+            address: z.ZodOptional<z.ZodString>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, z.ZodObject<{
+            id: z.ZodString;
+            createdAt: z.ZodString;
+        } & Record<never, never> & {
+            readonly offering: z.ZodString;
+            readonly date: z.ZodString;
+            readonly window: z.ZodString;
+            readonly name: z.ZodString;
+            readonly email: z.ZodEmail;
+            readonly phone: z.ZodString;
+            readonly address: z.ZodString;
+            readonly notes: z.ZodString;
+            readonly status: z.ZodEnum<{
+                requested: "requested";
+                accepted: "accepted";
+                declined: "declined";
+                cancelled: "cancelled";
+            }>;
+        }, z.core.$strip>>>;
+        readonly requests: NoInfer<import("./services.ts").ServiceCall<"/bookings/requests", {}, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            createdAt: z.ZodString;
+        } & Record<never, never> & {
+            readonly offering: z.ZodString;
+            readonly date: z.ZodString;
+            readonly window: z.ZodString;
+            readonly name: z.ZodString;
+            readonly email: z.ZodEmail;
+            readonly phone: z.ZodString;
+            readonly address: z.ZodString;
+            readonly notes: z.ZodString;
+            readonly status: z.ZodEnum<{
+                requested: "requested";
+                accepted: "accepted";
+                declined: "declined";
+                cancelled: "cancelled";
+            }>;
+        }, z.core.$strip>>>>;
+        readonly accept: NoInfer<import("./services.ts").ServiceCall<"/bookings/requests/:id/accept", {}, z.ZodObject<{
+            id: z.ZodString;
+            createdAt: z.ZodString;
+        } & Record<never, never> & {
+            readonly offering: z.ZodString;
+            readonly date: z.ZodString;
+            readonly window: z.ZodString;
+            readonly name: z.ZodString;
+            readonly email: z.ZodEmail;
+            readonly phone: z.ZodString;
+            readonly address: z.ZodString;
+            readonly notes: z.ZodString;
+            readonly status: z.ZodEnum<{
+                requested: "requested";
+                accepted: "accepted";
+                declined: "declined";
+                cancelled: "cancelled";
+            }>;
+        }, z.core.$strip>>>;
+        readonly decline: NoInfer<import("./services.ts").ServiceCall<"/bookings/requests/:id/decline", {}, z.ZodObject<{
+            id: z.ZodString;
+            createdAt: z.ZodString;
+        } & Record<never, never> & {
+            readonly offering: z.ZodString;
+            readonly date: z.ZodString;
+            readonly window: z.ZodString;
+            readonly name: z.ZodString;
+            readonly email: z.ZodEmail;
+            readonly phone: z.ZodString;
+            readonly address: z.ZodString;
+            readonly notes: z.ZodString;
+            readonly status: z.ZodEnum<{
+                requested: "requested";
+                accepted: "accepted";
+                declined: "declined";
+                cancelled: "cancelled";
+            }>;
+        }, z.core.$strip>>>;
+        readonly rules: NoInfer<import("./services.ts").ServiceCall<"/bookings/rules", {}, z.ZodObject<{
+            windows: z.ZodArray<z.ZodObject<{
+                weekday: z.ZodEnum<{
+                    Sunday: "Sunday";
+                    Monday: "Monday";
+                    Tuesday: "Tuesday";
+                    Wednesday: "Wednesday";
+                    Thursday: "Thursday";
+                    Friday: "Friday";
+                    Saturday: "Saturday";
+                }>;
+                label: z.ZodString;
+                start: z.ZodString;
+                end: z.ZodString;
+                capacity: z.ZodNumber;
+            }, z.core.$strip>>;
+            leadTimeHours: z.ZodNumber;
+            daysAhead: z.ZodNumber;
+            autoAccept: z.ZodBoolean;
+            blackouts: z.ZodArray<z.ZodObject<{
+                date: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        readonly saveRules: NoInfer<import("./services.ts").ServiceCall<"/bookings/rules", {
+            windows: z.ZodArray<z.ZodObject<{
+                weekday: z.ZodEnum<{
+                    Sunday: "Sunday";
+                    Monday: "Monday";
+                    Tuesday: "Tuesday";
+                    Wednesday: "Wednesday";
+                    Thursday: "Thursday";
+                    Friday: "Friday";
+                    Saturday: "Saturday";
+                }>;
+                label: z.ZodString;
+                start: z.ZodString;
+                end: z.ZodString;
+                capacity: z.ZodNumber;
+            }, z.core.$strip>>;
+            leadTimeHours: z.ZodNumber;
+            daysAhead: z.ZodNumber;
+            autoAccept: z.ZodBoolean;
+            blackouts: z.ZodArray<z.ZodObject<{
+                date: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.ZodObject<{
+            windows: z.ZodArray<z.ZodObject<{
+                weekday: z.ZodEnum<{
+                    Sunday: "Sunday";
+                    Monday: "Monday";
+                    Tuesday: "Tuesday";
+                    Wednesday: "Wednesday";
+                    Thursday: "Thursday";
+                    Friday: "Friday";
+                    Saturday: "Saturday";
+                }>;
+                label: z.ZodString;
+                start: z.ZodString;
+                end: z.ZodString;
+                capacity: z.ZodNumber;
+            }, z.core.$strip>>;
+            leadTimeHours: z.ZodNumber;
+            daysAhead: z.ZodNumber;
+            autoAccept: z.ZodBoolean;
+            blackouts: z.ZodArray<z.ZodObject<{
+                date: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    };
+};
+export declare const FULL = "That window was just taken. Choose another window or another day.";
+export declare const UNAVAILABLE = "That day or window can\u2019t be booked.";
+export declare function windowId(window: Pick<BookingWindow, 'start' | 'end'>): string;
+export declare function rulesProblem(rules: BookingRules): string | undefined;
+export declare function holdsAWindow(status: BookingStatus): boolean;
+export declare function isBookingMonth(month: string): boolean;
+export type Taken = ReadonlyMap<string, number>;
+export type Availability = {
+    rules: BookingRules;
+    taken: Taken;
+    now: Date;
+    timezone: string;
+};
+export declare function takenKey(date: string, window: string): string;
+export declare function takenBy(requests: readonly Pick<BookingRequest, 'date' | 'window' | 'status'>[]): Taken;
+export declare function datesOf(month: string): readonly string[];
+export declare function isValidTimezone(timezone: string): boolean;
+export declare function windowsOn(date: string, facts: Availability): readonly BookingSlot[];
+export declare function dayState(date: string, facts: Availability): BookingDay;
+export declare function daysOf(month: string, facts: Availability): readonly BookingDay[];
+export declare function slotFor(date: string, window: string, facts: Availability): (BookingSlot & {
+    capacity: number;
+}) | undefined;
+export declare function rulesOf(row: Pick<Row<typeof bookingRules>, 'windows' | 'leadTimeHours' | 'daysAhead' | 'autoAccept'> | undefined, blackouts: readonly z.output<typeof bookingBlackout>[]): BookingRules;
+export {};

package/dist/bookings.js

@@ -0,0 +1,300 @@
+import { z } from 'zod';
+import { call, defineServices } from "./services.js";
+import { patternTable } from "./table.js";
+const DATE = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+const MONTH = /^\d{4}-(0[1-9]|1[0-2])$/;
+const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+export const WEEKDAYS = [
+    'Sunday',
+    'Monday',
+    'Tuesday',
+    'Wednesday',
+    'Thursday',
+    'Friday',
+    'Saturday'
+];
+export const BOOKING_STATUSES = [
+    'requested',
+    'accepted',
+    'declined',
+    'cancelled'
+];
+const HOLDING = ['requested', 'accepted'];
+export const RULES_ID = 'rules';
+export const DEFAULT_RULES = {
+    windows: [],
+    leadTimeHours: 24,
+    daysAhead: 60,
+    autoAccept: false,
+    blackouts: []
+};
+export const bookingRules = patternTable('bookingRules', {
+    columns: {
+        windows: z.string(),
+        leadTimeHours: z.number().int(),
+        daysAhead: z.number().int(),
+        autoAccept: z.boolean()
+    },
+    access: {
+        read: 'server',
+        create: 'server',
+        update: 'server',
+        delete: 'server'
+    },
+    writes: 'confirmed'
+});
+export const bookingBlackouts = patternTable('bookingBlackouts', {
+    columns: {
+        date: z.string().regex(DATE),
+        reason: z.string()
+    },
+    access: {
+        read: 'server',
+        create: 'server',
+        update: 'server',
+        delete: 'server'
+    },
+    writes: 'confirmed'
+});
+export const bookingRequests = patternTable('bookingRequests', {
+    columns: {
+        offering: z.string().min(1).max(200),
+        date: z.string().regex(DATE),
+        window: z.string(),
+        name: z.string().min(1).max(200),
+        email: z.email().max(320),
+        phone: z.string().max(40),
+        address: z.string().max(500),
+        notes: z.string().max(2000),
+        status: z.enum(BOOKING_STATUSES)
+    },
+    access: {
+        read: 'server',
+        create: 'server',
+        update: 'server',
+        delete: 'server'
+    },
+    writes: 'confirmed'
+});
+export const bookingTables = { bookingRules, bookingBlackouts, bookingRequests };
+export const bookingWindow = z.object({
+    weekday: z.enum(WEEKDAYS),
+    label: z.string().min(1).max(60),
+    start: z.string().regex(TIME),
+    end: z.string().regex(TIME),
+    capacity: z.number().int().min(1).max(1000)
+});
+export const bookingBlackout = z.object({
+    date: z.string().regex(DATE),
+    reason: z.string().max(200)
+});
+const rulesShape = {
+    windows: z.array(bookingWindow).max(200),
+    leadTimeHours: z.number().int().min(0).max(720),
+    daysAhead: z.number().int().min(1).max(366),
+    autoAccept: z.boolean(),
+    blackouts: z.array(bookingBlackout).max(1000)
+};
+export const bookingRulesReply = z.object(rulesShape);
+export const bookingDay = z.object({
+    date: z.string(),
+    state: z.enum(['open', 'closed', 'full'])
+});
+export const bookingSlot = z.object({
+    id: z.string(),
+    label: z.string(),
+    start: z.string(),
+    end: z.string(),
+    remaining: z.number().int()
+});
+const requestShape = {
+    offering: z.string().min(1).max(200),
+    date: z.string().regex(DATE),
+    window: z.string().min(1).max(20),
+    name: z.string().trim().min(1).max(200),
+    email: z.email().max(320),
+    phone: z.string().max(40).optional(),
+    address: z.string().max(500).optional(),
+    notes: z.string().max(2000).optional()
+};
+export const bookingServices = defineServices({
+    bookings: {
+        days: call({
+            get: '/bookings/days',
+            input: { month: z.string().regex(MONTH) },
+            reply: z.array(bookingDay)
+        }),
+        windows: call({
+            get: '/bookings/windows',
+            input: { date: z.string().regex(DATE) },
+            reply: z.array(bookingSlot)
+        }),
+        request: call({
+            post: '/bookings/requests',
+            input: requestShape,
+            reply: bookingRequests.row
+        }),
+        requests: call({
+            get: '/bookings/requests',
+            reply: z.array(bookingRequests.row)
+        }),
+        accept: call({
+            post: '/bookings/requests/:id/accept',
+            reply: bookingRequests.row
+        }),
+        decline: call({
+            post: '/bookings/requests/:id/decline',
+            reply: bookingRequests.row
+        }),
+        rules: call({ get: '/bookings/rules', reply: bookingRulesReply }),
+        saveRules: call({
+            post: '/bookings/rules',
+            input: rulesShape,
+            reply: bookingRulesReply
+        })
+    }
+});
+export const FULL = 'That window was just taken. Choose another window or another day.';
+export const UNAVAILABLE = 'That day or window can’t be booked.';
+export function windowId(window) {
+    return `${window.start}-${window.end}`;
+}
+export function rulesProblem(rules) {
+    const seen = new Set();
+    for (const window of rules.windows) {
+        if (window.start >= window.end) {
+            return `${window.weekday} ${window.label} ends before it starts`;
+        }
+        const key = `${window.weekday} ${windowId(window)}`;
+        if (seen.has(key))
+            return `${window.weekday} has ${windowId(window)} twice`;
+        seen.add(key);
+    }
+    const dates = new Set(rules.blackouts.map((blackout) => blackout.date));
+    if (dates.size !== rules.blackouts.length) {
+        return 'A day is closed twice: list each date once';
+    }
+    return undefined;
+}
+export function holdsAWindow(status) {
+    return HOLDING.includes(status);
+}
+export function isBookingMonth(month) {
+    return MONTH.test(month);
+}
+export function takenKey(date, window) {
+    return `${date} ${window}`;
+}
+export function takenBy(requests) {
+    const taken = new Map();
+    for (const request of requests) {
+        if (!holdsAWindow(request.status))
+            continue;
+        const key = takenKey(request.date, request.window);
+        taken.set(key, (taken.get(key) ?? 0) + 1);
+    }
+    return taken;
+}
+function wallClock(now, timezone) {
+    const parts = new Intl.DateTimeFormat('en-US', {
+        timeZone: timezone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hourCycle: 'h23'
+    }).formatToParts(now);
+    const part = (type) => Number(parts.find((item) => item.type === type)?.value ?? 0);
+    return Date.UTC(part('year'), part('month') - 1, part('day'), part('hour'), part('minute'));
+}
+function wallTime(date, time) {
+    return Date.parse(`${date}T${time}:00Z`);
+}
+function isoDate(time) {
+    return new Date(time).toISOString().slice(0, 10);
+}
+export function datesOf(month) {
+    const first = Date.parse(`${month}-01T00:00:00Z`);
+    const start = new Date(first);
+    const count = new Date(Date.UTC(start.getUTCFullYear(), start.getUTCMonth() + 1, 0)).getUTCDate();
+    return Array.from({ length: count }, (_, index) => isoDate(first + index * DAY_MS));
+}
+export function isValidTimezone(timezone) {
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: timezone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isBookableDay(date, facts) {
+    const now = wallClock(facts.now, facts.timezone);
+    const today = isoDate(now);
+    const last = isoDate(Date.parse(`${today}T00:00:00Z`) + facts.rules.daysAhead * DAY_MS);
+    if (!DATE.test(date) || date < today || date > last)
+        return false;
+    return !facts.rules.blackouts.some((blackout) => blackout.date === date);
+}
+export function windowsOn(date, facts) {
+    if (!isBookableDay(date, facts))
+        return [];
+    const weekday = WEEKDAYS[new Date(`${date}T00:00:00Z`).getUTCDay()];
+    const earliest = wallClock(facts.now, facts.timezone) + facts.rules.leadTimeHours * HOUR_MS;
+    return facts.rules.windows
+        .filter((window) => window.weekday === weekday && wallTime(date, window.start) >= earliest)
+        .toSorted((a, b) => a.start.localeCompare(b.start))
+        .map((window) => {
+        const id = windowId(window);
+        return {
+            id,
+            label: window.label,
+            start: window.start,
+            end: window.end,
+            remaining: Math.max(0, window.capacity - (facts.taken.get(takenKey(date, id)) ?? 0))
+        };
+    });
+}
+export function dayState(date, facts) {
+    const windows = windowsOn(date, facts);
+    if (windows.length === 0)
+        return { date, state: 'closed' };
+    return {
+        date,
+        state: windows.every((window) => window.remaining === 0) ? 'full' : 'open'
+    };
+}
+export function daysOf(month, facts) {
+    return datesOf(month).map((date) => dayState(date, facts));
+}
+export function slotFor(date, window, facts) {
+    const slot = windowsOn(date, facts).find((item) => item.id === window);
+    if (slot === undefined)
+        return undefined;
+    const weekday = WEEKDAYS[new Date(`${date}T00:00:00Z`).getUTCDay()];
+    const rule = facts.rules.windows.find((item) => item.weekday === weekday && windowId(item) === window);
+    return rule === undefined ? undefined : { ...slot, capacity: rule.capacity };
+}
+function parsedJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function rulesOf(row, blackouts) {
+    if (row === undefined)
+        return { ...DEFAULT_RULES, blackouts: [...blackouts] };
+    const windows = z.array(bookingWindow).safeParse(parsedJson(row.windows));
+    return {
+        windows: windows.success ? windows.data : [],
+        leadTimeHours: row.leadTimeHours,
+        daysAhead: row.daysAhead,
+        autoAccept: row.autoAccept,
+        blackouts: [...blackouts]
+    };
+}