@servicetitan/dte-pdf-editor 1.35.0 → 1.37.0

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

@@ -17,6 +17,7 @@ import { ResultTypeSelector } from './result-type-selector';
 interface FormulaWorkspaceProps {
     actions: ReactNode;
     advancedOpen: boolean;
+    disabledOperators?: Set<string>;
     editorRef: RefObject<HTMLDivElement | null>;
     format: CalculatedFieldFormat;
     isInvalid: boolean;
@@ -36,6 +37,7 @@ interface FormulaWorkspaceProps {
 export const FormulaWorkspace: FC<FormulaWorkspaceProps> = ({
     actions,
     advancedOpen,
+    disabledOperators,
     editorRef,
     format,
     isInvalid,
@@ -73,8 +75,11 @@ export const FormulaWorkspace: FC<FormulaWorkspaceProps> = ({
     return (
         <Flex direction="column" flex={1} gap={2} style={{ padding: '12px' }}>
             <Text variant="body" size="small">
-                Click a field on the left to add it. Use +, -, *, /, and parentheses to build
-                formulas.
+                Click a field on the left to add it. Use +, -,{' '}
+                {disabledOperators?.has('*') ? '' : '*, /, and '}parentheses to build formulas.
+                {disabledOperators?.has('*')
+                    ? ' Multiply and divide are not available with date fields.'
+                    : ''}
             </Text>
             <Flex alignItems="center" justifyContent="space-between">
                 <Text variant="body" size="small">
@@ -101,11 +106,20 @@ export const FormulaWorkspace: FC<FormulaWorkspaceProps> = ({
             />
             {isInvalid && validationError && <Alert status="danger" title={validationError} />}
             <Flex gap={1}>
-                {CALCULATED_OPERATIONS.map(op => (
-                    <Button key={op} onClick={() => onOperatorSelect(op)} size="small">
-                        {op}
-                    </Button>
-                ))}
+                {CALCULATED_OPERATIONS.map(op => {
+                    const isDisabled = disabledOperators?.has(op) ?? false;
+                    return (
+                        <Button
+                            key={op}
+                            onClick={() => onOperatorSelect(op)}
+                            size="small"
+                            disabled={isDisabled}
+                            title={isDisabled ? 'Not available with date fields' : undefined}
+                        >
+                            {op}
+                        </Button>
+                    );
+                })}
             </Flex>
             <ResultTypeSelector format={format} onChange={onResultTypeChange} />
             <LinkButton appearance="primary" onClick={onToggleAdvanced}>

package/src/components/field-config-panel/result-type-selector.tsx

@@ -11,6 +11,7 @@ const RESULT_TYPE_OPTIONS: { label: string; value: CalculatedFieldFormat['result
     { label: 'Number', value: 'number' },
     { label: 'Currency', value: 'currency' },
     { label: 'Percent', value: 'percent' },
+    { label: 'Date', value: 'date' },
 ];
 
 export const ResultTypeSelector: FC<ResultTypeSelectorProps> = ({ format, onChange }) => (

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

@@ -5,19 +5,36 @@ import { evaluateFormula, formatCalculatedResult, resolvePdfDataValues } from '.
 interface PdfViewCalculatedProps {
     field: PdfField;
     data?: DataModelValues;
+    holidays?: string[];
 }
 
-export const PdfViewCalculated: FC<PdfViewCalculatedProps> = ({ data, field }) => {
+export const PdfViewCalculated: FC<PdfViewCalculatedProps> = ({ data, field, holidays }) => {
+    const dateFieldPaths = useMemo(() => {
+        const paths = field.formulaFormat?.dateFieldPaths;
+        return paths?.length ? new Set(paths) : undefined;
+    }, [field.formulaFormat?.dateFieldPaths]);
+
     const displayValue = useMemo(() => {
         if (field.formula?.tokens?.length) {
-            const value = evaluateFormula(field.formula, data);
+            const value = evaluateFormula(field.formula, data, dateFieldPaths, holidays);
+            if (value === null) {
+                return '';
+            }
             return formatCalculatedResult(value, field.formulaFormat);
         }
         if (field.path) {
             return resolvePdfDataValues(data, field.path) ?? '';
         }
         return field.label ?? '';
-    }, [data, field.formula, field.formulaFormat, field.label, field.path]);
+    }, [
+        data,
+        dateFieldPaths,
+        field.formula,
+        field.formulaFormat,
+        field.label,
+        field.path,
+        holidays,
+    ]);
 
     return <div className="dte-pdf-field-value">{displayValue}</div>;
 };

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 { getFieldPlaceholderText } from '../../utils';
+import { dateToUtcZero, getFieldPlaceholderText } from '../../utils';
 
 interface PdfViewFillableProps {
     field: PdfField;
@@ -103,8 +103,11 @@ export const PdfViewFillable: FC<PdfViewFillableProps> = ({
                 disabled={!isFillable}
                 id={field.path}
                 name={field.path}
-                value={resolvedValue ?? ''}
-                onChange={e => handleDataChange(e.target.value)}
+                value={resolvedValue ? resolvedValue.slice(0, 10) : ''}
+                onChange={e => {
+                    const dateStr = e.target.value;
+                    handleDataChange(dateStr ? dateToUtcZero(dateStr) : '');
+                }}
                 placeholder={getFieldPlaceholderText(field, 'mm/dd/yyyy')}
             />
         );

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

@@ -25,6 +25,12 @@ export interface PdfViewProps {
     data?: DataModelValues;
     pdfUrl: string;
     loading?: 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?: string[];
     /*
      * fillingBy defines the list of recipient names
      * who are allowed to fill this field.
@@ -45,6 +51,7 @@ export const PdfView: FC<PdfViewProps> = ({
     errors = {},
     fields,
     fillingBy,
+    holidays,
     loading = false,
     loadingPlaceholder,
     onDataChange,
@@ -106,6 +113,7 @@ export const PdfView: FC<PdfViewProps> = ({
                                     <PdfViewCalculated
                                         field={field}
                                         data={previewMode === 'fillable' ? previewData : data}
+                                        holidays={holidays}
                                     />
                                 )}
                                 {field.type === FieldTypeEnum.fillable && (

package/src/constants/calculated.constants.ts

@@ -1 +1,5 @@
 export const CALCULATED_OPERATIONS = ['+', '-', '*', '/', '(', ')'];
+
+export const DEFAULT_DATE_FORMAT = 'MM/DD/YYYY';
+
+export const MAX_DATE_CALC_DAYS = 365;

package/src/hooks/useFormulaEditor.ts

@@ -18,10 +18,11 @@ import {
 
 export const useFormulaEditor = (params: {
     currentExpression: string;
+    knownDateFields?: Set<string>;
     opened: boolean;
     pathToLabel: Map<string, string>;
 }) => {
-    const { currentExpression, opened, pathToLabel } = params;
+    const { currentExpression, knownDateFields, opened, pathToLabel } = params;
     const [draftExpression, setDraftExpression] = useState(currentExpression);
     const [history, setHistory] = useState<string[]>([currentExpression]);
     const [historyIndex, setHistoryIndex] = useState(0);
@@ -32,6 +33,7 @@ export const useFormulaEditor = (params: {
     const lastCaretRef = useRef(0);
     const historyIndexRef = useRef(0);
     const historyRef = useRef<string[]>([currentExpression]);
+    const knownDateFieldsRef = useRef(knownDateFields);
 
     useEffect(() => {
         if (opened) {
@@ -210,6 +212,10 @@ export const useFormulaEditor = (params: {
         [draftExpression],
     );
 
+    useEffect(() => {
+        knownDateFieldsRef.current = knownDateFields;
+    }, [knownDateFields]);
+
     const handleKeyDown = useCallback((e: ReactKeyboardEvent<HTMLDivElement>) => {
         if (e.ctrlKey || e.metaKey) {
             const key = e.key.toLowerCase();
@@ -240,6 +246,16 @@ export const useFormulaEditor = (params: {
                 return;
             }
         }
+        if (knownDateFieldsRef.current?.size && (e.key === '*' || e.key === '/')) {
+            const parts = tokenizeExpression(readExpressionFromEditor(editorRef.current!));
+            const hasDate = parts.some(
+                p => p.type === 'field' && knownDateFieldsRef.current!.has(p.value),
+            );
+            if (hasDate) {
+                e.preventDefault();
+                return;
+            }
+        }
         const allowed = new Set([
             '+',
             '-',
@@ -331,9 +347,24 @@ export const useFormulaEditor = (params: {
         return new Set(parts.filter(p => p.type === 'field').map(p => p.value));
     }, [draftExpression]);
 
+    const expressionHasDateFields = useMemo(() => {
+        if (!knownDateFields?.size) {
+            return false;
+        }
+        const parts = tokenizeExpression(draftExpression);
+        return parts.some(p => p.type === 'field' && knownDateFields.has(p.value));
+    }, [draftExpression, knownDateFields]);
+
+    const disabledOperators = useMemo(
+        () => (expressionHasDateFields ? new Set(['*', '/']) : undefined),
+        [expressionHasDateFields],
+    );
+
     return {
         draftExpression,
+        disabledOperators,
         editorRef,
+        expressionHasDateFields,
         isDirty,
         canUndo: historyIndex > 0,
         canRedo: historyIndex < history.length - 1,

package/src/interface/types.ts

@@ -80,11 +80,14 @@ export interface PdfField {
     displayCondition?: DisplayConditionState | null;
 }
 
+export type SchemaFieldType = 'number' | 'date';
+
 export interface FieldTypeOption {
     label: string;
     type: FieldTypeEnum;
     subType?: PdfFieldSubType;
     path?: string;
+    fieldType?: SchemaFieldType;
 }
 
 export interface DataModelFieldGroup {
@@ -102,7 +105,7 @@ export type FormulaToken =
     | { type: 'operator'; value: FormulaOperator }
     | { type: 'lparen'; value: '(' }
     | { type: 'rparen'; value: ')' }
-    | { type: 'field'; path: string; label: string };
+    | { type: 'field'; path: string };
 
 /** Structured formula representation (AST-like token list) for validation and safe editing */
 export interface StructuredFormula {
@@ -111,7 +114,7 @@ export interface StructuredFormula {
 
 /** Format options for a calculated field result (display and rounding) */
 export interface CalculatedFieldFormat {
-    resultType: 'number' | 'currency' | 'percent';
+    resultType: 'number' | 'currency' | 'percent' | 'date';
     thousandsSeparator: boolean;
     decimals: number;
     roundingMode: 'round' | 'floor' | 'ceil';
@@ -119,6 +122,9 @@ export interface CalculatedFieldFormat {
     decimalSeparator: '.' | ',';
     prefixText: string;
     postfixText: string;
+    dateFormat?: string;
+    /** Paths of date-typed fields used in the formula, persisted for date-aware evaluation */
+    dateFieldPaths?: string[];
 }
 
 export interface SchemaFieldBaseOptions {

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

@@ -2,6 +2,7 @@ import {
     DataModelFieldGroup,
     FieldTypeEnum,
     FieldTypeOption,
+    SchemaFieldType,
     SchemaNode,
     SchemaObject,
     SchemaSimpleDate,
@@ -16,6 +17,16 @@ function isSchemaSimpleDate(node: SchemaNode): node is SchemaSimpleDate {
     return node.type === 'date';
 }
 
+function getSchemaFieldType(node: SchemaNode): SchemaFieldType | undefined {
+    if (isSchemaSimpleNumber(node)) {
+        return 'number';
+    }
+    if (isSchemaSimpleDate(node)) {
+        return 'date';
+    }
+    return undefined;
+}
+
 function useInCalculatedFields(node: SchemaNode): boolean {
     return node.options?.useInCalculatedFields === true;
 }
@@ -79,6 +90,7 @@ export const extractGroupedFieldsFromDataModel = (
                     label: property.title ?? key,
                     type: FieldTypeEnum.dataModel,
                     path: key,
+                    fieldType: getSchemaFieldType(property),
                 });
             }
         }
@@ -114,12 +126,12 @@ const extractFieldsRecursive = (
             rawType === 'boolean';
         const includeField = !onlyUseInCalculatedFields || useInCalculatedFields(fieldProperty);
         if (isLeaf && includeField) {
-            // Leaf property - add as a field
             const label = fieldProperty.title ?? fieldKey;
             fields.push({
                 label,
                 type: FieldTypeEnum.dataModel,
                 path: currentPath,
+                fieldType: getSchemaFieldType(fieldProperty),
             });
         } else if (fieldProperty.type === 'object' && fieldProperty.properties) {
             extractFieldsRecursive(

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

@@ -28,6 +28,26 @@ export function valueToNumber(raw: unknown): number {
     return Number.isNaN(n) ? 0 : n;
 }
 
+function hasAllFieldValues(
+    formula: StructuredFormula,
+    data: DataModelValues | undefined,
+    dateFieldPaths?: Set<string>,
+): boolean {
+    return formula.tokens.every((t: FormulaToken) => {
+        if (t.type !== 'field') {
+            return true;
+        }
+        const raw = resolvePdfDataValues(data, t.path);
+        if (raw === '') {
+            return false;
+        }
+        if (dateFieldPaths?.has(t.path)) {
+            return !isNaN(new Date(raw).getTime());
+        }
+        return !isNaN(Number(raw.trim()));
+    });
+}
+
 type ResolvedToken =
     | { type: 'number'; value: number }
     | { type: 'operator'; value: FormulaOperator }
@@ -66,7 +86,7 @@ function applyOp(a: number, op: FormulaOperator, b: number): number {
 }
 
 /** Find the index of the matching closing paren for an open paren at openIndex. */
-function findMatchingParen(tokens: ResolvedToken[], openIndex: number): number {
+function findMatchingParen<T extends { type: string }>(tokens: T[], openIndex: number): number {
     let balance = 1;
     for (let i = openIndex + 1; i < tokens.length; i++) {
         const t = tokens[i];
@@ -123,7 +143,6 @@ function evalResolvedTokens(tokens: ResolvedToken[]): number {
 
     const list = [...tokens];
 
-    // Resolve innermost parentheses first
     let idx = 0;
     while (idx < list.length) {
         if (list[idx].type === 'lparen') {
@@ -142,18 +161,265 @@ function evalResolvedTokens(tokens: ResolvedToken[]): number {
     return evalFlat(list);
 }
 
+/*
+ * ---------------------------------------------------------------------------
+ * Date-aware evaluation (business-day logic: skips weekends & holidays)
+ * ---------------------------------------------------------------------------
+ */
+
+type ValueKind = 'number' | 'date';
+
+interface TypedValue {
+    kind: ValueKind;
+    value: number;
+}
+
+type DateAwareToken =
+    | TypedValue
+    | { type: 'operator'; value: FormulaOperator }
+    | { type: 'lparen'; value: '(' }
+    | { type: 'rparen'; value: ')' };
+
+function isTypedValue(t: DateAwareToken): t is TypedValue {
+    return 'kind' in t;
+}
+
+function parseDateValue(raw: string): number {
+    const d = new Date(raw);
+    return isNaN(d.getTime()) ? NaN : d.getTime();
+}
+
+function toDateOnly(ms: number): Date {
+    const d = new Date(ms);
+    d.setUTCHours(0, 0, 0, 0);
+    return d;
+}
+
+function toDateKey(d: Date): string {
+    const y = d.getUTCFullYear();
+    const m = String(d.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(d.getUTCDate()).padStart(2, '0');
+    return `${y}-${m}-${day}`;
+}
+
+function isWeekend(d: Date): boolean {
+    const day = d.getUTCDay();
+    return day === 0 || day === 6;
+}
+
+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(new Date(h).getTime());
+        if (!isNaN(d.getTime())) {
+            set.add(toDateKey(d));
+        }
+    }
+    return set;
+}
+
+function isNonBusinessDay(d: Date, holidaySet: Set<string>): boolean {
+    return isWeekend(d) || (holidaySet.size > 0 && holidaySet.has(toDateKey(d)));
+}
+
+/**
+ * Add business days to a date (epoch ms), skipping weekends and holidays.
+ * Returns the resulting date as epoch ms.
+ */
+function addBusinessDays(startMs: number, days: number, holidaySet: Set<string>): number {
+    const result = toDateOnly(startMs);
+    if (!isFinite(result.getTime())) {
+        return result.getTime();
+    }
+
+    const intDays = Math.trunc(days);
+    if (intDays === 0) {
+        return result.getTime();
+    }
+
+    const direction = intDays > 0 ? 1 : -1;
+    let remaining = Math.abs(intDays);
+
+    while (remaining > 0) {
+        result.setUTCDate(result.getUTCDate() + direction);
+        if (!isNonBusinessDay(result, holidaySet)) {
+            remaining--;
+        }
+    }
+
+    return result.getTime();
+}
+
+/**
+ * Count business days between two dates (epoch ms), skipping weekends and holidays.
+ * Positive when `toMs` is after `fromMs`, negative otherwise.
+ */
+function businessDayDiff(fromMs: number, toMs: number, holidaySet: Set<string>): number {
+    const start = toDateOnly(fromMs);
+    const end = toDateOnly(toMs);
+
+    if (!isFinite(start.getTime()) || !isFinite(end.getTime())) {
+        return 0;
+    }
+
+    const direction = end.getTime() >= start.getTime() ? 1 : -1;
+    const cursor = new Date(start.getTime());
+    let count = 0;
+
+    while (toDateKey(cursor) !== toDateKey(end)) {
+        cursor.setUTCDate(cursor.getUTCDate() + direction);
+        if (!isNonBusinessDay(cursor, holidaySet)) {
+            count++;
+        }
+    }
+
+    return count * direction;
+}
+
+function resolveDateAwareTokens(
+    formula: StructuredFormula,
+    data: DataModelValues | undefined,
+    dateFieldPaths: Set<string>,
+): DateAwareToken[] {
+    return formula.tokens.map((t: FormulaToken): DateAwareToken => {
+        if (t.type === 'field') {
+            const raw = resolvePdfDataValues(data, t.path);
+            if (dateFieldPaths.has(t.path)) {
+                const ms = parseDateValue(raw);
+                return { kind: 'date', value: isNaN(ms) ? 0 : ms };
+            }
+            return { kind: 'number', value: valueToNumber(raw) };
+        }
+        if (t.type === 'number') {
+            return { kind: 'number', value: valueToNumber(t.value) };
+        }
+        return t as DateAwareToken;
+    });
+}
+
+/**
+ * Apply an operator to two typed values with date-aware, business-day semantics:
+ *   date + number → add business days  → date
+ *   number + date → add business days  → date
+ *   date - number → sub business days  → date
+ *   date - date   → business day diff  → number
+ *   number ± number → normal           → number
+ */
+function applyDateOp(
+    a: TypedValue,
+    op: FormulaOperator,
+    b: TypedValue,
+    holidaySet: Set<string>,
+): TypedValue {
+    if (a.kind === 'date' && b.kind === 'number') {
+        if (op === '+') {
+            return { kind: 'date', value: addBusinessDays(a.value, b.value, holidaySet) };
+        }
+        if (op === '-') {
+            return { kind: 'date', value: addBusinessDays(a.value, -b.value, holidaySet) };
+        }
+    }
+    if (a.kind === 'number' && b.kind === 'date' && op === '+') {
+        return { kind: 'date', value: addBusinessDays(b.value, a.value, holidaySet) };
+    }
+    if (a.kind === 'date' && b.kind === 'date' && op === '-') {
+        return { kind: 'number', value: businessDayDiff(a.value, b.value, holidaySet) };
+    }
+    return { kind: 'number', value: applyOp(a.value, op, b.value) };
+}
+
+function evalDateFlat(tokens: DateAwareToken[], holidaySet: Set<string>): TypedValue {
+    const list = [...tokens];
+
+    for (let i = 1; i < list.length - 1; ) {
+        const t = list[i];
+        if ('type' in t && t.type === 'operator' && (t.value === '+' || t.value === '-')) {
+            const left = list[i - 1];
+            const right = list[i + 1];
+            if (isTypedValue(left) && isTypedValue(right)) {
+                const result = applyDateOp(left, t.value, right, holidaySet);
+                list.splice(i - 1, 3, result);
+                continue;
+            }
+        }
+        i += 2;
+    }
+
+    const single = list[0];
+    return isTypedValue(single) ? single : { kind: 'number', value: 0 };
+}
+
+function evalDateAwareTokens(tokens: DateAwareToken[], holidaySet: Set<string>): TypedValue {
+    if (tokens.length === 0) {
+        return { kind: 'number', value: 0 };
+    }
+    if (tokens.length === 1 && isTypedValue(tokens[0])) {
+        return tokens[0];
+    }
+
+    const list = [...tokens];
+
+    let idx = 0;
+    while (idx < list.length) {
+        if ('type' in list[idx] && (list[idx] as { type: string }).type === 'lparen') {
+            const close = findMatchingParen(list as { type: string }[], idx);
+            if (close === -1) {
+                break;
+            }
+            const inner = list.slice(idx + 1, close);
+            const result = evalDateAwareTokens(inner as DateAwareToken[], holidaySet);
+            list.splice(idx, close - idx + 1, result);
+            continue;
+        }
+        idx++;
+    }
+
+    return evalDateFlat(list as DateAwareToken[], holidaySet);
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * Public API
+ * ---------------------------------------------------------------------------
+ */
+
 /**
  * Evaluate a structured formula with the given data.
  * Field tokens are resolved via resolvePdfDataValues; string values are converted to number.
- * Supports +, -, *, / and parentheses. Returns 0 when the formula is empty or invalid.
+ * Supports +, -, *, / and parentheses.
+ *
+ * Returns `null` when the formula is empty **or** when any field token resolves
+ * to null / undefined / empty / non-numeric (non-date) — making the entire
+ * calculation blank instead of silently substituting 0.
+ *
+ * When `dateFieldPaths` is provided, date fields are resolved to epoch-ms and
+ * arithmetic follows business-day semantics — weekends and holidays are skipped
+ * when adding/subtracting days, and date diffs count only business days.
  */
 export function evaluateFormula(
     formula: StructuredFormula | undefined | null,
     data: DataModelValues | undefined,
-): number {
+    dateFieldPaths?: Set<string>,
+    holidays?: string[],
+): number | null {
     if (!formula?.tokens?.length) {
-        return 0;
+        return null;
+    }
+
+    if (!hasAllFieldValues(formula, data, dateFieldPaths)) {
+        return null;
     }
+
+    if (dateFieldPaths?.size) {
+        const resolved = resolveDateAwareTokens(formula, data, dateFieldPaths);
+        const holidaySet = buildHolidaySet(holidays);
+        const result = evalDateAwareTokens(resolved, holidaySet);
+        return result.value;
+    }
+
     const resolved = resolveTokens(formula, data);
     return evalResolvedTokens(resolved);
 }

package/src/utils/formula/expression.utils.ts

@@ -48,14 +48,10 @@ export function tokenizeExpression(expression: string): ExpressionPart[] {
 }
 
 /**
- * Parse an expression string into FormulaToken[] using valid paths and path->label map.
- * Invalid or unknown identifiers are skipped (or could be left as placeholder); only known paths become field tokens.
+ * Parse an expression string into FormulaToken[] using valid paths.
+ * Invalid or unknown identifiers are skipped; only known paths become field tokens.
  */
-export function parseExpression(
-    expression: string,
-    validPaths: Set<string>,
-    pathToLabel: Map<string, string>,
-): FormulaToken[] {
+export function parseExpression(expression: string, validPaths: Set<string>): FormulaToken[] {
     const parts = tokenizeExpression(expression).filter(
         p => p.type !== 'text' || p.value.trim() !== '',
     );
@@ -70,7 +66,6 @@ export function parseExpression(
                 tokens.push({
                     type: 'field',
                     path: part.value,
-                    label: pathToLabel.get(part.value) ?? part.value,
                 });
             }
             continue;