@servicetitan/dte-unlayer 0.157.0 → 0.159.0

package/src/__tests__/condition-row.test.tsx

@@ -0,0 +1,131 @@
+import { act, useState } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { TextDecoder, TextEncoder } from 'util';
+import type { FormFieldOption, SingleCondition } from '../display-conditions/types';
+import { buildFormFieldKey } from '../shared/forms';
+
+// Anvil2 needs these in jsdom: text encoding at import time, the rest when it renders.
+Object.assign(globalThis, { TextDecoder, TextEncoder });
+(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+const NoopObserver = class {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+    takeRecords() {
+        return [];
+    }
+};
+globalThis.ResizeObserver ??= NoopObserver as unknown as typeof ResizeObserver;
+globalThis.IntersectionObserver ??= NoopObserver as unknown as typeof IntersectionObserver;
+window.matchMedia ??= ((query: string) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: () => undefined,
+    removeListener: () => undefined,
+    addEventListener: () => undefined,
+    removeEventListener: () => undefined,
+    dispatchEvent: () => false,
+})) as typeof window.matchMedia;
+Object.assign(HTMLElement.prototype, {
+    showPopover() {},
+    hidePopover() {},
+    togglePopover() {},
+});
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { ConditionRow } =
+    require('../display-conditions/ConditionRow') as typeof import('../display-conditions/ConditionRow');
+
+const FORM_ID = 5;
+const ADDRESS_KEY = buildFormFieldKey(FORM_ID, 'address');
+const formFieldOptions: FormFieldOption[] = [
+    { formId: FORM_ID, fullKey: ADDRESS_KEY, title: 'Address', fieldType: 'string' },
+    {
+        formId: FORM_ID,
+        fullKey: buildFormFieldKey(FORM_ID, 'city'),
+        title: 'City',
+        fieldType: 'string',
+    },
+];
+
+describe('ConditionRow (Unlayer) source changes', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+    let latest: SingleCondition;
+    const onFormSelect = jest.fn();
+
+    /** A host that keeps the condition the row reports, as `ConditionGroup` does. */
+    const Host = ({ initial }: { initial: SingleCondition }) => {
+        const [condition, setCondition] = useState(initial);
+        latest = condition;
+        return (
+            <ConditionRow
+                canRemove={false}
+                condition={condition}
+                dataPointOptions={[{ fullKey: 'Job.Name', title: 'Job Name', fieldType: 'string' }]}
+                formFieldOptions={formFieldOptions}
+                forms={[{ id: FORM_ID, name: 'Job Completion Checklist' }]}
+                onChange={setCondition}
+                onFormSelect={onFormSelect}
+                onRemove={() => undefined}
+            />
+        );
+    };
+
+    const comboboxes = () =>
+        Array.from(container.querySelectorAll<HTMLElement>('[role="combobox"]'));
+    /** Opens a select and picks the option labelled `label` (else the first), once loaded. */
+    const choose = async (combobox: HTMLElement, label?: string) => {
+        act(() => combobox.click());
+        await act(() => new Promise(resolve => setTimeout(resolve, 50)));
+        const options = Array.from(document.body.querySelectorAll<HTMLElement>('[role="option"]'));
+        const option =
+            label === undefined ? options[0] : options.find(o => o.textContent?.trim() === label);
+        expect(option).toBeDefined();
+        act(() => option!.click());
+        await act(() => new Promise(resolve => setTimeout(resolve, 0)));
+    };
+
+    beforeEach(() => {
+        onFormSelect.mockClear();
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+    });
+
+    afterEach(() => {
+        act(() => root.unmount());
+        document.body.innerHTML = '';
+    });
+
+    test("resets the data point both ways, as BYOD does, without picking the form's first field", async () => {
+        act(() =>
+            root.render(
+                <Host
+                    initial={{
+                        id: 'c1',
+                        dataPointKey: ADDRESS_KEY,
+                        operator: 'contains',
+                        value: 'Main St',
+                    }}
+                />,
+            ),
+        );
+        expect(comboboxes()[0].textContent).toContain('Job Completion Checklist');
+        expect(comboboxes()[1].textContent).toContain('Address');
+
+        // The merge-tag source, listed first.
+        await choose(comboboxes()[0]);
+
+        expect(latest).toEqual({ id: 'c1', dataPointKey: '', operator: 'is_equal_to', value: '' });
+        expect(comboboxes()[1].textContent).toContain('Select data point...');
+
+        await choose(comboboxes()[0], 'Job Completion Checklist');
+
+        expect(latest).toEqual({ id: 'c1', dataPointKey: '', operator: 'is_equal_to', value: '' });
+        expect(comboboxes()[0].textContent).toContain('Job Completion Checklist');
+        expect(comboboxes()[1].textContent).toContain('Select form field...');
+        expect(onFormSelect).toHaveBeenCalledWith(FORM_ID);
+    });
+});

