@servicetitan/dte-pdf-editor 1.95.0 → 1.96.1

package/src/components/pdf-editor/pdf-editor.tsx

@@ -2,11 +2,16 @@ import { Flex } from '@servicetitan/anvil2';
 import { FC, ReactNode, useCallback, useMemo, useRef } from 'react';
 import { useFormFields, usePdfFieldDnD, usePdfFieldSelection } from '../../hooks';
 import {
+    type BusinessCalendar,
+    type BusinessDaySchedule,
     FieldTypeEnum,
+    type FieldScheduleBinding,
     type FormFieldsByFormIdI,
     type FormInfo,
+    type HolidayCatalog,
     type PdfField,
     type RecipientInfo,
+    type SaveScheduleRequest,
     type SchemaObject,
 } from '../../interface/types';
 import { extractGroupedFieldsFromDataModel, mapColorsToRecipients } from '../../utils';
@@ -30,10 +35,61 @@ export interface PdfEditorProps {
     hideConditionalLogic?: boolean;
     forms?: FormInfo[];
     zoomProps?: PdfCanvasProps['zoomProps'];
+    /**
+     * Holidays of the default business-day calendar, as `PdfView`'s `holidays`: the formula
+     * builder's preview of a date calculated field without its own calendar skips Saturday,
+     * Sunday and these days.
+     */
+    holidays?: string[];
+    /** Calendars of the date calculated fields bound to a schedule, by field id, as `PdfView`'s. */
+    fieldCalendars?: Record<string, BusinessCalendar>;
+    /**
+     * Date calculated fields whose custom business-day exclusion toggle is on, and the schedule
+     * each uses (`PdfField.id` as `fieldKey`), as `PdfView`'s. Also drives the Formula Builder's
+     * toggle/picker for the selected field.
+     */
+    scheduleBindings?: FieldScheduleBinding[];
+    /** The tenant's known holidays, for the schedule editor's checklist. */
+    holidayCatalog?: HolidayCatalog;
+    holidayCatalogLoading?: boolean;
+    holidayCatalogError?: string;
+    /** The schedules the tenant can pick from the Formula Builder's schedule picker. */
+    schedules?: BusinessDaySchedule[];
+    schedulesLoading?: boolean;
+    schedulesError?: string;
     onFormSelect?: (
         formIds: number[],
         sendFormFields: (formFieldsByFormId: FormFieldsByFormIdI) => void,
     ) => void;
+    /**
+     * Called with the complete desired `scheduleBindings` whenever the Formula Builder's toggle
+     * or schedule picker changes the selected field's binding (full replacement, mirroring DTE's
+     * `PUT api/holidays/templates/{id}/bindings`). `PdfEditor` does not persist this itself —
+     * the host is expected to save it (and the bindings are typically saved separately from the
+     * template's own fields).
+     */
+    onScheduleBindingsChange?(bindings: FieldScheduleBinding[]): void;
+    /**
+     * Creates a tenant schedule from the "Create New Schedule" drawer. Always creates a new
+     * schedule — it never overwrites a selected one. On success the created schedule is
+     * auto-selected in the picker. A rejected promise's `message` is shown as the drawer's error
+     * (for example a duplicate-name conflict).
+     */
+    onCreateSchedule?(request: SaveScheduleRequest): Promise<BusinessDaySchedule>;
+    /**
+     * Replaces a tenant schedule's name and rules in place, from the picker's "Edit" action
+     * (DTE's `PUT api/holidays/schedules/{id}`). Applies from the next conversion of every
+     * template using it. On success the updated schedule stays selected.
+     */
+    onUpdateSchedule?(id: number, request: SaveScheduleRequest): Promise<BusinessDaySchedule>;
+    /**
+     * Permanently deletes a tenant schedule, from the picker's "Delete" action (DTE's
+     * `DELETE api/holidays/schedules/{id}`). Fields still bound to it fall back to the default
+     * schedule — `PdfEditor` selects the default schedule for the current field on success, but
+     * does not itself update other fields' `scheduleBindings`; the host should drop bindings to
+     * a deleted schedule when it next saves them.
+     */
+    onDeleteSchedule?(id: number): Promise<void>;
     onLoadSuccess?(numPages: number): void;
     onFieldsChange(fields: PdfField[]): void;
 }
