@servicetitan/dte-pdf-editor 1.44.0 → 1.46.0

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

@@ -1,6 +1,6 @@
 import { FC } from 'react';
 import { DataChangePayload, DataModelValues, PdfField, PreviewMode } from '../../interface/types';
-import { dateToUtcZero, getFieldPlaceholderText } from '../../utils';
+import { dateToUtcZero, getFieldPlaceholderText, toDateInputValue } from '../../utils';
 
 interface PdfViewFillableProps {
     field: PdfField;
@@ -10,6 +10,59 @@ interface PdfViewFillableProps {
     onDataChange?(changedData: DataChangePayload, field: PdfField): void;
 }
 
+interface FillableTextInputProps {
+    field: PdfField;
+    value: string;
+    disabled: boolean;
+    onChange(value: string): void;
+}
+
+const fillableTextStyles = {
+    background: 'inherit',
+    width: 'inherit',
+    height: 'inherit',
+    borderColor: 'inherit',
+} as const;
+
+export const FillableTextInput: FC<FillableTextInputProps> = ({
+    disabled,
+    field,
+    onChange,
+    value,
+}) => {
+    return (
+        <input
+            type="text"
+            style={fillableTextStyles}
+            disabled={disabled}
+            id={field.path}
+            name={field.path}
+            value={value}
+            onChange={e => onChange(e.target.value)}
+            placeholder={getFieldPlaceholderText(field)}
+        />
+    );
+};
+
+export const FillableTextareaInput: FC<FillableTextInputProps> = ({
+    disabled,
+    field,
+    onChange,
+    value,
+}) => {
+    return (
+        <textarea
+            style={{ ...fillableTextStyles, resize: 'none' }}
+            disabled={disabled}
+            id={field.path}
+            name={field.path}
+            value={value}
+            onChange={e => onChange(e.target.value)}
+            placeholder={getFieldPlaceholderText(field)}
+        />
+    );
+};
+
 export const PdfViewFillable: FC<PdfViewFillableProps> = ({
     data,
     field,
@@ -91,6 +144,7 @@ export const PdfViewFillable: FC<PdfViewFillableProps> = ({
     }
 
     if (field.subType === 'date') {
+        const dateInputValue = toDateInputValue(resolvedValue);
         return (
             <input
                 type="date"
@@ -103,7 +157,7 @@ export const PdfViewFillable: FC<PdfViewFillableProps> = ({
                 disabled={!isFillable}
                 id={field.path}
                 name={field.path}
-                value={resolvedValue ? resolvedValue.slice(0, 10) : ''}
+                value={dateInputValue}
                 onChange={e => {
                     const dateStr = e.target.value;
                     handleDataChange(dateStr ? dateToUtcZero(dateStr) : '');
@@ -133,21 +187,13 @@ export const PdfViewFillable: FC<PdfViewFillableProps> = ({
         );
     }
 
+    const TextComponent = field.multiline ? FillableTextareaInput : FillableTextInput;
     return (
-        <input
-            type="text"
-            style={{
-                background: 'inherit',
-                width: 'inherit',
-                height: 'inherit',
-                borderColor: 'inherit',
-            }}
-            disabled={!isFillable}
-            id={field.path}
-            name={field.path}
+        <TextComponent
+            field={field}
             value={resolvedValue ?? ''}
-            onChange={e => handleDataChange(e.target.value)}
-            placeholder={getFieldPlaceholderText(field)}
+            disabled={!isFillable}
+            onChange={handleDataChange}
         />
     );
 };

package/src/interface/types.ts

@@ -96,6 +96,7 @@ export interface PdfField {
     formula?: StructuredFormula;
     formulaFormat?: CalculatedFieldFormat;
     displayCondition?: DisplayConditionState | null;
+    multiline?: boolean;
 }
 
 export type SchemaFieldType = 'number' | 'date';

package/src/styles/inline-editable.css

@@ -17,4 +17,5 @@
 
 .inline-editable-html-text {
     margin: var(--spacing-0, 0);
+    white-space: pre-wrap;
 }

package/src/utils/conditions/__tests__/evaluate.utils.test.ts

@@ -0,0 +1,163 @@
+import {
+    DisplayConditionSingle,
+    DisplayConditionState,
+} from '../../../interface/types';
+import { evaluateDisplayCondition } from '../evaluate.utils';
+
+const buildCondition = (overrides: Partial<DisplayConditionSingle> = {}): DisplayConditionSingle => ({
+    id: 'c1',
+    dataPointKey: 'name',
+    operator: 'is_equal_to',
+    value: 'John',
+    ...overrides,
+});
+
+const buildState = (
+    conditions: DisplayConditionSingle[],
+    behavior: DisplayConditionState['behavior'] = 'show',
+): DisplayConditionState => ({
+    behavior,
+    groups: [{ id: 'g1', conditions }],
+});
+
+describe('evaluateDisplayCondition', () => {
+    const subject = (state: DisplayConditionState, data: Record<string, unknown> | undefined) =>
+        evaluateDisplayCondition(state, data);
+
+    describe('when no valid conditions exist', () => {
+        test('returns true when groups have no usable conditions', () => {
+            const state = buildState([buildCondition({ dataPointKey: '', value: '' })]);
+            expect(subject(state, { name: 'John' })).toBe(true);
+        });
+
+        test('returns true when state has no groups', () => {
+            expect(subject({ behavior: 'show', groups: [] }, {})).toBe(true);
+        });
+    });
+
+    describe('with string operators', () => {
+        test.each([
+            ['is_equal_to', 'John', 'John', true],
+            ['is_equal_to', 'John', 'Jane', false],
+            ['is_not_equal_to', 'John', 'Jane', true],
+            ['is_not_equal_to', 'John', 'John', false],
+            ['contains', 'John Doe', 'Doe', true],
+            ['contains', 'John', 'Doe', false],
+            ['does_not_contain', 'John', 'Doe', true],
+            ['does_not_contain', 'John Doe', 'Doe', false],
+            ['starts_with', 'John', 'Jo', true],
+            ['starts_with', 'John', 'Do', false],
+            ['ends_with', 'John', 'hn', true],
+            ['ends_with', 'John', 'Do', false],
+        ])('%s "%s" vs "%s" returns %s', (operator, actual, expected, result) => {
+            const state = buildState([
+                buildCondition({ operator, value: expected }),
+            ]);
+            expect(subject(state, { name: actual })).toBe(result);
+        });
+    });
+
+    describe('with valueless operators', () => {
+        test.each([
+            ['is_empty', '', '', true],
+            ['is_empty', 'John', '', false],
+            ['is_not_empty', 'John', '', true],
+            ['is_not_empty', '', '', false],
+        ])('%s with actual "%s" returns %s', (operator, actual, value, expected) => {
+            const state = buildState([buildCondition({ operator, value })]);
+            expect(subject(state, { name: actual })).toBe(expected);
+        });
+    });
+
+    describe('with numeric operators', () => {
+        test.each([
+            ['num_eq', 5, '5', true],
+            ['num_eq', 5, '6', false],
+            ['num_neq', 5, '6', true],
+            ['num_gt', 10, '5', true],
+            ['num_gt', 5, '10', false],
+            ['num_lt', 5, '10', true],
+            ['num_gte', 5, '5', true],
+            ['num_gte', 4, '5', false],
+            ['num_lte', 5, '5', true],
+            ['num_lte', 6, '5', false],
+        ])('%s with %p vs "%s" returns %s', (operator, actual, value, expected) => {
+            const state = buildState([
+                buildCondition({ dataPointKey: 'amount', operator, value }),
+            ]);
+            expect(subject(state, { amount: actual })).toBe(expected);
+        });
+    });
+
+    describe('with nested data', () => {
+        test('reads value at nested path', () => {
+            const state = buildState([
+                buildCondition({ dataPointKey: 'user.name', value: 'John' }),
+            ]);
+            expect(subject(state, { user: { name: 'John' } })).toBe(true);
+        });
+
+        test('treats missing value as empty string', () => {
+            const state = buildState([
+                buildCondition({ dataPointKey: 'user.name', operator: 'is_empty', value: '' }),
+            ]);
+            expect(subject(state, { user: {} })).toBe(true);
+        });
+    });
+
+    describe('with multiple conditions in a group', () => {
+        test('combines conditions with AND when next has logicalOperator and', () => {
+            const state = buildState([
+                buildCondition({ dataPointKey: 'a', value: '1' }),
+                buildCondition({ id: 'c2', dataPointKey: 'b', value: '2', logicalOperator: 'and' }),
+            ]);
+            expect(subject(state, { a: '1', b: '2' })).toBe(true);
+            expect(subject(state, { a: '1', b: '3' })).toBe(false);
+        });
+
+        test('combines conditions with OR when next has logicalOperator or', () => {
+            const state = buildState([
+                buildCondition({ dataPointKey: 'a', value: '1' }),
+                buildCondition({ id: 'c2', dataPointKey: 'b', value: '2', logicalOperator: 'or' }),
+            ]);
+            expect(subject(state, { a: '0', b: '2' })).toBe(true);
+            expect(subject(state, { a: '0', b: '0' })).toBe(false);
+        });
+    });
+
+    describe('with multiple groups', () => {
+        const state: DisplayConditionState = {
+            behavior: 'show',
+            groups: [
+                {
+                    id: 'g1',
+                    conditions: [buildCondition({ dataPointKey: 'a', value: '1' })],
+                },
+                {
+                    id: 'g2',
+                    logicalOperator: 'or',
+                    conditions: [buildCondition({ id: 'c2', dataPointKey: 'b', value: '2' })],
+                },
+            ],
+        };
+
+        test('returns true when either group matches with OR logic', () => {
+            expect(subject(state, { a: '0', b: '2' })).toBe(true);
+        });
+
+        test('returns false when neither group matches with OR logic', () => {
+            expect(subject(state, { a: '0', b: '0' })).toBe(false);
+        });
+    });
+
+    describe('with hide behavior', () => {
+        test('inverts result when behavior is hide', () => {
+            const state = buildState(
+                [buildCondition({ dataPointKey: 'name', value: 'John' })],
+                'hide',
+            );
+            expect(subject(state, { name: 'John' })).toBe(false);
+            expect(subject(state, { name: 'Jane' })).toBe(true);
+        });
+    });
+});

package/src/utils/conditions/__tests__/schema-data-points.utils.test.ts

@@ -0,0 +1,149 @@
+import { FieldTypeEnum, PdfField, SchemaObject } from '../../../interface/types';
+import {
+    getDataPointOptions,
+    getDocumentFieldsDataPointOptions,
+    getSchemaDataPointOptions,
+} from '../schema-data-points.utils';
+
+const buildField = (overrides: Partial<PdfField> = {}): PdfField => ({
+    id: 'f1',
+    type: FieldTypeEnum.fillable,
+    x: 0,
+    y: 0,
+    page: 1,
+    label: 'Label',
+    width: 100,
+    height: 25,
+    ...overrides,
+});
+
+describe('getSchemaDataPointOptions', () => {
+    const subject = (schema: SchemaObject | undefined) => getSchemaDataPointOptions(schema);
+
+    test('returns empty array when schema is undefined', () => {
+        expect(subject(undefined)).toEqual([]);
+    });
+
+    test('returns empty array when schema has no properties', () => {
+        expect(subject({ type: 'object', properties: {} })).toEqual([]);
+    });
+
+    test('returns only nodes flagged with useInConditionals or useInCalculatedFields', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    title: 'Name',
+                    options: { useInConditionals: true },
+                },
+                age: {
+                    type: 'number',
+                    title: 'Age',
+                    options: { useInCalculatedFields: true },
+                },
+                hiddenField: { type: 'string', title: 'Hidden' },
+            },
+        };
+        expect(subject(schema)).toEqual([
+            { fieldType: 'number', fullKey: 'age', title: 'Age' },
+            { fieldType: 'string', fullKey: 'name', title: 'Name' },
+        ]);
+    });
+
+    test('walks nested objects and joins titles with dash', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                user: {
+                    type: 'object',
+                    title: 'User',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            title: 'Name',
+                            options: { useInConditionals: true },
+                        },
+                    },
+                },
+            },
+        };
+        expect(subject(schema)).toEqual([
+            { fieldType: 'string', fullKey: 'user.name', title: 'User - Name' },
+        ]);
+    });
+
+    test('returns options sorted alphabetically by title', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                zebra: {
+                    type: 'string',
+                    title: 'Zebra',
+                    options: { useInConditionals: true },
+                },
+                alpha: {
+                    type: 'string',
+                    title: 'Alpha',
+                    options: { useInConditionals: true },
+                },
+            },
+        };
+        expect(subject(schema).map(o => o.title)).toEqual(['Alpha', 'Zebra']);
+    });
+});
+
+describe('getDocumentFieldsDataPointOptions', () => {
+    const subject = (fields: PdfField[] | undefined) => getDocumentFieldsDataPointOptions(fields);
+
+    test.each([
+        ['undefined', undefined],
+        ['empty array', []],
+    ])('returns empty array when fields is %s', (_, fields) => {
+        expect(subject(fields)).toEqual([]);
+    });
+
+    test('includes only fillable fields with a path', () => {
+        const fields = [
+            buildField({ id: '1', path: 'fillable_a_b', label: 'Alpha', subType: 'text' }),
+            buildField({ id: '2', path: 'fillable_c_d', label: 'Number', subType: 'number' }),
+            buildField({ id: '3', label: 'No Path' }),
+            buildField({ id: '4', path: 'esign_x_y', type: FieldTypeEnum.eSign, label: 'Sig' }),
+        ];
+        expect(subject(fields)).toEqual([
+            { fieldType: 'string', fullKey: 'fillable_a_b', title: 'Alpha' },
+            { fieldType: 'number', fullKey: 'fillable_c_d', title: 'Number' },
+        ]);
+    });
+
+    test('falls back to path when label is empty', () => {
+        const fields = [buildField({ path: 'fillable_a_b', label: '' })];
+        expect(subject(fields)).toEqual([
+            { fieldType: 'string', fullKey: 'fillable_a_b', title: 'fillable_a_b' },
+        ]);
+    });
+});
+
+describe('getDataPointOptions', () => {
+    const subject = (schema: SchemaObject | undefined, documentFields: PdfField[] | undefined) =>
+        getDataPointOptions(schema, documentFields);
+
+    test('merges schema and document field options sorted by title', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    title: 'Name',
+                    options: { useInConditionals: true },
+                },
+            },
+        };
+        const fields = [buildField({ path: 'fillable_a_b', label: 'Address' })];
+
+        expect(subject(schema, fields)).toEqual([
+            { fieldType: 'string', fullKey: 'fillable_a_b', title: 'Address' },
+            { fieldType: 'string', fullKey: 'name', title: 'Name' },
+        ]);
+    });
+});