package/src/__tests__/date-calc.test.ts

@@ -0,0 +1,145 @@
+import { createHash } from 'crypto';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import {
+    addDays,
+    type BusinessCalendar,
+    dateDiffDays,
+    isDateWithinRange,
+} from '../shared/date-calc';
+
+/*
+ * The business-day cases DTE runs through BusinessDayCalculator (.NET) and noderenderer, copied from
+ * DTE's `tests/fixtures/business-day-cases.json`. The hash is the DTE file's: update the copy and the
+ * hash together, never the copy alone.
+ */
+const FIXTURE_PATH = resolve(__dirname, '../../../../tests/fixtures/business-day-cases.json');
+const FIXTURE_SHA256 = 'da105547c63cdec48e79962b57794f709cbe1867a05b8cfe79d40f99671a0370';
+
+interface FixtureCase {
+    name: string;
+    calendar: string;
+    start: string;
+    steps?: number[];
+    end?: string | null;
+    expected: string | number | null;
+}
+
+interface Fixture {
+    calendars: Record<string, BusinessCalendar>;
+    cases: FixtureCase[];
+}
+
+// Git may check the file out with CRLF line endings on Windows; DTE hashes it with LF.
+const fixtureText = readFileSync(FIXTURE_PATH, 'utf-8').replace(/\r\n/g, '\n');
+const fixture: Fixture = JSON.parse(fixtureText);
+
+describe('business-day parity fixture', () => {
+    test('matches the DTE copy', () => {
+        expect(createHash('sha256').update(fixtureText).digest('hex')).toBe(FIXTURE_SHA256);
+    });
+
+    describe('runs through the date helpers as a bound field', () => {
+        test.each(fixture.cases.map(c => [c.name, c] as const))('%s', (_, testCase) => {
+            const options = { calendar: fixture.calendars[testCase.calendar] };
+
+            const result =
+                'end' in testCase
+                    ? dateDiffDays(testCase.start, testCase.end, options)
+                    : (testCase.steps ?? []).reduce<string | null>(
+                          (date, step) => addDays(date, step, options),
+                          testCase.start,
+                      );
+
+            expect(result).toBe(testCase.expected);
+        });
+    });
+});
+
+describe('date helpers with the default calendar', () => {
+    beforeAll(() => {
+        jest.useFakeTimers({ now: new Date('2026-06-01T00:00:00Z') });
+    });
+
+    afterAll(() => {
+        jest.useRealTimers();
+    });
+
+    describe('addDays', () => {
+        test('skips Saturday and Sunday when no holidays are passed', () => {
+            // Fri 2026-07-03 + 1 = Mon 2026-07-06
+            expect(addDays('2026-07-03', 1)).toBe('2026-07-06');
+        });
+
+        test('skips the holidays passed', () => {
+            expect(addDays('2026-07-02', 1, { holidays: ['2026-07-03'] })).toBe('2026-07-06');
+        });
+
+        test('accepts timestamp holidays', () => {
+            expect(addDays('2026-07-02', 1, { holidays: ['2026-07-03T00:00:00.000Z'] })).toBe(
+                '2026-07-06',
+            );
+        });
+
+        test.each([
+            ['a fractional offset', '2026-09-30', 2.5],
+            ['an invalid date', 'not-a-date', 1],
+            ['a missing date', undefined, 1],
+            ['an offset over 365', '2026-01-02', 366],
+            ['a start outside the current year ± 1', '2024-12-31', 1],
+            ['a result outside the current year ± 1', '2027-12-31', 1],
+        ])('is blank for %s', (_, date, days) => {
+            expect(addDays(date, days)).toBeNull();
+        });
+
+        test('accepts a numeric string offset', () => {
+            expect(addDays('2026-07-06', '2')).toBe('2026-07-08');
+        });
+    });
+
+    describe('dateDiffDays', () => {
+        test('counts from the first date to the second', () => {
+            // Mon 2026-07-06 → Fri 2026-07-10
+            expect(dateDiffDays('2026-07-06', '2026-07-10')).toBe(4);
+            expect(dateDiffDays('2026-07-10', '2026-07-06')).toBe(-4);
+        });
+
+        test.each([
+            ['an invalid date', 'not-a-date'],
+            ['a missing date', undefined],
+        ])('is blank for %s', (_, to) => {
+            expect(dateDiffDays('2026-07-06', to)).toBeNull();
+        });
+    });
+
+    describe('isDateWithinRange', () => {
+        test.each([
+            ['2025-01-01', true],
+            ['2027-12-31', true],
+            ['2024-12-31', false],
+            ['2028-01-01', false],
+        ])('%s is %s for the current year ± 1', (date, expected) => {
+            expect(isDateWithinRange(date)).toBe(expected);
+        });
+    });
+});
+
+describe('date helpers with a field calendar', () => {
+    const sundayOnly: BusinessCalendar = {
+        weekendDays: [0],
+        holidays: [],
+        firstYear: 2026,
+        lastYear: 2026,
+    };
+
+    test('uses only the field calendar, not the default holidays', () => {
+        // Fri 2026-07-10 + 1 = Sat 2026-07-11, a business day of a Sunday-only calendar.
+        expect(addDays('2026-07-10', 1, { calendar: sundayOnly, holidays: ['2026-07-11'] })).toBe(
+            '2026-07-11',
+        );
+    });
+
+    test('is blank outside the calendar years, whatever the current year', () => {
+        expect(addDays('2026-12-31', 1, { calendar: sundayOnly })).toBeNull();
+    });
+});