@@ -42,17 +98,30 @@ export const PdfEditor: FC<PdfEditorProps> = ({
     dataModel,
     errorPlaceholder,
     errors = {},
+    fieldCalendars,
     fields = [],
     forms,
     hideConditionalLogic,
     hideFields,
+    holidayCatalog,
+    holidayCatalogError,
+    holidayCatalogLoading,
+    holidays,
     loading = false,
     loadingPlaceholder,
+    onCreateSchedule,
+    onDeleteSchedule,
     onFieldsChange,
     onFormSelect,
     onLoadSuccess,
+    onScheduleBindingsChange,
+    onUpdateSchedule,
     pdfUrl,
     recipients = [],
+    scheduleBindings,
+    schedules,
+    schedulesError,
+    schedulesLoading,
     zoomProps,
     zoomable = true,
 }) => {
@@ -99,6 +168,19 @@ export const PdfEditor: FC<PdfEditorProps> = ({
                     recipients={recipients}
                     onDeselectField={pdfFieldSelection.deselectField}
                     hideConditionalLogic={hideConditionalLogic}
+                    holidays={holidays}
+                    fieldCalendars={fieldCalendars}
+                    scheduleBindings={scheduleBindings}
+                    onScheduleBindingsChange={onScheduleBindingsChange}
+                    holidayCatalog={holidayCatalog}
+                    holidayCatalogLoading={holidayCatalogLoading}
+                    holidayCatalogError={holidayCatalogError}
+                    schedules={schedules}
+                    schedulesLoading={schedulesLoading}
+                    schedulesError={schedulesError}
+                    onCreateSchedule={onCreateSchedule}
+                    onUpdateSchedule={onUpdateSchedule}
+                    onDeleteSchedule={onDeleteSchedule}
                     onRequestFormFields={formFields.requestFormFieldsById}
                 />
             )}

package/src/components/pdf-view/pdf-view-calculated.tsx

@@ -1,8 +1,15 @@
 import { FC, useMemo } from 'react';
-import { type DataModelValues, type PdfField, type PdfViewMode } from '../../interface/types';
+import {
+    type BusinessCalendar,
+    type DataModelValues,
+    type FieldScheduleBinding,
+    type PdfField,
+    type PdfViewMode,
+} from '../../interface/types';
 import {
     evaluateFormula,
     formatCalculatedResult,
+    getFieldDateCalcOptions,
     getFieldTextClipClassName,
     resolvePdfDataValues,
 } from '../../utils';
@@ -11,18 +18,26 @@ interface PdfViewCalculatedProps {
     field: PdfField;
     data?: DataModelValues;
     holidays?: string[];
+    fieldCalendars?: Record<string, BusinessCalendar>;
+    scheduleBindings?: FieldScheduleBinding[];
     viewMode?: PdfViewMode;
 }
 
 export const PdfViewCalculated: FC<PdfViewCalculatedProps> = ({
     data,
     field,
+    fieldCalendars,
     holidays,
+    scheduleBindings,
     viewMode,
 }) => {
     const displayValue = useMemo(() => {
         if (field.formula?.tokens?.length) {
-            const value = evaluateFormula(field.formula, data, holidays);
+            const value = evaluateFormula(
+                field.formula,
+                data,
+                getFieldDateCalcOptions(field.id, scheduleBindings, holidays, fieldCalendars),
+            );
             if (value === null) {
                 return '';
             }
@@ -32,7 +47,17 @@ export const PdfViewCalculated: FC<PdfViewCalculatedProps> = ({
             return resolvePdfDataValues(data, field.path) ?? '';
         }
         return field.label ?? '';
-    }, [data, field.formula, field.formulaFormat, field.label, field.path, holidays]);
+    }, [
+        data,
+        field.formula,
+        field.formulaFormat,
+        field.id,
+        field.label,
+        field.path,
+        fieldCalendars,
+        holidays,
+        scheduleBindings,
+    ]);
 
     const isPreview = viewMode === 'preview';
     const shouldShowPreviewFallback = isPreview && displayValue === '';

package/src/components/pdf-view/pdf-view.tsx

@@ -3,8 +3,10 @@ import { FC, ReactNode, useLayoutEffect, useMemo, useRef, useState } from 'react
 import { BASE_PAGE_WIDTH } from '../../constants';
 import { usePinchZoom, useZoom } from '../../hooks';
 import {
+    type BusinessCalendar,
     type DataChangePayload,
     type DataModelValues,
+    type FieldScheduleBinding,
     FieldTypeEnum,
     type PdfField,
     type PdfViewMode,
@@ -47,11 +49,25 @@ export interface PdfViewProps {
      */
     makeFillableFieldsReadonly?: boolean;
     /**
-     * UTC date strings (e.g. `'2026-03-17T00:00:00Z'`) treated as non-business days.
-     * When provided, date-based calculated fields skip weekends and these holidays
-     * when adding/subtracting days or computing date differences.
+     * Holidays of the default business-day calendar, as date strings (`'2026-07-03'`,
+     * `'2026-03-17T00:00:00Z'`). Date calculated fields without their own calendar skip
+     * Saturday, Sunday and these days when adding/subtracting days or computing date
+     * differences, within the current year ± 1.
      */
     holidays?: string[];
+    /**
+     * Calendars of the date calculated fields bound to a business-day schedule, by field id
+     * (`PdfField.id`), as DTE's `POST api/holidays/calendar` resolves them. Listed fields use
+     * only their calendar; the others use the default one (`holidays`).
+     */
+    fieldCalendars?: Record<string, BusinessCalendar>;
+    /**
+     * Date calculated fields whose custom business-day exclusion toggle is on, and the schedule
+     * each uses (DTE's bindings, `PdfField.id` as `fieldKey`). A field with no entry here uses
+     * plain calendar-day arithmetic — no weekend or holiday skipping — regardless of `holidays`
+     * or `fieldCalendars`.
+     */
+    scheduleBindings?: FieldScheduleBinding[];
     /**
      * fillingBy defines the list of recipient names
      * who are allowed to fill this field.
@@ -71,6 +87,7 @@ export const PdfView: FC<PdfViewProps> = ({
     enableInputNavigation = true,
     errorPlaceholder,
     errors = {},
+    fieldCalendars,
     fields,
     fillingBy,
     holidays,
@@ -81,6 +98,7 @@ export const PdfView: FC<PdfViewProps> = ({
     onLoadSuccess,
     pdfUrl,
     recipients,
+    scheduleBindings,
     viewMode,
     zoomProps,
     zoomable = true,
@@ -280,6 +298,8 @@ export const PdfView: FC<PdfViewProps> = ({
                                             field={field}
                                             data={viewMode === 'preview' ? previewData : data}
                                             holidays={holidays}
+                                            fieldCalendars={fieldCalendars}
+                                            scheduleBindings={scheduleBindings}
                                             viewMode={viewMode}
                                         />
                                     )}

package/src/constants/calculated.constants.ts

@@ -4,4 +4,11 @@ export const DEFAULT_DATE_FORMAT = 'MM/DD/YYYY';
 
 export const MAX_DATE_CALC_DAYS = 365;
 
+/**
+ * Years either side of the current one that the default business-day calendar covers, as DTE's
+ * (`HolidayCheckService.HolidayYearsWindow`): outside them its holidays are unknown, so date
+ * arithmetic is blank.
+ */
+export const DEFAULT_CALENDAR_YEARS = 1;
+
 export const MAX_DATE_DISPLAY_RANGE_YEARS = 2;

package/src/hooks/usePinchZoom.ts

@@ -1,10 +1,5 @@
 import { RefObject, useEffect, useRef } from 'react';
-import {
-    clampZoom,
-    getPinchZoomValue,
-    getTouchDistance,
-    getWheelZoomFactor,
-} from '../utils';
+import { clampZoom, getPinchZoomValue, getTouchDistance, getWheelZoomFactor } from '../utils';
 
 interface UsePinchZoomOptions {
     enabled: boolean;

package/src/interface/types.ts

@@ -86,6 +86,14 @@ export interface ESignDateSignedOffsetSettings {
     rules:
         | [ESignDateSignedOffsetSettingsFinalRule]
         | [...ESignDateSignedOffsetSettingsRule[], ESignDateSignedOffsetSettingsFinalRule];
+    /**
+     * Whether the day offset skips weekends/holidays per a business-day schedule, same toggle as a
+     * calculated field's (`FieldScheduleBinding`) but stored here instead, since - like `rules` -
+     * it applies to every `dateSignedOffset` field in the document, not one field at a time.
+     */
+    businessCalendarEnabled?: boolean;
+    /** The schedule to use while `businessCalendarEnabled` is on; undefined for the default schedule. */
+    scheduleId?: number;
 }
 
 export interface FillableDropdownItem {
@@ -246,6 +254,45 @@ export interface StructuredFormula {
     tokens: FormulaToken[];
 }
 
+/**
+ * Days a date calculated field skips, as DTE resolves a business-day schedule
+ * (`POST api/holidays/calendar`). Date arithmetic outside `firstYear`–`lastYear` is blank.
+ */
+export interface BusinessCalendar {
+    /** Excluded weekend days, as `Date.getUTCDay()` numbers them: 0 = Sunday, 6 = Saturday. */
+    weekendDays: number[];
+    /** Holiday dates, already moved to their observed days, as `YYYY-MM-DD`. */
+    holidays: string[];
+    firstYear: number;
+    lastYear: number;
+}
+
+/**
+ * Re-exported from `@servicetitan/dte-shared` so existing imports from this path keep
+ * working: the schedule editor UI (`ScheduleDrawer`/`SchedulePicker`) is shared with
+ * `@servicetitan/dte-unlayer` and lives there now, these types are its domain model.
+ */
+export type {
+    BusinessCalendarRules,
+    BusinessDaySchedule,
+    HolidayCatalog,
+    KnownHoliday,
+    SaveScheduleRequest,
+    WeekendDay,
+} from '@servicetitan/dte-shared';
+
+/**
+ * A date calculated field whose custom business-day exclusion toggle is on, and the schedule it
+ * uses (DTE's bindings, full-replace via `PUT api/holidays/templates/{id}/bindings`). A field with
+ * no entry here uses the default calendar with the toggle off (plain calendar-day arithmetic).
+ */
+export interface FieldScheduleBinding {
+    /** `PdfField.id`. */
+    fieldKey: string;
+    /** One of the tenant's schedules, or undefined for the default schedule. */
+    scheduleId?: number;
+}
+
 /** Format options for a calculated field with a numeric result (number, currency, percent) */
 export interface CalculatedFormatForNumber {
     resultType: 'number' | 'currency' | 'percent';

package/src/utils/field/__tests__/field-background-color.utils.test.ts

@@ -8,19 +8,19 @@ describe('getFieldColor', () => {
         expect(subject('signer1', { signer1: '#ff0000', signer2: '#00ff00' })).toBe('#ff0000');
     });
 
-    test('returns "none" when recipient is undefined', () => {
-        expect(subject(undefined, { signer1: '#ff0000' })).toBe('none');
+    test('returns undefined when recipient is undefined', () => {
+        expect(subject(undefined, { signer1: '#ff0000' })).toBeUndefined();
     });
 
-    test('returns "none" when recipient is empty string', () => {
-        expect(subject('', { signer1: '#ff0000' })).toBe('none');
+    test('returns undefined when recipient is empty string', () => {
+        expect(subject('', { signer1: '#ff0000' })).toBeUndefined();
     });
 
-    test('returns "none" when recipient is not in the color map', () => {
-        expect(subject('unknown', { signer1: '#ff0000' })).toBe('none');
+    test('returns undefined when recipient is not in the color map', () => {
+        expect(subject('unknown', { signer1: '#ff0000' })).toBeUndefined();
     });
 
-    test('returns "none" when color map is empty', () => {
-        expect(subject('signer1', {})).toBe('none');
+    test('returns undefined when color map is empty', () => {
+        expect(subject('signer1', {})).toBeUndefined();
     });
 });

package/src/utils/field/__tests__/get-field-bounds-style.utils.test.ts

@@ -38,6 +38,22 @@ describe('getFieldBoundsStyle', () => {
         });
     });
 
+    test('sets the recipient color variables when a color is given', () => {
+        expect(subject(buildField(), { color: '#ff0000' })).toMatchObject({
+            '--pdf-field-color': '#ff0000',
+            '--pdf-field-color-dark': '#ff0000',
+            '--pdf-field-opacity-color': '#ff00001f',
+        });
+    });
+
+    test('leaves the color variables unset without a color, so the stylesheet defaults apply', () => {
+        const style = subject(buildField(), { color: undefined });
+
+        expect(style).not.toHaveProperty('--pdf-field-color');
+        expect(style).not.toHaveProperty('--pdf-field-color-dark');
+        expect(style).not.toHaveProperty('--pdf-field-opacity-color');
+    });
+
     test('converts font size from points to editor pixels', () => {
         const style = subject(buildField({ styles: { fontSize: 12 } }));
         expect(style.fontSize).toBe(`${pointsToPixels(12)}px`);

package/src/utils/formula/__tests__/evaluate-formula.utils.test.ts

@@ -1,5 +1,17 @@
-import { type DataModelValues, type StructuredFormula } from '../../../interface/types';
-import { evaluateFormula, hasDivisionByZero, valueToNumber } from '../evaluate-formula.utils';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import {
+    type BusinessCalendar,
+    type DataModelValues,
+    type FieldScheduleBinding,
+    type StructuredFormula,
+} from '../../../interface/types';
+import {
+    evaluateFormula,
+    getFieldDateCalcOptions,
+    hasDivisionByZero,
+    valueToNumber,
+} from '../evaluate-formula.utils';
 
 const f = (tokens: StructuredFormula['tokens']): StructuredFormula => ({ tokens });
 
@@ -35,7 +47,7 @@ describe('evaluateFormula', () => {
         formula: StructuredFormula | undefined | null,
         data: DataModelValues | undefined,
         holidays?: string[],
-    ) => evaluateFormula(formula, data, holidays);
+    ) => evaluateFormula(formula, data, { enabled: true, holidays });
 
     describe('when formula is empty', () => {
         test.each([
@@ -180,6 +192,18 @@ describe('evaluateFormula', () => {
     });
 
     describe('with date fields', () => {
+        // The default calendar covers the current year ± 1.
+        beforeAll(() => {
+            jest.useFakeTimers({ now: new Date('2024-06-01T00:00:00Z') });
+        });
+
+        afterAll(() => {
+            jest.useRealTimers();
+        });
+
+        const dateKey = (result: number | null) =>
+            result === null ? null : new Date(result).toISOString().slice(0, 10);
+
         test('adds business days to a date field (skipping weekend)', () => {
             // Friday 2024-01-05 + 1 business day = Monday 2024-01-08
             const formula = f([
@@ -187,22 +211,18 @@ describe('evaluateFormula', () => {
                 { type: 'operator', value: '+' },
                 { type: 'number', value: '1' },
             ]);
-            const result = subject(formula, { d: '2024-01-05' });
-            expect(result).not.toBeNull();
-            const date = new Date(result as number);
-            expect(date.getUTCFullYear()).toBe(2024);
-            expect(date.getUTCMonth()).toBe(0);
-            expect(date.getUTCDate()).toBe(8);
+            expect(dateKey(subject(formula, { d: '2024-01-05' }))).toBe('2024-01-08');
         });
 
-        test('counts business days when subtracting later date from earlier date', () => {
-            // start - end traverses Mon 2024-01-01 → Fri 2024-01-05 = 4 business days
+        test('counts D1 - D2 from D2 to D1, positive when D1 is later', () => {
+            // end - start traverses Mon 2024-01-01 → Fri 2024-01-05 = 4 business days
             const formula = f([
-                { type: 'field', path: 'start', fieldType: 'date' },
-                { type: 'operator', value: '-' },
                 { type: 'field', path: 'end', fieldType: 'date' },
+                { type: 'operator', value: '-' },
+                { type: 'field', path: 'start', fieldType: 'date' },
             ]);
             expect(subject(formula, { start: '2024-01-01', end: '2024-01-05' })).toBe(4);
+            expect(subject(formula, { start: '2024-01-05', end: '2024-01-01' })).toBe(-4);
         });
 
         test('skips holidays when adding business days', () => {
@@ -212,9 +232,43 @@ describe('evaluateFormula', () => {
                 { type: 'operator', value: '+' },
                 { type: 'number', value: '1' },
             ]);
-            const result = subject(formula, { d: '2024-01-08' }, ['2024-01-09']);
-            expect(result).not.toBeNull();
-            expect(new Date(result as number).getUTCDate()).toBe(10);
+            expect(dateKey(subject(formula, { d: '2024-01-08' }, ['2024-01-09']))).toBe(
+                '2024-01-10',
+            );
+        });
+
+        test('applies chained offsets one step at a time', () => {
+            // D - 1 + 2 from Sat 2024-10-05: Fri 10-04, then Tue 10-08
+            const formula = f([
+                { type: 'field', path: 'd', fieldType: 'date' },
+                { type: 'operator', value: '-' },
+                { type: 'number', value: '1' },
+                { type: 'operator', value: '+' },
+                { type: 'number', value: '2' },
+            ]);
+            expect(dateKey(subject(formula, { d: '2024-10-05' }))).toBe('2024-10-08');
+        });
+
+        test.each([
+            ['a fractional offset', { d: '2024-09-30', n: '2.5' }],
+            ['a start outside the current year ± 1', { d: '2022-06-01', n: '1' }],
+            ['a result outside the current year ± 1', { d: '2025-12-31', n: '1' }],
+        ])('returns null for %s', (_, data) => {
+            const formula = f([
+                { type: 'field', path: 'd', fieldType: 'date' },
+                { type: 'operator', value: '+' },
+                { type: 'field', path: 'n', fieldType: 'number' },
+            ]);
+            expect(subject(formula, data)).toBeNull();
+        });
+
+        test('returns null for a difference over 365 days', () => {
+            const formula = f([
+                { type: 'field', path: 'end', fieldType: 'date' },
+                { type: 'operator', value: '-' },
+                { type: 'field', path: 'start', fieldType: 'date' },
+            ]);
+            expect(subject(formula, { start: '2024-01-02', end: '2025-01-05' })).toBeNull();
         });
 
         test('returns null when date field has invalid value', () => {
@@ -225,5 +279,133 @@ describe('evaluateFormula', () => {
             ]);
             expect(subject(formula, { d: 'not-a-date' })).toBeNull();
         });
+
+        test('uses only the field calendar when one is passed', () => {
+            // Fri 2026-07-10 + 1 = Sat 2026-07-11 with a Sunday-only calendar, outside today's years.
+            const formula = f([
+                { type: 'field', path: 'd', fieldType: 'date' },
+                { type: 'operator', value: '+' },
+                { type: 'number', value: '1' },
+            ]);
+            const calendar: BusinessCalendar = {
+                weekendDays: [0],
+                holidays: [],
+                firstYear: 2026,
+                lastYear: 2026,
+            };
+            const result = evaluateFormula(formula, { d: '2026-07-10' }, { enabled: true, calendar });
+            expect(dateKey(result)).toBe('2026-07-11');
+        });
+
+        test('uses plain calendar-day arithmetic (no skipping) when the toggle is disabled', () => {
+            // Friday 2024-01-05 + 1 day = Saturday 2024-01-06, unskipped, regardless of holidays passed.
+            const formula = f([
+                { type: 'field', path: 'd', fieldType: 'date' },
+                { type: 'operator', value: '+' },
+                { type: 'number', value: '1' },
+            ]);
+            const result = evaluateFormula(
+                formula,
+                { d: '2024-01-05' },
+                { enabled: false, holidays: ['2024-01-06'] },
+            );
+            expect(dateKey(result)).toBe('2024-01-06');
+        });
+
+        test('uses plain calendar-day diff (no skipping) when the toggle is disabled', () => {
+            // Plain calendar days between Mon 2024-01-01 and Fri 2024-01-05 is 4, same as business days
+            // here, so use a span that differs: Fri 2024-01-05 -> Mon 2024-01-08 is 3 calendar days but
+            // only 1 business day.
+            const formula = f([
+                { type: 'field', path: 'end', fieldType: 'date' },
+                { type: 'operator', value: '-' },
+                { type: 'field', path: 'start', fieldType: 'date' },
+            ]);
+            const result = evaluateFormula(
+                formula,
+                { start: '2024-01-05', end: '2024-01-08' },
+                { enabled: false },
+            );
+            expect(result).toBe(3);
+        });
+    });
+});
+
+describe('getFieldDateCalcOptions', () => {
+    const calendar: BusinessCalendar = {
+        weekendDays: [0],
+        holidays: [],
+        firstYear: 2026,
+        lastYear: 2027,
+    };
+    const scheduleBindings: FieldScheduleBinding[] = [{ fieldKey: 'a' }, { fieldKey: 'b' }];
+
+    test.each([
+        ['the field calendar for a bound, listed field', 'a', { enabled: true, calendar }],
+        [
+            'the default holidays for a bound field with no calendar entry',
+            'b',
+            { enabled: true, holidays: ['2026-07-03'] },
+        ],
+        ['disabled for an unbound field', 'c', { enabled: false }],
+        ['disabled without a field id', undefined, { enabled: false }],
+    ])('returns %s', (_, fieldId, expected) => {
+        expect(
+            getFieldDateCalcOptions(fieldId, scheduleBindings, ['2026-07-03'], { a: calendar }),
+        ).toEqual(expected);
+    });
+});
+
+describe('business-day parity fixture', () => {
+    // DTE's shared business-day cases; packages/unlayer's date-calc test checks the copy's hash.
+    const fixture: {
+        calendars: Record<string, BusinessCalendar>;
+        cases: {
+            name: string;
+            calendar: string;
+            start: string;
+            steps?: number[];
+            end?: string | null;
+            expected: string | number | null;
+        }[];
+    } = JSON.parse(
+        readFileSync(
+            resolve(__dirname, '../../../../../../tests/fixtures/business-day-cases.json'),
+            'utf-8',
+        ),
+    );
+
+    type FixtureCase = (typeof fixture.cases)[number];
+
+    // The case as a BYOD formula: `start ± step ± step …`, or `end - start`.
+    const toFormula = (testCase: FixtureCase): StructuredFormula => {
+        if ('end' in testCase) {
+            return f([
+                { type: 'field', path: 'end', fieldType: 'date' },
+                { type: 'operator', value: '-' },
+                { type: 'field', path: 'start', fieldType: 'date' },
+            ]);
+        }
+        return f([
+            { type: 'field', path: 'start', fieldType: 'date' },
+            ...(testCase.steps ?? []).flatMap((step): StructuredFormula['tokens'] => [
+                { type: 'operator', value: step < 0 ? '-' : '+' },
+                { type: 'number', value: String(Math.abs(step)) },
+            ]),
+        ]);
+    };
+
+    test.each(fixture.cases.map(c => [c.name, c] as const))('%s', (_, testCase) => {
+        const data = { start: testCase.start, end: testCase.end ?? '' };
+        const result = evaluateFormula(toFormula(testCase), data, {
+            enabled: true,
+            calendar: fixture.calendars[testCase.calendar],
+        });
+
+        const actual =
+            result === null || 'end' in testCase
+                ? result
+                : new Date(result).toISOString().slice(0, 10);
+        expect(actual).toBe(testCase.expected);
     });
 });