@servicetitan/dte-unlayer 0.157.0 → 0.159.0

package/src/editor.tsx

@@ -7,6 +7,9 @@ import {
     useRef,
     useState,
 } from 'react';
+import { useBusinessCalendarState } from './business-calendar/business-calendar-state';
+import { BusinessCalendarDrawer } from './business-calendar/BusinessCalendarDrawer';
+import { useBusinessCalendarRequests } from './business-calendar/useBusinessCalendarRequests';
 import { DisplayConditionModal } from './display-conditions/DisplayConditionModal';
 import { ESignDateSignedOffsetModal } from './e-sign-offset/ESignDateSignedOffsetModal';
 import { getErrorMessage } from './log';
@@ -133,6 +136,9 @@ export const UnlayerEditor = forwardRef<UnlayerRef, UnlayerEditorProps>((props,
         return () => store.setOnCalcFieldSelect();
     }, [props.opts.onCalcFieldSelect, store]);
 
+    const businessCalendar = useBusinessCalendarRequests(store, props.opts);
+    useBusinessCalendarState(store, props.opts);
+
     const { minHeight = 800, style = {} } = props;
 
     return (
@@ -155,6 +161,15 @@ export const UnlayerEditor = forwardRef<UnlayerRef, UnlayerEditorProps>((props,
                     onConditionFormSelect={props.opts.onConditionFormSelect}
                 />
             )}
+            {businessCalendar.drawer && props.opts.onScheduleBindingsChange && (
+                <BusinessCalendarDrawer
+                    key={businessCalendar.drawer.id}
+                    request={businessCalendar.drawer}
+                    host={props.opts}
+                    portalContainer={props.opts.displayConditionModalPortalContainer}
+                    onClose={businessCalendar.closeDrawer}
+                />
+            )}
         </div>
     );
 });

package/src/index.ts

@@ -21,3 +21,13 @@ export { versions } from './unlayer';
 export * from './shared/date-calc';
 export { emptyArrayIfNull } from './shared/nunjucks-helpers';
 export * from './display-conditions/lookupOptionsController';
+export type {
+    BusinessCalendarHostProps,
+    BusinessCalendarRules,
+    BusinessDaySchedule,
+    FieldScheduleBinding,
+    HolidayCatalog,
+    KnownHoliday,
+    SaveScheduleRequest,
+    WeekendDay,
+} from '@servicetitan/dte-shared';

package/src/shared/const.ts

@@ -1,4 +1,6 @@
+import type { BusinessDaySchedule, HolidayCatalog } from '@servicetitan/dte-shared';
 import type { DisplayConditionState } from '../display-conditions/types';