package/src/__tests__/e-sign-offset-modal.test.tsx

@@ -0,0 +1,124 @@
+import { act } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { TextDecoder, TextEncoder } from 'util';
+import type { ESignDateSignedOffsetSettings } from '../shared/const';
+
+// Anvil2 needs these in jsdom: text encoding at import time, the rest when it renders.
+Object.assign(globalThis, { TextDecoder, TextEncoder });
+(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+globalThis.ResizeObserver ??= class {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+} as unknown as typeof ResizeObserver;
+window.matchMedia ??= ((query: string) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: () => undefined,
+    removeListener: () => undefined,
+    addEventListener: () => undefined,
+    removeEventListener: () => undefined,
+    dispatchEvent: () => false,
+})) as typeof window.matchMedia;
+Object.assign(HTMLElement.prototype, {
+    showPopover() {},
+    hidePopover() {},
+    togglePopover() {},
+});
+Object.assign(HTMLDialogElement.prototype, {
+    showModal(this: HTMLDialogElement) {
+        this.setAttribute('open', '');
+    },
+    close(this: HTMLDialogElement) {
+        this.removeAttribute('open');
+    },
+});
+
+/* eslint-disable @typescript-eslint/no-require-imports -- loaded after the stubs Anvil2 needs */
+const { ESignDateSignedOffsetModal } =
+    require('../e-sign-offset/ESignDateSignedOffsetModal') as typeof import('../e-sign-offset/ESignDateSignedOffsetModal');
+const { emitESignOffsetRequest } =
+    require('../e-sign-offset/eSignOffsetController') as typeof import('../e-sign-offset/eSignOffsetController');
+/* eslint-enable @typescript-eslint/no-require-imports */
+
+const configuredRule = {
+    days: 2,
+    condition: {
+        behavior: 'show' as const,
+        groups: [
+            {
+                id: 'g1',
+                conditions: [
+                    {
+                        id: 'c1',
+                        dataPointKey: 'Job.Name',
+                        operator: 'is_equal_to' as const,
+                        value: 'Repair',
+                    },
+                ],
+            },
+        ],
+    },
+};
+
+describe('ESignDateSignedOffsetModal (the Date Signed Offset Rules modal, as in BYOD)', () => {
+    let container: HTMLDivElement;
+    let root: Root;
+
+    const open = (value: ESignDateSignedOffsetSettings) => {
+        const done = jest.fn();
+        act(() => emitESignOffsetRequest({ value, done }));
+        return done;
+    };
+    const button = (text: string) =>
+        Array.from(document.body.querySelectorAll('button')).find(
+            b => b.textContent?.trim() === text,
+        );
+    const click = (text: string) => {
+        const target = button(text);
+        if (!target) {
+            throw new Error(`No "${text}" button`);
+        }
+        act(() => target.click());
+    };
+
+    beforeEach(() => {
+        container = document.createElement('div');
+        document.body.appendChild(container);
+        root = createRoot(container);
+        act(() => root.render(<ESignDateSignedOffsetModal />));
+    });
+
+    afterEach(() => {
+        act(() => root.unmount());
+        document.body.innerHTML = '';
+    });
+
+    test("labels the condition's source as BYOD does", () => {
+        open({ rules: [{ days: 0 }] });
+
+        expect(document.body.textContent).toContain('Source');
+        expect(document.body.textContent).toContain('Merge tags');
+        expect(document.body.textContent).not.toContain('Data Type');
+    });
+
+    test('offers Clear Rules only once a rule is configured', () => {
+        open({ rules: [{ days: 0 }] });
+        expect(button('Clear Rules')).toBeUndefined();
+
+        click('Cancel');
+        open({ rules: [configuredRule, { days: 5 }] });
+        expect(button('Clear Rules')).toBeDefined();
+    });
+
+    test('clearing leaves one empty rule that saves as no rules', () => {
+        const done = open({ rules: [configuredRule, { days: 5 }] });
+
+        click('Clear Rules');
+        expect(button('Clear Rules')).toBeUndefined();
+        click('Save Changes');
+
+        expect(done).toHaveBeenCalledWith({ rules: [{ days: 0 }] });
+    });
+});

