@servicetitan/dte-unlayer 0.157.0 → 0.159.0

package/dist/vendor/dte-shared/business-calendar-validation.utils.js

@@ -0,0 +1,80 @@
+import { CUSTOM_DATE_MONTH_LENGTHS, CUSTOM_DATE_PATTERN, MAX_SCHEDULE_NAME_LENGTH, RESERVED_SCHEDULE_NAME, } from './constants';
+/** Whether `value` is a valid `MM-DD` custom date (`02-29` included, as a recurring rule). */
+export function isValidCustomDate(value) {
+    const match = CUSTOM_DATE_PATTERN.exec(value);
+    if (!match) {
+        return false;
+    }
+    const month = Number(match[1]);
+    const day = Number(match[2]);
+    return day <= CUSTOM_DATE_MONTH_LENGTHS[month - 1];
+}
+/** Converts a complete `{ month, day }` to `MM-DD`, or null while the field is incomplete/invalid. */
+export function yearlessDateToCustomDate(value) {
+    var _a, _b;
+    const month = (_a = value === null || value === void 0 ? void 0 : value.month) !== null && _a !== void 0 ? _a : null;
+    const day = (_b = value === null || value === void 0 ? void 0 : value.day) !== null && _b !== void 0 ? _b : null;
+    if (month === null || day === null) {
+        return null;
+    }
+    const candidate = `${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+    return isValidCustomDate(candidate) ? candidate : null;
+}
+/** Converts a stored `MM-DD` custom date back to `DateFieldYearless`'s `{ month, day }` value. */
+export function customDateToYearlessDate(value) {
+    const match = CUSTOM_DATE_PATTERN.exec(value);
+    return match ? { month: Number(match[1]), day: Number(match[2]) } : null;
+}
+const CUSTOM_DATE_MONTH_ABBREVIATIONS = [
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sep',
+    'Oct',
+    'Nov',
+    'Dec',
+];
+/** Formats a stored `MM-DD` custom date for display, e.g. `03-03` → `Mar - 03`. */
+export function formatCustomDateLabel(value) {
+    const match = CUSTOM_DATE_PATTERN.exec(value);
+    if (!match) {
+        return value;
+    }
+    const [, month, day] = match;
+    return `${CUSTOM_DATE_MONTH_ABBREVIATIONS[Number(month) - 1]} - ${day}`;
+}
+/** How the schedule picker and drawer name a known holiday, e.g. `Independence Day · July 4`. */
+export function formatKnownHolidayLabel(holiday) {
+    return `${holiday.displayName} · ${holiday.rule}`;
+}
+/** Whether `name` is the reserved default-schedule name, ignoring case and surrounding whitespace. */
+export function isReservedScheduleName(name) {
+    return name.trim().toLowerCase() === RESERVED_SCHEDULE_NAME.toLowerCase();
+}
+/**
+ * Client-side schedule name checks mirroring DTE's `SaveDateScheduleRequest.Name` contract: a
+ * required, non-reserved name up to 255 characters, unique per tenant ignoring case. `existingNames`
+ * should exclude the schedule being edited, if any. The server is still authoritative — a duplicate
+ * it rejects despite passing this check is a 409, not a bug here.
+ */
+export function validateScheduleName(name, existingNames) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return 'Schedule name is required';
+    }
+    if (trimmed.length > MAX_SCHEDULE_NAME_LENGTH) {
+        return `Schedule name must be ${MAX_SCHEDULE_NAME_LENGTH} characters or fewer`;
+    }
+    if (isReservedScheduleName(trimmed)) {
+        return `"${RESERVED_SCHEDULE_NAME}" is reserved for the default schedule`;
+    }
+    if (existingNames.some(existing => existing.trim().toLowerCase() === trimmed.toLowerCase())) {
+        return 'A schedule with this name already exists';
+    }
+    return undefined;
+}

package/dist/vendor/dte-shared/components/business-calendar-section.d.ts

@@ -0,0 +1,15 @@
+import { FC } from 'react';
+import '../styles/schedule.css';
+import { type ScheduleEditorContext } from '../types';
+interface BusinessCalendarSectionProps {
+    businessCalendar: ScheduleEditorContext;
+    /** @default "Exclude weekends & holidays from the calculation" */
+    label?: string;
+}
+/**
+ * A business-day exclusion toggle, shown for a date calculated field (Formula Builder's Advanced
+ * Settings, date result type only) and an e-sign `dateSignedOffset` field's day-offset settings.
+ * On reveals the schedule picker; what off means for the date arithmetic is up to the editor.
+ */
+export declare const BusinessCalendarSection: FC<BusinessCalendarSectionProps>;
+export {};

package/dist/vendor/dte-shared/components/business-calendar-section.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Flex, Switch } from '@servicetitan/anvil2';
+import { BUSINESS_CALENDAR_TOGGLE_LABEL } from '../constants';
+import '../styles/schedule.css';
+import { SchedulePicker } from './schedule-picker';
+/**
+ * A business-day exclusion toggle, shown for a date calculated field (Formula Builder's Advanced
+ * Settings, date result type only) and an e-sign `dateSignedOffset` field's day-offset settings.
+ * On reveals the schedule picker; what off means for the date arithmetic is up to the editor.
+ */
+export const BusinessCalendarSection = ({ businessCalendar, label = BUSINESS_CALENDAR_TOGGLE_LABEL, }) => {
+    const { enabled, onToggle } = businessCalendar;
+    return (_jsx("div", { className: "dte-business-calendar-section", children: _jsxs(Flex, { direction: "column", gap: "4", children: [_jsx(Switch, { checked: enabled, onChange: (_e, state) => onToggle(state.checked), label: label, value: "business-calendar-exclusion" }), enabled && _jsx(SchedulePicker, { businessCalendar: businessCalendar })] }) }));
+};

package/dist/vendor/dte-shared/components/schedule-drawer.d.ts

@@ -0,0 +1,18 @@
+import { FC } from 'react';
+import { type BusinessDaySchedule, type ScheduleEditorContext } from '../types';
+interface ScheduleDrawerProps {
+    businessCalendar: ScheduleEditorContext;
+    /** When set, edits this schedule in place (PUT) instead of creating a new one (POST). */
+    editingSchedule?: BusinessDaySchedule;
+    onClose(): void;
+    onSaved(schedule: BusinessDaySchedule): void;
+}
+/**
+ * "Create New Schedule" / "Edit Schedule" drawer. With `businessCalendar.editorContainer` set, the
+ * same form is portaled into that element instead (its Close button calls `onClose`; there is no
+ * backdrop or Escape key). Creating starts from the default schedule's rules
+ * (DEFAULT_SCHEDULE_WEEKEND_DAYS, every catalog holiday); editing starts from `editingSchedule`'s
+ * own rules and replaces it in place on save.
+ */
+export declare const ScheduleDrawer: FC<ScheduleDrawerProps>;
+export {};

package/dist/vendor/dte-shared/components/schedule-drawer.js

@@ -0,0 +1,119 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Alert, Button, ButtonToggle, DateFieldYearless, Drawer, Flex, MultiSelectFieldSync, Text, TextField, } from '@servicetitan/anvil2';
+import IconAddCircle from '@servicetitan/anvil2/assets/icons/material/round/add_circle.svg';
+import IconClose from '@servicetitan/anvil2/assets/icons/material/round/close.svg';
+import DeleteIcon from '@servicetitan/anvil2/assets/icons/material/round/delete.svg';
+import { useMemo, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { customDateToYearlessDate, formatKnownHolidayLabel, validateScheduleName, yearlessDateToCustomDate, } from '../business-calendar-validation.utils';
+import { DEFAULT_SCHEDULE_WEEKEND_DAYS } from '../constants';
+const EMPTY_DATE = { month: null, day: null };
+const isEmptyDate = (value) => value.month === null && value.day === null;
+/**
+ * "Create New Schedule" / "Edit Schedule" drawer. With `businessCalendar.editorContainer` set, the
+ * same form is portaled into that element instead (its Close button calls `onClose`; there is no
+ * backdrop or Escape key). Creating starts from the default schedule's rules
+ * (DEFAULT_SCHEDULE_WEEKEND_DAYS, every catalog holiday); editing starts from `editingSchedule`'s
+ * own rules and replaces it in place on save.
+ */
+export const ScheduleDrawer = ({ businessCalendar, editingSchedule, onClose, onSaved, }) => {
+    var _a;
+    const { editorContainer, holidayCatalog, holidayCatalogError, holidayCatalogLoading, onCreateSchedule, onUpdateSchedule, schedules, } = businessCalendar;
+    const [name, setName] = useState((_a = editingSchedule === null || editingSchedule === void 0 ? void 0 : editingSchedule.name) !== null && _a !== void 0 ? _a : '');
+    const [weekendDays, setWeekendDays] = useState(() => { var _a; return new Set((_a = editingSchedule === null || editingSchedule === void 0 ? void 0 : editingSchedule.calendar.weekendDays) !== null && _a !== void 0 ? _a : DEFAULT_SCHEDULE_WEEKEND_DAYS); });
+    const [knownHolidays, setKnownHolidays] = useState(() => {
+        var _a, _b;
+        return new Set((_b = (_a = editingSchedule === null || editingSchedule === void 0 ? void 0 : editingSchedule.calendar.knownHolidays) !== null && _a !== void 0 ? _a : holidayCatalog === null || holidayCatalog === void 0 ? void 0 : holidayCatalog.holidays.map(h => h.code)) !== null && _b !== void 0 ? _b : []);
+    });
+    const [customDates, setCustomDates] = useState(() => {
+        var _a;
+        return ((_a = editingSchedule === null || editingSchedule === void 0 ? void 0 : editingSchedule.calendar.customDates) !== null && _a !== void 0 ? _a : []).map((date, index) => {
+            var _a;
+            return ({
+                id: index,
+                value: (_a = customDateToYearlessDate(date)) !== null && _a !== void 0 ? _a : EMPTY_DATE,
+            });
+        });
+    });
+    const nextRowId = useRef(customDates.length);
+    const [nameTouched, setNameTouched] = useState(false);
+    const [submitError, setSubmitError] = useState();
+    const [submitting, setSubmitting] = useState(false);
+    const holidayOptions = useMemo(() => {
+        var _a;
+        return ((_a = holidayCatalog === null || holidayCatalog === void 0 ? void 0 : holidayCatalog.holidays) !== null && _a !== void 0 ? _a : []).map(h => ({
+            id: h.code,
+            label: formatKnownHolidayLabel(h),
+        }));
+    }, [holidayCatalog]);
+    const selectedHolidayOptions = useMemo(() => holidayOptions.filter(o => knownHolidays.has(String(o.id))), [holidayOptions, knownHolidays]);
+    const existingNames = useMemo(() => (schedules !== null && schedules !== void 0 ? schedules : [])
+        .filter(s => !s.isDefault && s.id !== (editingSchedule === null || editingSchedule === void 0 ? void 0 : editingSchedule.id))
+        .map(s => s.name), [schedules, editingSchedule]);
+    const nameError = validateScheduleName(name, existingNames);
+    const toggleWeekendDay = (day) => {
+        setWeekendDays(prev => {
+            const next = new Set(prev);
+            if (next.has(day)) {
+                next.delete(day);
+            }
+            else {
+                next.add(day);
+            }
+            return next;
+        });
+    };
+    const handleAddDate = () => setCustomDates(prev => [...prev, { id: nextRowId.current++, value: EMPTY_DATE }]);
+    const handleRemoveDate = (id) => setCustomDates(prev => prev.filter(row => row.id !== id));
+    const handleCustomDateChange = (id, value) => setCustomDates(prev => prev.map(row => (row.id === id ? { ...row, value: value !== null && value !== void 0 ? value : EMPTY_DATE } : row)));
+    /** Resolved `MM-DD` per non-empty row, or `null` for an incomplete/invalid one (blocks submit). */
+    const resolvedCustomDates = customDates.map(row => isEmptyDate(row.value) ? '' : yearlessDateToCustomDate(row.value));
+    const hasInvalidCustomDate = resolvedCustomDates.some((d, i) => d === null && !isEmptyDate(customDates[i].value));
+    /*
+     * Editing is only offered for a saved tenant schedule, which always has an id (only the
+     * read-only default schedule — never editable — lacks one).
+     */
+    const editingId = editingSchedule === null || editingSchedule === void 0 ? void 0 : editingSchedule.id;
+    const isEditing = editingId !== undefined;
+    const canSave = isEditing ? !!onUpdateSchedule : !!onCreateSchedule;
+    const canSubmit = !nameError && !hasInvalidCustomDate && !submitting && canSave;
+    const handleSubmit = async () => {
+        setNameTouched(true);
+        if (nameError || hasInvalidCustomDate || !canSave) {
+            return;
+        }
+        const request = {
+            name: name.trim(),
+            weekendDays: Array.from(weekendDays),
+            knownHolidays: Array.from(knownHolidays),
+            customDates: Array.from(new Set(resolvedCustomDates.filter((d) => !!d))),
+        };
+        setSubmitting(true);
+        setSubmitError(undefined);
+        try {
+            if (isEditing && onUpdateSchedule) {
+                onSaved(await onUpdateSchedule(editingId, request));
+            }
+            else if (!isEditing && onCreateSchedule) {
+                onSaved(await onCreateSchedule(request));
+            }
+        }
+        catch (e) {
+            setSubmitError(e instanceof Error
+                ? e.message
+                : `Failed to ${isEditing ? 'save' : 'create'} schedule`);
+        }
+        finally {
+            setSubmitting(false);
+        }
+    };
+    const title = isEditing ? 'Edit Schedule' : 'Create New Schedule';
+    const form = (_jsxs(Flex, { direction: "column", gap: "5", style: { height: '100%', overflowY: 'auto' }, children: [_jsx(TextField, { required: true, label: "Schedule Name", placeholder: "New Schedule", value: name, onChange: e => setName(e.target.value), onBlur: () => setNameTouched(true), error: nameTouched ? nameError : undefined }), _jsxs(Flex, { direction: "column", gap: "3", children: [_jsx(Text, { variant: "eyebrow", size: "small", children: "Exclude Weekends" }), _jsxs(Flex, { gap: "3", children: [_jsx(ButtonToggle, { checked: weekendDays.has(6), onClick: () => toggleWeekendDay(6), children: "Saturday" }), _jsx(ButtonToggle, { checked: weekendDays.has(0), onClick: () => toggleWeekendDay(0), children: "Sunday" })] })] }), _jsxs(Flex, { direction: "column", gap: "3", children: [_jsx(Text, { variant: "eyebrow", size: "small", children: "Exclude Holidays" }), holidayCatalogLoading && _jsx(Text, { variant: "body", children: "Loading holidays\u2026" }), holidayCatalogError && _jsx(Alert, { status: "danger", title: holidayCatalogError }), _jsx(MultiSelectFieldSync, { label: holidayCatalog ? `${holidayCatalog.jurisdiction} Holidays` : 'Holidays', disabled: holidayCatalogLoading, options: holidayOptions, value: selectedHolidayOptions, onSelectedOptionsChange: options => setKnownHolidays(new Set(options.map(o => String(o.id)))), description: "Select the holidays you want to exclude", filter: { keys: ['label'] } })] }), _jsxs(Flex, { direction: "column", gap: "2", children: [_jsx(Text, { variant: "eyebrow", size: "small", children: "Custom Dates" }), customDates.map((row, index) => {
+                        const invalid = resolvedCustomDates[index] === null && !isEmptyDate(row.value);
+                        return (_jsxs(Flex, { gap: "2", children: [_jsx(DateFieldYearless, { label: `Custom date ${index + 1}`, hideLabel: true, value: row.value, error: invalid ? 'Enter a valid date' : undefined, onChange: change => handleCustomDateChange(row.id, change.value), flex: 1 }), _jsx(Button, { icon: DeleteIcon, appearance: "ghost", "aria-label": "Remove date", onClick: () => handleRemoveDate(row.id) })] }, row.id));
+                    }), _jsx(Button, { appearance: "ghost", icon: IconAddCircle, onClick: handleAddDate, alignSelf: "end", children: "Add Date" })] }), submitError && _jsx(Alert, { status: "danger", title: submitError })] }));
+    if (editorContainer) {
+        return createPortal(_jsxs(Flex, { direction: "column", gap: "5", style: { height: '100%' }, children: [_jsxs(Flex, { alignItems: "center", justifyContent: "space-between", children: [_jsx(Text, { variant: "headline", el: "h6", size: "small", children: title }), _jsx(Button, { appearance: "ghost", size: "small", onClick: onClose, "aria-label": "Close", icon: IconClose })] }), form, _jsx(Button, { size: "small", appearance: "primary", onClick: handleSubmit, loading: submitting, disabled: !canSubmit, style: { width: '100%' }, children: isEditing ? 'Save' : 'Create' })] }), editorContainer);
+    }
+    return (_jsxs(Drawer, { open: true, onClose: onClose, size: "medium", children: [_jsx(Drawer.Header, { children: title }), _jsx(Drawer.Content, { children: form }), _jsxs(Drawer.Footer, { sticky: true, children: [_jsx(Drawer.CancelButton, { appearance: "secondary", children: "Cancel" }), _jsx(Button, { appearance: "primary", onClick: handleSubmit, loading: submitting, disabled: !canSubmit, children: isEditing ? 'Save' : 'Create' })] })] }));
+};

package/dist/vendor/dte-shared/components/schedule-picker.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { type ScheduleEditorContext } from '../types';
+interface SchedulePickerProps {
+    businessCalendar: ScheduleEditorContext;
+}
+/** "Select Schedule or create new" picker plus a collapsible preview of the selected schedule's rules. */
+export declare const SchedulePicker: FC<SchedulePickerProps>;
+export {};

package/dist/vendor/dte-shared/components/schedule-picker.js

@@ -0,0 +1,88 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Alert, Button, Chip, Flex, SelectFieldSync, Text } from '@servicetitan/anvil2';
+import DeleteIcon from '@servicetitan/anvil2/assets/icons/material/round/delete.svg';
+import EditIcon from '@servicetitan/anvil2/assets/icons/material/round/edit.svg';
+import IconExpandLess from '@servicetitan/anvil2/assets/icons/material/round/expand_less.svg';
+import IconExpandMore from '@servicetitan/anvil2/assets/icons/material/round/expand_more.svg';
+import { Fragment, useMemo, useState } from 'react';
+import { formatCustomDateLabel, formatKnownHolidayLabel, } from '../business-calendar-validation.utils';
+import { SCHEDULE_PICKER_TEXT, WEEKEND_DAY_LABELS } from '../constants';
+import { findSelectedSchedule } from '../schedule-bindings.utils';
+import { ScheduleDrawer } from './schedule-drawer';
+const DEFAULT_OPTION_ID = 'default';
+/** "Select Schedule or create new" picker plus a collapsible preview of the selected schedule's rules. */
+export const SchedulePicker = ({ businessCalendar }) => {
+    var _a;
+    const { holidayCatalog, holidayCatalogError, holidayCatalogLoading, onDeleteSchedule, onSelectSchedule, schedules, schedulesError, schedulesLoading, selectedScheduleId, } = businessCalendar;
+    const [drawerOpen, setDrawerOpen] = useState(false);
+    const [editingSchedule, setEditingSchedule] = useState();
+    const [previewOpen, setPreviewOpen] = useState(true);
+    const [deleting, setDeleting] = useState(false);
+    const [deleteError, setDeleteError] = useState();
+    const options = useMemo(() => (schedules !== null && schedules !== void 0 ? schedules : []).map(s => { var _a; return ({ id: (_a = s.id) !== null && _a !== void 0 ? _a : DEFAULT_OPTION_ID, label: s.name }); }), [schedules]);
+    const selectedOptionId = selectedScheduleId !== null && selectedScheduleId !== void 0 ? selectedScheduleId : DEFAULT_OPTION_ID;
+    const selectedOption = (_a = options.find(o => o.id === selectedOptionId)) !== null && _a !== void 0 ? _a : null;
+    const selectedSchedule = findSelectedSchedule(schedules, selectedScheduleId);
+    const holidayByCode = useMemo(() => {
+        var _a;
+        const map = new Map();
+        for (const h of (_a = holidayCatalog === null || holidayCatalog === void 0 ? void 0 : holidayCatalog.holidays) !== null && _a !== void 0 ? _a : []) {
+            map.set(h.code, h);
+        }
+        return map;
+    }, [holidayCatalog]);
+    const handleSelectedOptionChange = (option) => {
+        if (!option) {
+            return;
+        }
+        onSelectSchedule(option.id === DEFAULT_OPTION_ID ? undefined : option.id);
+    };
+    const handleSaved = (schedule) => {
+        onSelectSchedule(schedule.id);
+        setDrawerOpen(false);
+        setEditingSchedule(undefined);
+    };
+    const handleOpenCreate = () => {
+        setEditingSchedule(undefined);
+        setDrawerOpen(true);
+    };
+    const handleOpenEdit = () => {
+        if (!selectedSchedule) {
+            return;
+        }
+        setEditingSchedule(selectedSchedule);
+        setDrawerOpen(true);
+    };
+    const handleCloseDrawer = () => {
+        setDrawerOpen(false);
+        setEditingSchedule(undefined);
+    };
+    const handleDelete = async () => {
+        if (!(selectedSchedule === null || selectedSchedule === void 0 ? void 0 : selectedSchedule.id) || !onDeleteSchedule) {
+            return;
+        }
+        setDeleting(true);
+        setDeleteError(undefined);
+        try {
+            await onDeleteSchedule(selectedSchedule.id);
+            onSelectSchedule(undefined);
+        }
+        catch (e) {
+            setDeleteError(e instanceof Error ? e.message : SCHEDULE_PICKER_TEXT.deleteFailed);
+        }
+        finally {
+            setDeleting(false);
+        }
+    };
+    return (_jsxs(Fragment, { children: [_jsx(SelectFieldSync, { label: SCHEDULE_PICKER_TEXT.selectLabel, options: options, value: selectedOption, disableClearButton: true, disabled: schedulesLoading, onSelectedOptionChange: handleSelectedOptionChange, onAddNewItem: handleOpenCreate, addItemLabel: SCHEDULE_PICKER_TEXT.createNew, filter: { keys: ['label'] } }), schedulesLoading && (_jsx(Text, { variant: "body", children: SCHEDULE_PICKER_TEXT.loadingSchedules })), schedulesError && _jsx(Alert, { status: "danger", title: schedulesError }), selectedSchedule && (_jsxs("div", { className: "dte-business-calendar-preview", children: [_jsxs(Flex, { alignItems: "center", justifyContent: "space-between", gap: "2", className: "dte-business-calendar-preview-header", children: [_jsxs(Flex, { alignItems: "center", gap: "2", onClick: () => setPreviewOpen(prev => !prev), children: [_jsx(Button, { appearance: "ghost", size: "small", icon: previewOpen ? IconExpandLess : IconExpandMore, "aria-label": previewOpen
+                                            ? 'Collapse schedule preview'
+                                            : 'Expand schedule preview' }), _jsx(Text, { variant: "body", size: "small", style: { fontWeight: 'bold' }, children: selectedSchedule.name })] }), !selectedSchedule.isDefault && (_jsxs(Flex, { alignItems: "center", gap: "2", children: [_jsx(Button, { icon: EditIcon, size: "small", appearance: "ghost", onClick: handleOpenEdit, disabled: deleting }), _jsx(Button, { icon: DeleteIcon, size: "small", appearance: "ghost", "aria-label": "Delete schedule", onClick: handleDelete, loading: deleting, disabled: !onDeleteSchedule })] }))] }), deleteError && _jsx(Alert, { status: "danger", title: deleteError }), previewOpen && (_jsxs(Flex, { direction: "column", gap: "5", className: "dte-business-calendar-preview-content", children: [_jsxs(Flex, { direction: "column", gap: "4", children: [_jsx(Text, { variant: "eyebrow", size: "small", children: SCHEDULE_PICKER_TEXT.excludedWeekends }), _jsx(Flex, { gap: "2", style: { flexWrap: 'wrap' }, children: selectedSchedule.calendar.weekendDays.map(day => {
+                                            var _a;
+                                            return (_jsx(Chip, { label: (_a = WEEKEND_DAY_LABELS[day]) !== null && _a !== void 0 ? _a : String(day), size: "medium" }, day));
+                                        }) })] }), _jsxs(Flex, { direction: "column", gap: "4", children: [_jsx(Text, { variant: "eyebrow", size: "small", children: SCHEDULE_PICKER_TEXT.excludedHolidays }), holidayCatalogLoading && (_jsx(Text, { variant: "body", children: SCHEDULE_PICKER_TEXT.loadingHolidays })), holidayCatalogError && (_jsx(Alert, { status: "danger", title: holidayCatalogError })), _jsx(Flex, { gap: "2", style: { flexWrap: 'wrap' }, children: selectedSchedule.calendar.knownHolidays.map(code => {
+                                            const holiday = holidayByCode.get(code);
+                                            return (_jsx(Chip, { label: holiday
+                                                    ? formatKnownHolidayLabel(holiday)
+                                                    : code, size: "medium" }, code));
+                                        }) })] }), selectedSchedule.calendar.customDates.length > 0 && (_jsxs(Flex, { direction: "column", gap: "4", children: [_jsx(Text, { variant: "eyebrow", size: "small", children: SCHEDULE_PICKER_TEXT.customDates }), _jsx(Flex, { gap: "2", style: { flexWrap: 'wrap' }, children: selectedSchedule.calendar.customDates.map(date => (_jsx(Chip, { label: formatCustomDateLabel(date), size: "medium" }, date))) })] }))] }))] })), drawerOpen && (_jsx(ScheduleDrawer, { businessCalendar: businessCalendar, editingSchedule: editingSchedule, onClose: handleCloseDrawer, onSaved: handleSaved }))] }));
+};

package/dist/vendor/dte-shared/constants.d.ts

@@ -0,0 +1,31 @@
+/** DTE's `SaveDateScheduleRequest.Name` limit. */
+export declare const MAX_SCHEDULE_NAME_LENGTH = 255;
+/** The read-only default schedule's name; a tenant schedule may not reuse it (case-insensitive). */
+export declare const RESERVED_SCHEDULE_NAME = "Default";
+/** `MM-DD`, 01-12 / 01-31, as DTE's `CalendarSpecModel.customDates` (`02-29` is a valid leap day). */
+export declare const CUSTOM_DATE_PATTERN: RegExp;
+/** Days per month for an `MM-DD` custom date, Feb including the leap day. */
+export declare const CUSTOM_DATE_MONTH_LENGTHS: number[];
+/** The default schedule's weekend: Sunday and Saturday, DTE's `Date.getUTCDay()` numbering. */
+export declare const DEFAULT_SCHEDULE_WEEKEND_DAYS: [0, 6];
+/**
+ * `BusinessCalendarSection`'s default toggle label, used for a date calculated field and an e-sign
+ * `dateSignedOffset` field alike.
+ */
+export declare const BUSINESS_CALENDAR_TOGGLE_LABEL = "Exclude weekends & holidays from the calculation";
+/** How a schedule's preview names `BusinessCalendarRules.weekendDays`. */
+export declare const WEEKEND_DAY_LABELS: Readonly<Record<number, string>>;
+/**
+ * `SchedulePicker`'s text, also used by an editor that renders its own copy of the picker
+ * (Unlayer's Formula Builder, inside an iframe without Anvil2), so both read the same.
+ */
+export declare const SCHEDULE_PICKER_TEXT: {
+    readonly selectLabel: "Select Schedule or create new";
+    readonly createNew: "Create new schedule";
+    readonly loadingSchedules: "Loading schedules…";
+    readonly loadingHolidays: "Loading holidays…";
+    readonly excludedWeekends: "Excluded Weekends";
+    readonly excludedHolidays: "Excluded Holidays";
+    readonly customDates: "Custom Dates";
+    readonly deleteFailed: "Failed to delete schedule";
+};

package/dist/vendor/dte-shared/constants.js

@@ -0,0 +1,34 @@
+/** DTE's `SaveDateScheduleRequest.Name` limit. */
+export const MAX_SCHEDULE_NAME_LENGTH = 255;
+/** The read-only default schedule's name; a tenant schedule may not reuse it (case-insensitive). */
+export const RESERVED_SCHEDULE_NAME = 'Default';
+/** `MM-DD`, 01-12 / 01-31, as DTE's `CalendarSpecModel.customDates` (`02-29` is a valid leap day). */
+export const CUSTOM_DATE_PATTERN = /^(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
+/** Days per month for an `MM-DD` custom date, Feb including the leap day. */
+export const CUSTOM_DATE_MONTH_LENGTHS = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+/** The default schedule's weekend: Sunday and Saturday, DTE's `Date.getUTCDay()` numbering. */
+export const DEFAULT_SCHEDULE_WEEKEND_DAYS = [0, 6];
+/**
+ * `BusinessCalendarSection`'s default toggle label, used for a date calculated field and an e-sign
+ * `dateSignedOffset` field alike.
+ */
+export const BUSINESS_CALENDAR_TOGGLE_LABEL = 'Exclude weekends & holidays from the calculation';
+/** How a schedule's preview names `BusinessCalendarRules.weekendDays`. */
+export const WEEKEND_DAY_LABELS = {
+    0: 'Sundays',
+    6: 'Saturdays',
+};
+/**
+ * `SchedulePicker`'s text, also used by an editor that renders its own copy of the picker
+ * (Unlayer's Formula Builder, inside an iframe without Anvil2), so both read the same.
+ */
+export const SCHEDULE_PICKER_TEXT = {
+    selectLabel: 'Select Schedule or create new',
+    createNew: 'Create new schedule',
+    loadingSchedules: 'Loading schedules…',
+    loadingHolidays: 'Loading holidays…',
+    excludedWeekends: 'Excluded Weekends',
+    excludedHolidays: 'Excluded Holidays',
+    customDates: 'Custom Dates',
+    deleteFailed: 'Failed to delete schedule',
+};

package/dist/vendor/dte-shared/field-schedule-editor-context.d.ts

@@ -0,0 +1,31 @@
+import { type BusinessCalendarHostProps, type FieldScheduleBinding, type ScheduleEditorContext } from './types';
+/** Where a field's `ScheduleEditorContext` reads the current bindings and sends the next ones. */
+export interface FieldScheduleBindingsAccess {
+    get(): FieldScheduleBinding[];
+    set(bindings: FieldScheduleBinding[]): void;
+}
+/**
+ * The `ScheduleEditorContext` of the field `fieldKey`, built from an editor's schedule props: the
+ * toggle is on while the field has a binding, and the toggle, the picker and a schedule delete
+ * replace the bindings through `bindings.set`.
+ *
+ * Every change reads the bindings through `bindings.get` when it happens, not when the context was
+ * built, so a callback kept from an earlier render can't write stale bindings back. A pick changes
+ * only a field whose toggle is on, and only to a different schedule: the picker shows only while
+ * the toggle is on, and its select of the default schedule right after a delete (which already
+ * moved the field there) must neither resend the bindings nor turn back on a toggle switched off
+ * while the delete was running. Without a `fieldKey` the toggle is off and does nothing.
+ */
+export declare function buildFieldScheduleEditorContext(fieldKey: string | undefined, host: BusinessCalendarHostProps, bindings: FieldScheduleBindingsAccess): ScheduleEditorContext;
+/**
+ * A stable {@link FieldScheduleBindingsAccess} over an editor's `scheduleBindings`: changes go to the
+ * latest `onScheduleBindingsChange`, even from a callback kept from an earlier render, and until the
+ * host passes them back the next change builds on the last one sent.
+ */
+export declare function useFieldScheduleBindingsAccess(scheduleBindings: FieldScheduleBinding[] | undefined, onScheduleBindingsChange: ((bindings: FieldScheduleBinding[]) => void) | undefined): FieldScheduleBindingsAccess;
+/**
+ * {@link buildFieldScheduleEditorContext} for a component: the field's context from the editor's
+ * schedule props, rebuilt only when one of them changes, with
+ * {@link useFieldScheduleBindingsAccess} for the bindings.
+ */
+export declare function useFieldScheduleEditorContext(fieldKey: string | undefined, host: BusinessCalendarHostProps): ScheduleEditorContext;

package/dist/vendor/dte-shared/field-schedule-editor-context.js

@@ -0,0 +1,110 @@
+import { useEffect, useMemo, useRef } from 'react';
+import { clearDeletedSchedule, setFieldSchedule, setFieldScheduleEnabled, } from './schedule-bindings.utils';
+/**
+ * The `ScheduleEditorContext` of the field `fieldKey`, built from an editor's schedule props: the
+ * toggle is on while the field has a binding, and the toggle, the picker and a schedule delete
+ * replace the bindings through `bindings.set`.
+ *
+ * Every change reads the bindings through `bindings.get` when it happens, not when the context was
+ * built, so a callback kept from an earlier render can't write stale bindings back. A pick changes
+ * only a field whose toggle is on, and only to a different schedule: the picker shows only while
+ * the toggle is on, and its select of the default schedule right after a delete (which already
+ * moved the field there) must neither resend the bindings nor turn back on a toggle switched off
+ * while the delete was running. Without a `fieldKey` the toggle is off and does nothing.
+ */
+export function buildFieldScheduleEditorContext(fieldKey, host, bindings) {
+    var _a;
+    const binding = fieldKey
+        ? (_a = host.scheduleBindings) === null || _a === void 0 ? void 0 : _a.find(b => b.fieldKey === fieldKey)
+        : undefined;
+    const { onDeleteSchedule } = host;
+    return {
+        enabled: !!binding,
+        selectedScheduleId: binding === null || binding === void 0 ? void 0 : binding.scheduleId,
+        onToggle: enabled => {
+            if (fieldKey) {
+                bindings.set(setFieldScheduleEnabled(bindings.get(), fieldKey, enabled));
+            }
+        },
+        onSelectSchedule: scheduleId => {
+            const current = bindings.get();
+            const fieldBinding = fieldKey ? current.find(b => b.fieldKey === fieldKey) : undefined;
+            if (fieldKey && fieldBinding && fieldBinding.scheduleId !== scheduleId) {
+                bindings.set(setFieldSchedule(current, fieldKey, scheduleId));
+            }
+        },
+        holidayCatalog: host.holidayCatalog,
+        holidayCatalogLoading: host.holidayCatalogLoading,
+        holidayCatalogError: host.holidayCatalogError,
+        schedules: host.schedules,
+        schedulesLoading: host.schedulesLoading,
+        schedulesError: host.schedulesError,
+        onCreateSchedule: host.onCreateSchedule,
+        onUpdateSchedule: host.onUpdateSchedule,
+        onDeleteSchedule: onDeleteSchedule &&
+            (async (id) => {
+                await onDeleteSchedule(id);
+                const current = bindings.get();
+                if (current.some(b => b.scheduleId === id)) {
+                    bindings.set(clearDeletedSchedule(current, id));
+                }
+            }),
+    };
+}
+/**
+ * A stable {@link FieldScheduleBindingsAccess} over an editor's `scheduleBindings`: changes go to the
+ * latest `onScheduleBindingsChange`, even from a callback kept from an earlier render, and until the
+ * host passes them back the next change builds on the last one sent.
+ */
+export function useFieldScheduleBindingsAccess(scheduleBindings, onScheduleBindingsChange) {
+    const latestBindings = useRef(scheduleBindings !== null && scheduleBindings !== void 0 ? scheduleBindings : []);
+    const latestOnChange = useRef(onScheduleBindingsChange);
+    useEffect(() => {
+        latestBindings.current = scheduleBindings !== null && scheduleBindings !== void 0 ? scheduleBindings : [];
+    }, [scheduleBindings]);
+    useEffect(() => {
+        latestOnChange.current = onScheduleBindingsChange;
+    }, [onScheduleBindingsChange]);
+    return useMemo(() => ({
+        get: () => latestBindings.current,
+        set: next => {
+            var _a;
+            latestBindings.current = next;
+            (_a = latestOnChange.current) === null || _a === void 0 ? void 0 : _a.call(latestOnChange, next);
+        },
+    }), []);
+}
+/**
+ * {@link buildFieldScheduleEditorContext} for a component: the field's context from the editor's
+ * schedule props, rebuilt only when one of them changes, with
+ * {@link useFieldScheduleBindingsAccess} for the bindings.
+ */
+export function useFieldScheduleEditorContext(fieldKey, host) {
+    const { holidayCatalog, holidayCatalogError, holidayCatalogLoading, onCreateSchedule, onDeleteSchedule, onScheduleBindingsChange, onUpdateSchedule, scheduleBindings, schedules, schedulesError, schedulesLoading, } = host;
+    const bindings = useFieldScheduleBindingsAccess(scheduleBindings, onScheduleBindingsChange);
+    return useMemo(() => buildFieldScheduleEditorContext(fieldKey, {
+        holidayCatalog,
+        holidayCatalogError,
+        holidayCatalogLoading,
+        onCreateSchedule,
+        onDeleteSchedule,
+        onUpdateSchedule,
+        scheduleBindings,
+        schedules,
+        schedulesError,
+        schedulesLoading,
+    }, bindings), [
+        bindings,
+        fieldKey,
+        holidayCatalog,
+        holidayCatalogError,
+        holidayCatalogLoading,
+        onCreateSchedule,
+        onDeleteSchedule,
+        onUpdateSchedule,
+        scheduleBindings,
+        schedules,
+        schedulesError,
+        schedulesLoading,
+    ]);
+}

package/dist/vendor/dte-shared/index.d.ts

@@ -0,0 +1,8 @@
+export { BusinessCalendarSection } from './components/business-calendar-section';
+export { SchedulePicker } from './components/schedule-picker';
+export { ScheduleDrawer } from './components/schedule-drawer';
+export type * from './types';
+export * from './constants';
+export * from './business-calendar-validation.utils';
+export * from './schedule-bindings.utils';
+export * from './field-schedule-editor-context';

package/dist/vendor/dte-shared/index.js

@@ -0,0 +1,7 @@
+export { BusinessCalendarSection } from './components/business-calendar-section';
+export { SchedulePicker } from './components/schedule-picker';
+export { ScheduleDrawer } from './components/schedule-drawer';
+export * from './constants';
+export * from './business-calendar-validation.utils';
+export * from './schedule-bindings.utils';
+export * from './field-schedule-editor-context';

package/dist/vendor/dte-shared/schedule-bindings.utils.d.ts

@@ -0,0 +1,22 @@
+import { type BusinessDaySchedule, type FieldScheduleBinding } from './types';
+/**
+ * The schedule a field's picker shows for its `scheduleId` (undefined for the default schedule),
+ * or undefined when it isn't listed (for example a deleted one).
+ */
+export declare function findSelectedSchedule(schedules: BusinessDaySchedule[] | undefined, scheduleId: number | undefined): BusinessDaySchedule | undefined;
+/**
+ * Replaces `fieldKey`'s binding: enabling adds it (default schedule, `scheduleId` undefined);
+ * disabling removes it. Every other field's binding is returned unchanged.
+ */
+export declare function setFieldScheduleEnabled(bindings: FieldScheduleBinding[], fieldKey: string, enabled: boolean): FieldScheduleBinding[];
+/**
+ * Sets `fieldKey`'s selected schedule (`scheduleId` undefined for the default schedule),
+ * enabling its toggle if it wasn't already on. Every other field's binding is returned unchanged.
+ */
+export declare function setFieldSchedule(bindings: FieldScheduleBinding[], fieldKey: string, scheduleId: number | undefined): FieldScheduleBinding[];
+/**
+ * Moves every field bound to the deleted schedule `scheduleId` to the default schedule, keeping its
+ * toggle on, as DTE falls back for a deleted schedule (and DTE refuses to save a binding to a
+ * schedule that no longer exists). Every other binding is returned unchanged.
+ */
+export declare function clearDeletedSchedule(bindings: FieldScheduleBinding[], scheduleId: number): FieldScheduleBinding[];

package/dist/vendor/dte-shared/schedule-bindings.utils.js

@@ -0,0 +1,31 @@
+/**
+ * The schedule a field's picker shows for its `scheduleId` (undefined for the default schedule),
+ * or undefined when it isn't listed (for example a deleted one).
+ */
+export function findSelectedSchedule(schedules, scheduleId) {
+    return (schedules !== null && schedules !== void 0 ? schedules : []).find(s => scheduleId === undefined ? s.id === undefined : s.id === scheduleId);
+}
+/**
+ * Replaces `fieldKey`'s binding: enabling adds it (default schedule, `scheduleId` undefined);
+ * disabling removes it. Every other field's binding is returned unchanged.
+ */
+export function setFieldScheduleEnabled(bindings, fieldKey, enabled) {
+    const withoutField = bindings.filter(b => b.fieldKey !== fieldKey);
+    return enabled ? [...withoutField, { fieldKey }] : withoutField;
+}
+/**
+ * Sets `fieldKey`'s selected schedule (`scheduleId` undefined for the default schedule),
+ * enabling its toggle if it wasn't already on. Every other field's binding is returned unchanged.
+ */
+export function setFieldSchedule(bindings, fieldKey, scheduleId) {
+    const withoutField = bindings.filter(b => b.fieldKey !== fieldKey);
+    return [...withoutField, { fieldKey, scheduleId }];
+}
+/**
+ * Moves every field bound to the deleted schedule `scheduleId` to the default schedule, keeping its
+ * toggle on, as DTE falls back for a deleted schedule (and DTE refuses to save a binding to a
+ * schedule that no longer exists). Every other binding is returned unchanged.
+ */
+export function clearDeletedSchedule(bindings, scheduleId) {
+    return bindings.map(b => (b.scheduleId === scheduleId ? { fieldKey: b.fieldKey } : b));
+}