+import type { BusinessCalendar } from './date-calc';
 import { SchemaObject } from './schema';
 
 export const constGenericsEditor = {
@@ -48,6 +50,62 @@ export interface UnlayerEventESignOffset {
     value: ESignDateSignedOffsetSettings;
 }
 
+/**
+ * Names shown for e-sign field types whose title differs from the type list entry it is derived
+ * from (by type value). Only the label changes: the stored value stays, so saved designs and the
+ * `esign_<recipient>_<type>` placeholder are unaffected.
+ */
+export const E_SIGN_FIELD_TYPE_LABELS: Readonly<Record<string, string | undefined>> = {
+    [E_SIGN_DATE_SIGNED_OFFSET_TYPE]: 'Calculated Signing Date',
+};
+
+/**
+ * Payload of `--business-calendar-request` (iframe to parent): what a date field's inline schedule
+ * settings (a calculated field's or an e-sign "Date Signed Offset" field's) ask the parent window
+ * to do. `fieldKey` is the tool's instance id (`values.id`), the key DTE binds the schedule to.
+ * - `toggle` / `select`: the exclusion toggle and the schedule picker.
+ * - `create` / `edit`: open the schedule drawer, for a new schedule or `scheduleId`.
+ * - `delete`: delete the selected schedule; the outcome comes back as `--business-calendar-result`.
+ */
+export type UnlayerEventBusinessCalendarRequest =
+    | { action: 'toggle'; fieldKey: string; enabled: boolean }
+    | { action: 'select'; fieldKey: string; scheduleId?: number }
+    | { action: 'create'; fieldKey: string }
+    | { action: 'edit'; fieldKey: string; scheduleId: number }
+    | { action: 'delete'; fieldKey: string; scheduleId: number; requestId: string };
+
+/** Payload of `--business-calendar-result` (parent to iframe): how a `delete` request ended. */
+export interface UnlayerEventBusinessCalendarResult {
+    requestId: string;
+    /** Why it failed, shown under the schedule; absent on success. */
+    error?: string;
+}
+
+/**
+ * Payload of `--business-calendar-state` (parent to iframe), sent whenever the host's schedule
+ * props change: what the property editors show and the calendars the previews use.
+ */
+export interface UnlayerEventBusinessCalendarState {
+    /** Whether the host edits schedules (it passes `onScheduleBindingsChange`). */
+    enabled: boolean;
+    /** The fields whose exclusion toggle is on, by field key, with their schedule (none: default). */
+    bindings: Record<string, { scheduleId?: number }>;
+    /** The schedules a field can pick, default first, as the host passes them. */
+    schedules: BusinessDaySchedule[];
+    schedulesLoading?: boolean;
+    schedulesError?: string;
+    /** The tenant's known holidays, for the schedule preview's names. */
+    holidayCatalog?: HolidayCatalog;
+    holidayCatalogLoading?: boolean;
+    holidayCatalogError?: string;
+    /** Whether the host can delete schedules (it passes `onDeleteSchedule`). */
+    canDeleteSchedule: boolean;
+    /** Calendars of the bound fields, by field key. */
+    fieldCalendars: Record<string, BusinessCalendar>;
+    /** The default calendar's holidays. */
+    holidays?: string[];
+}
+
 export interface UnlayerEditorUnit {
     id: string;
     generic: string;
@@ -69,6 +127,7 @@ export interface UnlayerEventConfig {
     isSnapshotMode?: boolean;
     units?: UnlayerEditorUnit[];
     holidays?: string[];
+    fieldCalendars?: Record<string, BusinessCalendar>;
     conditionalRulesEnabled?: boolean;
 }
 
@@ -76,6 +135,8 @@ export interface UnlayerEventRegister {
     units?: UnlayerEditorUnit[];
     eSignRecipients?: UnlayerEditorESignRecipientInfo[];
     eSignFieldTypes?: string[];
+    /** {@link E_SIGN_FIELD_TYPE_LABELS}, for the e-sign tool's canvas label. */
+    eSignFieldTypeLabels?: Readonly<Record<string, string | undefined>>;
     customTools?: {
         key: string;
         title?: string;

package/src/shared/date-calc.ts

@@ -1,23 +1,10 @@
 export const MAX_DATE_CALC_DAYS = 365;
 
 /**
- * Fallback US federal holidays used when the store config does not provide a
- * holidays list.  Keep in sync with any similar inline arrays elsewhere (e.g.
- * components/scripts/comps/calculated-field.ts).
+ * The years DTE knows holidays for (`HolidayCheckService.HolidayYearsWindow`): outside them a
+ * default-calendar answer would skip weekends but miss holidays, so it is left blank, as in BYOD.
  */
-export const DEFAULT_HOLIDAYS: string[] = [
-    '2026-01-01T00:00:00.000Z',
-    '2026-01-19T00:00:00.000Z',
-    '2026-02-16T00:00:00.000Z',
-    '2026-05-25T00:00:00.000Z',
-    '2026-07-04T00:00:00.000Z',
-    '2026-09-07T00:00:00.000Z',
-    '2026-11-26T00:00:00.000Z',
-    '2026-11-27T00:00:00.000Z',
-    '2026-12-25T00:00:00.000Z',
-];
-
-export const DATE_RANGE_YEARS = 2;
+export const DATE_RANGE_YEARS = 1;
 
 /**
  * Returns true if the date's year falls within [currentYear - DATE_RANGE_YEARS, currentYear + DATE_RANGE_YEARS].
@@ -36,10 +23,40 @@ export function isDateWithinRange(dateInput: unknown): boolean {
     return year >= currentYear - DATE_RANGE_YEARS && year <= currentYear + DATE_RANGE_YEARS;
 }
 
+/**
+ * Days a date calculation skips, as DTE resolves them (`POST api/holidays/calendar`, and the
+ * `calendars` noderenderer receives). Arithmetic outside `firstYear`–`lastYear` is blank; without
+ * years no year limit applies.
+ */
+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 | null;
+    lastYear?: number | null;
+}
+
+/** Saturday and Sunday: the default calendar's weekend. */
+export const DEFAULT_WEEKEND_DAYS = [0, 6];
+
+/**
+ * Which calendar a calculation uses. With `calendar` (a field bound to a schedule) only that
+ * calendar applies. Without it, the default calendar applies: Saturday and Sunday plus `holidays`,
+ * with the start and the result limited to the current year ± DATE_RANGE_YEARS.
+ */
 export interface DateCalcOptions {
+    calendar?: BusinessCalendar;
     holidays?: string[];
 }
 
+interface PreparedCalendar {
+    weekendDays: Set<number>;
+    holidays: Set<string>;
+    firstYear: number | null;
+    lastYear: number | null;
+}
+
 function toDateOnly(input: string | Date): Date {
     const d = typeof input === 'string' ? new Date(input) : new Date(input.getTime());
     d.setUTCHours(0, 0, 0, 0);
@@ -53,96 +70,121 @@ function toDateKey(d: Date): string {
     return `${y}-${m}-${day}`;
 }
 
-function isWeekend(d: Date): boolean {
-    const day = d.getUTCDay();
-    return day === 0 || day === 6;
+function parseDate(input: unknown): Date | null {
+    if (typeof input !== 'string' && !(input instanceof Date)) {
+        return null;
+    }
+    const d = toDateOnly(input);
+    return isFinite(d.getTime()) ? d : null;
 }
 
 function buildHolidaySet(holidays?: string[]): Set<string> {
-    if (!holidays?.length) {
-        return new Set();
-    }
     const set = new Set<string>();
-    for (const h of holidays) {
-        const d = toDateOnly(h);
-        if (!isNaN(d.getTime())) {
+    for (const h of holidays ?? []) {
+        const d = parseDate(h);
+        if (d) {
             set.add(toDateKey(d));
         }
     }
     return set;
 }
 
-function isNonBusinessDay(d: Date, holidaySet: Set<string>): boolean {
-    if (isWeekend(d)) {
-        return true;
+// Calendars are passed once and reused by every calculation, so each is prepared once.
+const preparedCalendars = new WeakMap<BusinessCalendar, PreparedCalendar>();
+
+function prepareCalendar(calendar: BusinessCalendar): PreparedCalendar {
+    const cached = preparedCalendars.get(calendar);
+    if (cached) {
+        return cached;
     }
-    if (holidaySet.size > 0 && holidaySet.has(toDateKey(d))) {
-        return true;
+
+    const prepared: PreparedCalendar = {
+        weekendDays: new Set(calendar.weekendDays ?? DEFAULT_WEEKEND_DAYS),
+        holidays: buildHolidaySet(calendar.holidays),
+        firstYear: calendar.firstYear ?? null,
+        lastYear: calendar.lastYear ?? null,
+    };
+    preparedCalendars.set(calendar, prepared);
+    return prepared;
+}
+
+// One calendar per holidays array, so the default calendar is also prepared once.
+const holidayCalendars = new WeakMap<string[], BusinessCalendar>();
+const NO_HOLIDAYS_CALENDAR: BusinessCalendar = { weekendDays: DEFAULT_WEEKEND_DAYS, holidays: [] };
+
+function defaultCalendar(holidays?: string[]): BusinessCalendar {
+    if (!Array.isArray(holidays)) {
+        return NO_HOLIDAYS_CALENDAR;
     }
-    return false;
+    let calendar = holidayCalendars.get(holidays);
+    if (!calendar) {
+        calendar = { weekendDays: DEFAULT_WEEKEND_DAYS, holidays };
+        holidayCalendars.set(holidays, calendar);
+    }
+    return calendar;
+}
+
+function isBusinessDay(d: Date, calendar: PreparedCalendar): boolean {
+    return !calendar.weekendDays.has(d.getUTCDay()) && !calendar.holidays.has(toDateKey(d));
+}
+
+function isWithinYears(d: Date, calendar: PreparedCalendar): boolean {
+    const year = d.getUTCFullYear();
+    return (
+        (calendar.firstYear === null || year >= calendar.firstYear) &&
+        (calendar.lastYear === null || year <= calendar.lastYear)
+    );
 }
 
 /**
- * Add business days to a date, always skipping weekends and provided holidays.
- * Negative days subtracts.
+ * Walks `days` business days from `start` (negative walks back); the start is not counted.
+ * Mirrors `BusinessDayCalculator.AddBusinessDays` in DTE: null for more than MAX_DATE_CALC_DAYS,
+ * or when the start or the walk leaves the calendar's years.
  */
-export function addDays(dateInput: string | Date, days: number, options?: DateCalcOptions): Date {
-    const result = toDateOnly(dateInput);
-    if (!isFinite(result.getTime())) {
-        return result;
-    }
-
-    const intDays = Math.trunc(days);
-    if (intDays === 0) {
-        return result;
-    }
-    if (Math.abs(intDays) > MAX_DATE_CALC_DAYS) {
-        return new Date(NaN);
+function addBusinessDays(start: Date, days: number, calendar: PreparedCalendar): Date | null {
+    if (Math.abs(days) > MAX_DATE_CALC_DAYS || !isWithinYears(start, calendar)) {
+        return null;
     }
 
-    const holidaySet = buildHolidaySet(options?.holidays);
-    const direction = intDays > 0 ? 1 : -1;
-    let remaining = Math.abs(intDays);
+    const direction = days >= 0 ? 1 : -1;
+    let remaining = Math.abs(days);
+    const current = new Date(start.getTime());
 
     while (remaining > 0) {
-        result.setUTCDate(result.getUTCDate() + direction);
-        if (!isNonBusinessDay(result, holidaySet)) {
+        current.setUTCDate(current.getUTCDate() + direction);
+        if (!isWithinYears(current, calendar)) {
+            return null;
+        }
+        if (isBusinessDay(current, calendar)) {
             remaining--;
         }
     }
 
-    return result;
+    return current;
 }
 
 /**
- * Count the number of business days between two dates, always skipping weekends and provided holidays.
- * Returns a positive number when `to` is after `from`, negative otherwise.
+ * Counts the business days from `from` to `to`, negative when `to` is earlier; the start is not
+ * counted, the end is. Mirrors `BusinessDayCalculator.CountBusinessDays` in DTE: null for a span
+ * over MAX_DATE_CALC_DAYS, or a date outside the calendar's years.
  */
-export function dateDiffDays(
-    from: string | Date,
-    to: string | Date,
-    options?: DateCalcOptions,
-): number {
-    const start = toDateOnly(from);
-    const end = toDateOnly(to);
-
-    if (!isFinite(start.getTime()) || !isFinite(end.getTime())) {
-        return 0;
-    }
-
-    const calendarDiff = Math.abs(end.getTime() - start.getTime()) / (24 * 60 * 60 * 1000);
-    if (calendarDiff > MAX_DATE_CALC_DAYS * 2) {
-        return NaN;
+function countBusinessDays(from: Date, to: Date, calendar: PreparedCalendar): number | null {
+    const span = Math.abs(to.getTime() - from.getTime()) / (24 * 60 * 60 * 1000);
+    if (
+        span > MAX_DATE_CALC_DAYS ||
+        !isWithinYears(from, calendar) ||
+        !isWithinYears(to, calendar)
+    ) {
+        return null;
     }
 
-    const holidaySet = buildHolidaySet(options?.holidays);
-    const direction = end.getTime() >= start.getTime() ? 1 : -1;
-    const cursor = new Date(start.getTime());
+    const direction = to.getTime() >= from.getTime() ? 1 : -1;
+    const cursor = new Date(from.getTime());
     let count = 0;
 
-    while (toDateKey(cursor) !== toDateKey(end)) {
+    while (toDateKey(cursor) !== toDateKey(to)) {
         cursor.setUTCDate(cursor.getUTCDate() + direction);
-        if (!isNonBusinessDay(cursor, holidaySet)) {
+        if (isBusinessDay(cursor, calendar)) {
             count++;
         }
     }
@@ -150,12 +192,47 @@ export function dateDiffDays(
     return count * direction;
 }
 
-/** Format a Date to ISO date string (YYYY-MM-DD). */
-export function formatDateResult(date: Date): string {
-    if (!isFinite(date.getTime())) {
-        return '';
+/**
+ * Adds business days to a date, as DTE's noderenderer `dateAddDays` does. Returns the result as
+ * `YYYY-MM-DD`, or null (a blank field, as in BYOD) for an invalid date, a fractional offset, or
+ * a start or result outside the calendar's years.
+ */
+export function addDays(
+    dateInput: unknown,
+    daysInput: unknown,
+    options?: DateCalcOptions,
+): string | null {
+    const isDefault = !options?.calendar;
+    const calendar = prepareCalendar(options?.calendar ?? defaultCalendar(options?.holidays));
+    const start = parseDate(dateInput);
+    const days = Number(daysInput);
+    if (!start || !Number.isInteger(days) || (isDefault && !isDateWithinRange(start))) {
+        return null;
+    }
+    const result = addBusinessDays(start, days, calendar);
+    if (!result || (isDefault && !isDateWithinRange(result))) {
+        return null;
+    }
+    return toDateKey(result);
+}
+
+/**
+ * Counts the business days from `from` to `to` (positive when `to` is later), as DTE's
+ * noderenderer `dateDiffDays` does. A formula's `D1 - D2` counts from D2 to D1. Null (a blank
+ * field) for an invalid or missing date, or a span over MAX_DATE_CALC_DAYS.
+ */
+export function dateDiffDays(
+    fromInput: unknown,
+    toInput: unknown,
+    options?: DateCalcOptions,
+): number | null {
+    const calendar = prepareCalendar(options?.calendar ?? defaultCalendar(options?.holidays));
+    const from = parseDate(fromInput);
+    const to = parseDate(toInput);
+    if (!from || !to) {
+        return null;
     }
-    return toDateKey(date);
+    return countBusinessDays(from, to, calendar);
 }
 
 export const DEFAULT_DATE_FORMAT = 'MM/DD/YYYY';

package/src/shared/instance-id.ts

@@ -1,9 +1,14 @@
+import { E_SIGN_TOOL_SLUG } from './const';
+
 /**
  * Custom tools whose `values.id` is a per-instance GUID that must stay unique
  * within a design. When such a tool is duplicated (content or row duplicate),
  * Unlayer copies the values as-is, so the host regenerates the id of the copy.
+ *
+ * `calculated_field` and `e-sign` use it as the field key DTE binds a business-day schedule
+ * to, so a copy starts unbound.
  */
-export const INSTANCE_ID_TOOL_SLUGS = ['embedded-image'];
+export const INSTANCE_ID_TOOL_SLUGS = ['embedded-image', 'calculated_field', E_SIGN_TOOL_SLUG];
 
 /**
  * Generates an RFC 4122 v4 GUID (`3fa85f64-5717-4562-b3fc-2c963f66afa6`) with the

package/src/store.ts

@@ -4,11 +4,15 @@ import { loadScript } from './loadScript';
 import { logUnlayerError } from './log';
 import { toUnlayerMergeTags, type UnlayerMergeTagsConfig } from './merge-tags';
 import { defaultImageValidation } from './shared/configs';
-import type {
-    UnlayerEditorTwin,
-    UnlayerEventConfig,
-    UnlayerEventESignOffset,
-    UnlayerEventRegister,
+import {
+    E_SIGN_FIELD_TYPE_LABELS,
+    type UnlayerEditorTwin,
+    type UnlayerEventBusinessCalendarRequest,
+    type UnlayerEventBusinessCalendarResult,
+    type UnlayerEventBusinessCalendarState,
+    type UnlayerEventConfig,
+    type UnlayerEventESignOffset,
+    type UnlayerEventRegister,
 } from './shared/const';
 import { normalizeESignOffsetSettings } from './shared/e-sign-offset';
 import { unlayerSupportedFonts } from './shared/fonts';
@@ -212,6 +216,9 @@ export class UnlayerStore {
     private isEditorReady = false;
     private isMergeTagsApplied = false;
     private mergeTagsConfig?: UnlayerMergeTagsConfig;
+    /** Latest `--business-calendar-state` payload, and the last one sent to the iframe. */
+    private businessCalendarStateJson?: string;
+    private sentBusinessCalendarStateJson?: string;
 
     private onMessageCB?: (type: string, data: any) => void;
     private onChangeCB?: (info: UnlayerDesignChangeInfo) => void;
@@ -222,6 +229,7 @@ export class UnlayerStore {
     private onFormSelectCB?: (formId: number) => void;
     private onCalcFieldOpenCB?: (usedFormIds: number[]) => void;
     private onCalcFieldSelectCB?: (fieldKeys: string[]) => void;
+    private onBusinessCalendarRequestCB?: (request: UnlayerEventBusinessCalendarRequest) => void;
 
     constructor(readonly props: CreateUnlayerEditorProps) {
         const schemaData = this.props.schema ? schemaBuildMap(this.props.schema) : undefined;
@@ -232,6 +240,7 @@ export class UnlayerStore {
                 .map(field => field.fullKey),
         );
 
+        // Each entry's type value is derived from it; the name shown can differ (E_SIGN_FIELD_TYPE_LABELS).
         this.props.eSignFieldTypes = [
             'Signature',
             'Initials',
@@ -379,6 +388,32 @@ export class UnlayerStore {
         this.onCalcFieldSelectCB = onCalcFieldSelect;
     };
 
+    setOnBusinessCalendarRequest = (
+        onBusinessCalendarRequest?: UnlayerStore['onBusinessCalendarRequestCB'],
+    ) => {
+        this.onBusinessCalendarRequestCB = onBusinessCalendarRequest;
+    };
+
+    /** Tells the iframe how a schedule `delete` request ended. */
+    sendBusinessCalendarResult = (result: UnlayerEventBusinessCalendarResult) => {
+        this.sendMessage('--business-calendar-result', JSON.parse(JSON.stringify(result)));
+    };
+
+    /**
+     * Keeps the schedule state for the iframe and sends it once the tools core has loaded (it
+     * goes out again right after `--config`). An unchanged state isn't sent again.
+     */
+    setBusinessCalendarState = (state: UnlayerEventBusinessCalendarState) => {
+        this.businessCalendarStateJson = JSON.stringify(state);
+
+        if (
+            this.hasCoreLoaded &&
+            this.businessCalendarStateJson !== this.sentBusinessCalendarStateJson
+        ) {
+            this.sendBusinessCalendarState();
+        }
+    };
+
     sendFormList = (forms: FormInfo[]) => {
         this.sendMessage('--form-list', { forms });
     };
@@ -509,17 +544,25 @@ export class UnlayerStore {
                 genericConfigMode: this.props.genericConfigMode,
                 isSnapshotMode: this.props.isSnapshotMode,
                 holidays: this.props.holidays,
+                fieldCalendars: this.props.fieldCalendars,
                 conditionalRulesEnabled:
                     !!this.props.displayConditions || !!this.props.onConditionalsOpen,
             };
 
             this.sendMessage('--config', JSON.parse(JSON.stringify(configData)));
+            // Always: a reloaded tools core starts without it.
+            this.sendBusinessCalendarState();
         } else if (type === '--form-select') {
             this.onFormSelectCB?.(data?.formId);
         } else if (type === '--calc-field-open') {
             this.onCalcFieldOpenCB?.(data?.usedFormIds ?? []);
         } else if (type === '--esign-offset-open') {
             this.openESignOffsetRules(data);
+        } else if (type === '--business-calendar-request') {
+            // It can delete a tenant schedule and replace bindings: only from this editor's iframe.
+            if (e.source === this.iframe?.contentWindow) {
+                this.routeBusinessCalendarRequest(data);
+            }
         } else if (type === '--calc-field-select') {
             if (this.onCalcFieldSelectCB) {
                 this.onCalcFieldSelectCB(data?.fieldKeys ?? []);
@@ -532,6 +575,7 @@ export class UnlayerStore {
                 toolTwins: this.props.toolTwins,
                 eSignRecipients: this.props.eSignRecipients,
                 eSignFieldTypes: this.props.eSignFieldTypes,
+                eSignFieldTypeLabels: E_SIGN_FIELD_TYPE_LABELS,
                 units: this.props.units?.map(unit => ({
                     ...unit,
                     values: {
@@ -580,6 +624,25 @@ export class UnlayerStore {
         });
     };
 
+    private routeBusinessCalendarRequest = (
+        data?: Partial<UnlayerEventBusinessCalendarRequest>,
+    ) => {
+        if (!data?.action || !data.fieldKey) {
+            return;
+        }
+
+        this.onBusinessCalendarRequestCB?.(data as UnlayerEventBusinessCalendarRequest);
+    };
+
+    private sendBusinessCalendarState = () => {
+        if (!this.businessCalendarStateJson) {
+            return;
+        }
+
+        this.sentBusinessCalendarStateJson = this.businessCalendarStateJson;
+        this.sendMessage('--business-calendar-state', JSON.parse(this.businessCalendarStateJson));
+    };
+
     private updateFormFieldSamples = (formId: number, fields: FormFieldInfo[]) => {
         fields.forEach((field, index) => {
             const normalizedFieldId = String(field.id ?? '').replaceAll('-', '');

package/src/unlayer-interface.tsx

@@ -1,8 +1,10 @@
+import type { BusinessCalendarHostProps } from '@servicetitan/dte-shared';
 import {
     UnlayerEditorESignRecipientInfo,
     UnlayerEditorTwin,
     UnlayerEditorUnit,
 } from './shared/const';
+import type { BusinessCalendar } from './shared/date-calc';
 import { FormFieldInfo, FormInfo } from './shared/forms';
 import { SchemaObject } from './shared/schema';
 
@@ -72,7 +74,16 @@ export interface UnlayerEditorCustomTool {
     groupUrl?: string;
 }
 
-export interface CreateUnlayerEditorProps {
+/**
+ * Editor options. The business-day schedule props (`BusinessCalendarHostProps`: `scheduleBindings`,
+ * `schedules`, `holidayCatalog`, `onScheduleBindingsChange`, ...) mean the same as `PdfEditor`'s;
+ * the field key of a binding is the tool's `values.id` (calculated field or e-sign "Date Signed
+ * Offset" field). The schedule UI shows only when `onScheduleBindingsChange` is passed. Changes
+ * to them (and to `holidays` / `fieldCalendars`) reach the editor when the host re-renders
+ * `UnlayerEditor` with new values: new arrays and objects, as for `PdfEditor`, since one changed
+ * in place isn't noticed.
+ */
+export interface CreateUnlayerEditorProps extends BusinessCalendarHostProps {
     tools: UnlayerEditorCustomTool[];
     newSnapshot?: UnlayerEditorTwin;
     toolTwins?: UnlayerEditorTwin[];
@@ -107,7 +118,20 @@ export interface CreateUnlayerEditorProps {
         maxHeight?: number;
         maxFileSize?: number;
     };
+    /**
+     * Holidays of the default business-day calendar (`YYYY-MM-DD`, observed days), skipped with
+     * Saturday and Sunday by date calculated fields whose toggle is off. Without it the previews
+     * skip weekends only. Sent to the editor again whenever it changes.
+     */
     holidays?: string[];
+    /**
+     * Calendars of the date calculated fields bound to a schedule, by field key (the tool's
+     * `values.id`), as `POST api/holidays/calendar` resolves them. Fields not listed use the
+     * default calendar (`holidays`); while `onScheduleBindingsChange` is passed, so does a field
+     * without a binding in `scheduleBindings`. Only the editor previews read it: rendered
+     * documents get their calendars from DTE. Sent to the editor again whenever it changes.
+     */
+    fieldCalendars?: Record<string, BusinessCalendar>;
     onFormSelect?: (formId: number) => void;
     onCalcFieldOpen?: (usedFormIds: number[]) => void;
     onCalcFieldSelect?: (fieldKeys: string[]) => void;

package/src/unlayer.tsx

@@ -2,7 +2,7 @@ import { emitDisplayCondition } from './display-conditions/displayConditionContr
 import { editorCoreScript, editorCoreStyles, editorCoreTools } from './editor-core';
 import { logUnlayerError } from './log';
 import { toUnlayerMergeTags } from './merge-tags';
-import { constGenericsEditor } from './shared/const';
+import { constGenericsEditor, E_SIGN_FIELD_TYPE_LABELS } from './shared/const';
 import { unlayerSupportedFonts } from './shared/fonts';
 import {
     unlayerCustomEmptyToolState,
@@ -226,10 +226,10 @@ export const createUnlayerEditor = (
 
     const acv = constGenericsEditor.adminConfigProperty;
 
-    const eSignTypeMapping = (eSignFieldTypes ?? []).map(key => ({
-        label: key,
-        value: key.charAt(0).toLowerCase() + key.replace(/ /g, '').slice(1),
-    }));
+    const eSignTypeMapping = (eSignFieldTypes ?? []).map(key => {
+        const value = key.charAt(0).toLowerCase() + key.replace(/ /g, '').slice(1);
+        return { label: E_SIGN_FIELD_TYPE_LABELS[value] ?? key, value };
+    });
 
     const unitsConfig = (units ?? []).reduce(
         (out, unit) => {