package/src/__tests__/instance-id.test.ts

@@ -0,0 +1,49 @@
+import { unlayerToolsDedupeInstanceIds } from '../tools';
+
+import type { UnlayerDesignFormat, UnlayerDesignTool } from '../unlayer-interface';
+
+const ORIGINAL_ID = '3fa85f64-5717-4562-b3fc-2c963f66afa6';
+
+const content = (slug: string, htmlID: string, id?: string): UnlayerDesignTool => ({
+    type: 'custom',
+    slug,
+    values: { id, _meta: { htmlID } },
+});
+
+const design = (contents: UnlayerDesignTool[]): UnlayerDesignFormat => ({
+    body: { rows: [{ cells: [1], columns: [{ contents }] }] },
+    counters: {},
+    schemaVersion: 1,
+});
+
+describe('unlayerToolsDedupeInstanceIds', () => {
+    test.each(['calculated_field', 'e-sign', 'embedded-image'])(
+        'gives a duplicated %s a new id and keeps the original',
+        slug => {
+            const original = content(slug, 'u_content_1', ORIGINAL_ID);
+            const copy = content(slug, 'u_content_2', ORIGINAL_ID);
+
+            expect(unlayerToolsDedupeInstanceIds(design([original, copy]), 'u_content_2')).toBe(
+                true,
+            );
+            expect(original.values.id).toBe(ORIGINAL_ID);
+            expect(copy.values.id).toEqual(expect.any(String));
+            expect(copy.values.id).not.toBe(ORIGINAL_ID);
+        },
+    );
+
+    test('keeps the ids of different tools that happen to be equal', () => {
+        const field = content('calculated_field', 'u_content_1', ORIGINAL_ID);
+        const signature = content('e-sign', 'u_content_2', ORIGINAL_ID);
+
+        expect(unlayerToolsDedupeInstanceIds(design([field, signature]))).toBe(false);
+        expect(signature.values.id).toBe(ORIGINAL_ID);
+    });
+
+    test('leaves tools without an instance id alone', () => {
+        const first = content('page-break', 'u_content_1', ORIGINAL_ID);
+        const second = content('page-break', 'u_content_2', ORIGINAL_ID);
+
+        expect(unlayerToolsDedupeInstanceIds(design([first, second]))).toBe(false);
+    });
+});

