@servicetitan/dte-pdf-editor 1.95.0 → 1.96.0

package/src/components/field-config-panel/formula-modal.tsx

@@ -1,6 +1,7 @@
 import { Button, Dialog, Divider, Flex } from '@servicetitan/anvil2';
 import IconRedo from '@servicetitan/anvil2/assets/icons/material/round/redo.svg';
 import IconUndo from '@servicetitan/anvil2/assets/icons/material/round/undo.svg';
+import { type ScheduleEditorContext } from '@servicetitan/dte-shared';
 import { FC, useCallback, useEffect, useMemo, useState } from 'react';
 import {
     DEFAULT_DATE_CALCULATED_FORMAT,
@@ -18,6 +19,7 @@ import {
     type StructuredFormula,
 } from '../../interface/types';
 import {
+    type DateCalcOptions,
     evaluateFormula,
     formatCalculatedResult,
     formFieldInfosToCalculationOptions,
@@ -68,7 +70,10 @@ function setSampleValueAtPath(target: DataModelValues, path: string, value: unkn
 export interface FormulaModalProps {
     initialFormula: StructuredFormula | undefined;
     initialFormat?: CalculatedFieldFormat;
+    businessCalendar?: ScheduleEditorContext;
     dataModelGroups: DataModelFieldGroup[];
+    /** The calendar the preview uses: the field's own, or the default one. */
+    dateCalcOptions?: DateCalcOptions;
     fillableFieldsFromDocument?: FieldTypeOption[];
     formFieldsByFormId?: FormFieldsByFormIdI;
     forms: FormInfo[];
@@ -79,7 +84,9 @@ export interface FormulaModalProps {
 }
 
 export const FormulaModal: FC<FormulaModalProps> = ({
+    businessCalendar,
     dataModelGroups,
+    dateCalcOptions,
     fillableFieldsFromDocument = [],
     formFieldsByFormId = {},
     forms,
@@ -255,21 +262,28 @@ export const FormulaModal: FC<FormulaModalProps> = ({
         if (parsedTokens.length === 0 || !formulaValidation.valid) {
             return '';
         }
-        return hasDivisionByZero({ tokens: parsedTokens }, sampleData)
+        return hasDivisionByZero({ tokens: parsedTokens }, sampleData, dateCalcOptions)
             ? 'Division by zero is not allowed'
             : '';
-    }, [parsedTokens, formulaValidation.valid, sampleData]);
+    }, [parsedTokens, formulaValidation.valid, sampleData, dateCalcOptions]);
 
     const previewValue = useMemo(() => {
         if (parsedTokens.length === 0 || !formulaValidation.valid || divisionByZeroError) {
             return '';
         }
-        const computed = evaluateFormula({ tokens: parsedTokens }, sampleData);
+        const computed = evaluateFormula({ tokens: parsedTokens }, sampleData, dateCalcOptions);
         if (computed === null) {
             return '';
         }
         return formatCalculatedResult(computed, format);
-    }, [parsedTokens, formulaValidation.valid, divisionByZeroError, sampleData, format]);
+    }, [
+        parsedTokens,
+        formulaValidation.valid,
+        divisionByZeroError,
+        sampleData,
+        format,
+        dateCalcOptions,
+    ]);
 
     const handleClose = useCallback(() => {
         onClose();
@@ -317,6 +331,7 @@ export const FormulaModal: FC<FormulaModalProps> = ({
                         selectedPaths={formulaEditor.selectedFieldPaths}
                     />
                     <FormulaWorkspace
+                        businessCalendar={businessCalendar}
                         disabledOperators={formulaEditor.disabledOperators}
                         editorRef={formulaEditor.editorRef}
                         isInvalid={isInvalid && formulaEditor.isDirty}

package/src/components/field-config-panel/formula-workspace.tsx

@@ -1,4 +1,8 @@
-import { Alert, Button, Flex, LinkButton, Text } from '@servicetitan/anvil2';
+import { Alert, Button, Flex, Text } from '@servicetitan/anvil2';
+import IconExpandMore from '@servicetitan/anvil2/assets/icons/material/round/expand_more.svg';
+import IconArrowForward from '@servicetitan/anvil2/assets/icons/material/round/keyboard_arrow_right.svg';
+
+import { type ScheduleEditorContext } from '@servicetitan/dte-shared';
 import {
     Dispatch,
     FC,
@@ -17,6 +21,7 @@ import { ResultTypeSelector } from './result-type-selector';
 interface FormulaWorkspaceProps {
     actions: ReactNode;
     advancedOpen: boolean;
+    businessCalendar?: ScheduleEditorContext;
     disabledOperators?: Set<string>;
     editorRef: RefObject<HTMLDivElement | null>;
     format: CalculatedFieldFormat;
@@ -38,6 +43,7 @@ interface FormulaWorkspaceProps {
 export const FormulaWorkspace: FC<FormulaWorkspaceProps> = ({
     actions,
     advancedOpen,
+    businessCalendar,
     disabledOperators,
     editorRef,
     format,
@@ -75,7 +81,7 @@ export const FormulaWorkspace: FC<FormulaWorkspaceProps> = ({
     );
 
     return (
-        <Flex direction="column" flex={1} gap={2} style={{ padding: '12px' }}>
+        <Flex direction="column" flex={1} gap={2} style={{ padding: '12px', overflowY: 'auto' }}>
             <Flex direction="column" gap={1}>
                 <Text variant="body" size="small">
                     Preview (uses demo sample data)
@@ -132,10 +138,29 @@ export const FormulaWorkspace: FC<FormulaWorkspaceProps> = ({
                 })}
             </Flex>
             <ResultTypeSelector format={format} onChange={onResultTypeChange} />
-            <LinkButton appearance="primary" onClick={onToggleAdvanced}>
-                {advancedOpen ? 'Hide advanced settings' : 'Show advanced settings'}
-            </LinkButton>
-            {advancedOpen && <AdvancedSettings format={format} setFormat={setFormat} />}
+            <Flex
+                role="button"
+                onClick={onToggleAdvanced}
+                alignItems="center"
+                gap={1}
+                style={{ cursor: 'pointer', marginTop: 16 }}
+            >
+                <Text variant="eyebrow" size="small">
+                    Advanced settings
+                </Text>
+                {advancedOpen ? (
+                    <IconExpandMore fontSize="small" />
+                ) : (
+                    <IconArrowForward fontSize="small" />
+                )}
+            </Flex>
+            {advancedOpen && (
+                <AdvancedSettings
+                    format={format}
+                    setFormat={setFormat}
+                    businessCalendar={businessCalendar}
+                />
+            )}
         </Flex>
     );
 };

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`);