package/src/utils/data-model/__tests__/extract-fields.utils.test.ts

@@ -0,0 +1,154 @@
+import { FieldTypeEnum, SchemaObject } from '../../../interface/types';
+import { extractGroupedFieldsFromDataModel } from '../extract-fields.utils';
+
+const emptySchema: SchemaObject = { type: 'object', properties: {} };
+
+describe('extractGroupedFieldsFromDataModel', () => {
+    const subject = (
+        schema: SchemaObject,
+        options?: Parameters<typeof extractGroupedFieldsFromDataModel>[1],
+    ) => extractGroupedFieldsFromDataModel(schema, options);
+
+    describe('when schema has no properties', () => {
+        test('returns empty array', () => {
+            expect(subject(emptySchema)).toEqual([]);
+        });
+    });
+
+    describe('with top-level simple fields', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                firstName: { type: 'string', title: 'First Name' },
+                age: { type: 'number' },
+            },
+        };
+
+        test('groups simple fields under the default "Fields" group', () => {
+            const result = subject(schema);
+            expect(result).toHaveLength(1);
+            expect(result[0].groupName).toBe('Fields');
+            expect(result[0].fields).toEqual([
+                {
+                    label: 'First Name',
+                    type: FieldTypeEnum.dataModel,
+                    path: 'firstName',
+                    fieldType: undefined,
+                },
+                {
+                    label: 'age',
+                    type: FieldTypeEnum.dataModel,
+                    path: 'age',
+                    fieldType: 'number',
+                },
+            ]);
+        });
+    });
+
+    describe('with object properties', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                user: {
+                    type: 'object',
+                    title: 'User Info',
+                    properties: {
+                        name: { type: 'string', title: 'Name' },
+                        address: {
+                            type: 'object',
+                            properties: {
+                                city: { type: 'string', title: 'City' },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+
+        test('flattens nested object properties into one group per top-level object', () => {
+            const result = subject(schema);
+            expect(result).toHaveLength(1);
+            expect(result[0].groupName).toBe('User Info');
+            expect(result[0].fields).toEqual([
+                {
+                    label: 'Name',
+                    type: FieldTypeEnum.dataModel,
+                    path: 'user.name',
+                    fieldType: undefined,
+                },
+                {
+                    label: 'City',
+                    type: FieldTypeEnum.dataModel,
+                    path: 'user.address.city',
+                    fieldType: undefined,
+                },
+            ]);
+        });
+    });
+
+    test('places default-group fields before object groups', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                top: { type: 'string' },
+                user: {
+                    type: 'object',
+                    title: 'User',
+                    properties: { name: { type: 'string' } },
+                },
+            },
+        };
+        const result = subject(schema);
+        expect(result.map(g => g.groupName)).toEqual(['Fields', 'User']);
+    });
+
+    test('skips array properties', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                items: { type: 'array', items: { type: 'string' } },
+            },
+        };
+        expect(subject(schema)).toEqual([]);
+    });
+
+    test('skips empty object groups', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                empty: { type: 'object', properties: {} },
+            },
+        };
+        expect(subject(schema)).toEqual([]);
+    });
+
+    describe('with onlyUseInCalculatedFields option', () => {
+        const schema: SchemaObject = {
+            type: 'object',
+            properties: {
+                included: {
+                    type: 'number',
+                    options: { useInCalculatedFields: true },
+                },
+                excluded: { type: 'number' },
+                user: {
+                    type: 'object',
+                    title: 'User',
+                    properties: {
+                        salary: {
+                            type: 'number',
+                            options: { useInCalculatedFields: true },
+                        },
+                        notes: { type: 'string' },
+                    },
+                },
+            },
+        };
+
+        test('keeps only fields flagged with useInCalculatedFields', () => {
+            const result = subject(schema, { onlyUseInCalculatedFields: true });
+            const allPaths = result.flatMap(g => g.fields.map(f => f.path));
+            expect(allPaths.sort()).toEqual(['included', 'user.salary']);
+        });
+    });
+});