package/src/__tests__/store.business-calendar.test.ts

@@ -0,0 +1,185 @@
+import type { UnlayerEventBusinessCalendarState } from '../shared/const';
+import { UnlayerStore } from '../store';
+
+const editorMock = {
+    addEventListener: jest.fn(),
+    removeEventListener: jest.fn(),
+    registerCallback: jest.fn(),
+    unregisterCallback: jest.fn(),
+    setMergeTags: jest.fn(),
+    loadDesign: jest.fn(),
+    setBodyValues: jest.fn(),
+};
+
+jest.mock('../loadScript', () => ({ loadScript: jest.fn().mockResolvedValue(undefined) }));
+jest.mock('../unlayer', () => ({
+    ...jest.requireActual('../unlayer'),
+    createUnlayerEditor: jest.fn(() => editorMock),
+}));
+
+const offState: UnlayerEventBusinessCalendarState = {
+    enabled: true,
+    bindings: {},
+    schedules: [],
+    canDeleteSchedule: true,
+    fieldCalendars: {},
+};
+
+const onState: UnlayerEventBusinessCalendarState = {
+    enabled: true,
+    bindings: { 'field-a': { scheduleId: 7 } },
+    schedules: [
+        {
+            id: 7,
+            name: 'Sundays only',
+            isDefault: false,
+            calendar: { weekendDays: [0], knownHolidays: [], customDates: [] },
+        },
+    ],
+    canDeleteSchedule: true,
+    fieldCalendars: {
+        'field-a': { weekendDays: [0], holidays: [], firstYear: 2025, lastYear: 2027 },
+    },
+    holidays: ['2026-07-03'],
+};
+
+/** A message posted to the parent window: by the tools core in Unlayer's iframe, by default. */
+const postFromIframe = (
+    type: string,
+    data?: unknown,
+    source: Window | null = document.querySelector('iframe')?.contentWindow ?? null,
+) =>
+    window.dispatchEvent(
+        new MessageEvent('message', { data: { '-dte-message-from': { type, data } }, source }),
+    );
+
+describe('UnlayerStore business-day schedules', () => {
+    let store: UnlayerStore;
+    let container: HTMLDivElement;
+    let postMessage: jest.SpyInstance;
+
+    /** Types of the messages sent to the iframe, in order. */
+    const sentTypes = () =>
+        postMessage.mock.calls.map(([message]) => message['-dte-message-to'].type);
+    const sentData = (type: string) =>
+        postMessage.mock.calls
+            .map(([message]) => message['-dte-message-to'])
+            .filter(message => message.type === type)
+            .map(message => message.data);
+
+    beforeEach(async () => {
+        jest.useFakeTimers();
+        jest.clearAllMocks();
+        (window as any).unlayer = {};
+        container = document.createElement('div');
+        container.appendChild(document.createElement('iframe'));
+        document.body.appendChild(container);
+
+        store = new UnlayerStore({ tools: [] });
+        await store.init(container);
+        // The window message listener is added on the next tick (not the tools-ready watchdog).
+        jest.advanceTimersByTime(0);
+        postMessage = jest.spyOn(container.querySelector('iframe')!.contentWindow!, 'postMessage');
+    });
+
+    afterEach(() => {
+        store.destroy();
+        container.remove();
+        jest.useRealTimers();
+    });
+
+    test('keeps the state until the tools core has loaded, then sends it right after --config', () => {
+        store.setBusinessCalendarState(onState);
+        expect(sentTypes()).toEqual([]);
+
+        postFromIframe('--core-loaded');
+
+        expect(sentTypes()).toEqual(['--config', '--business-calendar-state']);
+        expect(sentData('--business-calendar-state')).toEqual([onState]);
+    });
+
+    test('sends a changed state at once, and skips an unchanged one', () => {
+        postFromIframe('--core-loaded');
+        postMessage.mockClear();
+
+        store.setBusinessCalendarState(offState);
+        store.setBusinessCalendarState({ ...offState });
+        store.setBusinessCalendarState(onState);
+
+        expect(sentData('--business-calendar-state')).toEqual([offState, onState]);
+    });
+
+    test('sends the state again when the tools core loads again', () => {
+        store.setBusinessCalendarState(onState);
+        postFromIframe('--core-loaded');
+        postMessage.mockClear();
+
+        postFromIframe('--core-loaded');
+
+        expect(sentData('--business-calendar-state')).toEqual([onState]);
+    });
+
+    test('sends a plain copy, not the object it was given', () => {
+        postFromIframe('--core-loaded');
+        store.setBusinessCalendarState(onState);
+
+        const [sent] = sentData('--business-calendar-state');
+        expect(sent).toEqual(onState);
+        expect(sent).not.toBe(onState);
+    });
+
+    test('passes schedule requests to the host only when they name an action and a field', () => {
+        const onRequest = jest.fn();
+        store.setOnBusinessCalendarRequest(onRequest);
+
+        postFromIframe('--business-calendar-request', { action: 'toggle', enabled: true });
+        postFromIframe('--business-calendar-request', { fieldKey: 'field-a' });
+        postFromIframe('--business-calendar-request', {
+            action: 'toggle',
+            fieldKey: 'field-a',
+            enabled: true,
+        });
+        postFromIframe('--business-calendar-request', {
+            action: 'select',
+            fieldKey: 'esign-a',
+            scheduleId: 7,
+        });
+
+        expect(onRequest.mock.calls).toEqual([
+            [{ action: 'toggle', fieldKey: 'field-a', enabled: true }],
+            [{ action: 'select', fieldKey: 'esign-a', scheduleId: 7 }],
+        ]);
+    });
+
+    test("ignores schedule requests that don't come from the editor's iframe", () => {
+        const onRequest = jest.fn();
+        store.setOnBusinessCalendarRequest(onRequest);
+        const otherFrame = document.createElement('iframe');
+        document.body.appendChild(otherFrame);
+
+        const request = { action: 'delete', fieldKey: 'field-a', scheduleId: 7, requestId: 'r1' };
+        postFromIframe('--business-calendar-request', request, otherFrame.contentWindow);
+        postFromIframe('--business-calendar-request', request, window);
+        postFromIframe('--business-calendar-request', request, null);
+
+        expect(onRequest).not.toHaveBeenCalled();
+    });
+
+    test('sends the outcome of a delete request to the iframe', () => {
+        store.sendBusinessCalendarResult({ requestId: 'r1', error: 'in use' });
+
+        expect(sentData('--business-calendar-result')).toEqual([
+            { requestId: 'r1', error: 'in use' },
+        ]);
+    });
+
+    test('registers the e-sign type labels with the tools', () => {
+        postFromIframe('--data-loaded');
+
+        const [register] = sentData('--register');
+        expect(register.eSignFieldTypes).toContain('Date Signed Offset');
+        expect(register.eSignFieldTypeLabels).toEqual({
+            dateSignedOffset: 'Calculated Signing Date',
+        });
+    });
+});

package/src/__tests__/unlayer.e-sign-types.test.ts

@@ -0,0 +1,30 @@
+import { E_SIGN_DATE_SIGNED_OFFSET_TYPE } from '../shared/const';
+import { createUnlayerEditor } from '../unlayer';
+
+describe('createUnlayerEditor e-sign field types', () => {
+    const createEditor = jest.fn(() => ({ registerCallback: jest.fn() }));
+
+    beforeEach(() => {
+        createEditor.mockClear();
+        (window as any).unlayer = { createEditor };
+    });
+
+    const eSignTypeOptions = (): { label: string; value: string }[] => {
+        const container = document.createElement('div');
+        container.id = 'editor';
+        createUnlayerEditor(container, {
+            tools: [],
+            eSignFieldTypes: ['Signature', 'Date Signed', 'Date Signed Offset'],
+        });
+        const [[config]] = createEditor.mock.calls as unknown as [[any]];
+        return config.tools['custom#e-sign'].properties.eSignFieldType.editor.data.options;
+    };
+
+    test('shows "Calculated Signing Date" for the date signed offset type, keeping its value', () => {
+        expect(eSignTypeOptions()).toEqual([
+            { label: 'Signature', value: 'signature' },
+            { label: 'Date Signed', value: 'dateSigned' },
+            { label: 'Calculated Signing Date', value: E_SIGN_DATE_SIGNED_OFFSET_TYPE },
+        ]);
+    });
+});