package/src/utils/data-model/__tests__/resolve-values.utils.test.ts

@@ -0,0 +1,60 @@
+import { DataModelValues } from '../../../interface/types';
+import { resolvePdfDataValues } from '../resolve-values.utils';
+
+describe('resolvePdfDataValues', () => {
+    const subject = (data: DataModelValues | undefined, path: string | undefined) =>
+        resolvePdfDataValues(data, path);
+
+    describe('when data or path are missing', () => {
+        test.each([
+            ['data is undefined', undefined, 'some.path'],
+            ['path is undefined', { foo: 'bar' }, undefined],
+            ['path is empty', { foo: 'bar' }, ''],
+        ])('returns empty string when %s', (_, data, path) => {
+            expect(subject(data as DataModelValues | undefined, path)).toBe('');
+        });
+    });
+
+    describe('with primitive resolution', () => {
+        test('resolves a top-level string property', () => {
+            expect(subject({ name: 'John' }, 'name')).toBe('John');
+        });
+
+        test('resolves a nested string property', () => {
+            expect(subject({ user: { name: 'John' } }, 'user.name')).toBe('John');
+        });
+
+        test('resolves a numeric property as string', () => {
+            expect(subject({ count: 42 }, 'count')).toBe('42');
+        });
+
+        test('resolves a boolean property as string', () => {
+            expect(subject({ active: true }, 'active')).toBe('true');
+        });
+    });
+
+    describe('when value is missing', () => {
+        test.each([
+            ['null value', { user: null }, 'user.name'],
+            ['undefined value', { user: undefined }, 'user.name'],
+            ['unknown key', { user: { name: 'John' } }, 'user.email'],
+            ['intermediate value is not object', { user: 'string' }, 'user.name'],
+        ])('returns empty string for %s', (_, data, path) => {
+            expect(subject(data as DataModelValues, path)).toBe('');
+        });
+    });
+
+    describe('with object value resolution', () => {
+        test('formats amount/currency objects', () => {
+            expect(subject({ price: { Amount: 100, Currency: 'USD' } }, 'price')).toBe('USD 100');
+        });
+
+        test('returns Value property when present', () => {
+            expect(subject({ field: { Value: 'inner' } }, 'field')).toBe('inner');
+        });
+
+        test('stringifies generic objects via JSON', () => {
+            expect(subject({ obj: { foo: 'bar' } }, 'obj')).toBe('{"foo":"bar"}');
+        });
+    });
+});

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

@@ -0,0 +1,26 @@
+import { getFieldBackgroundColor } from '../field-background-color.utils';
+
+describe('getFieldBackgroundColor', () => {
+    const subject = (recipient: string | undefined, recipientsColors: Record<string, string>) =>
+        getFieldBackgroundColor(recipient, recipientsColors);
+
+    test('returns color for recipient when present in map', () => {
+        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 "none" when recipient is empty string', () => {
+        expect(subject('', { signer1: '#ff0000' })).toBe('none');
+    });
+
+    test('returns "none" when recipient is not in the color map', () => {
+        expect(subject('unknown', { signer1: '#ff0000' })).toBe('none');
+    });
+
+    test('returns "none" when color map is empty', () => {
+        expect(subject('signer1', {})).toBe('none');
+    });
+});