@servicetitan/dte-pdf-editor 1.34.0 → 1.36.0

package/src/hooks/useFormulaEditor.ts

@@ -7,8 +7,8 @@ import {
     useState,
 } from 'react';
 import {
-    backspaceBetweenTwoFields,
     getCaretExpressionIndex,
+    normalizeMergeTags,
     placeCaretAtEnd,
     readExpressionFromEditor,
     renderFormulaHtml,
@@ -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) {
@@ -79,26 +81,36 @@ export const useFormulaEditor = (params: {
         }
         const nextValue = readExpressionFromEditor(editor);
         const caretIndex = getCaretExpressionIndex(editor);
-        pendingCaretRef.current = caretIndex;
-        lastCaretRef.current = caretIndex;
-        updateSourceRef.current = 'editor';
-        setDraftExpression(nextValue);
+        const validPaths = new Set(pathToLabel.keys());
+        const { normalized, removed } = normalizeMergeTags(nextValue, validPaths);
+        let nextCaret = caretIndex;
+        if (removed) {
+            if (caretIndex >= removed.end) {
+                nextCaret = caretIndex - (removed.end - removed.start);
+            } else if (caretIndex > removed.start) {
+                nextCaret = removed.start;
+            }
+        }
+        pendingCaretRef.current = nextCaret;
+        lastCaretRef.current = nextCaret;
+        updateSourceRef.current = removed ? 'state' : 'editor';
+        setDraftExpression(normalized);
         setIsDirty(true);
         const cur = historyIndexRef.current;
         const hist = historyRef.current;
         const base = hist.slice(0, cur + 1);
-        if (base[base.length - 1] !== nextValue) {
-            setHistory([...base, nextValue]);
+        if (base[base.length - 1] !== normalized) {
+            setHistory([...base, normalized]);
             setHistoryIndex(base.length);
         }
-    }, []);
+    }, [pathToLabel]);
 
     const getCaretIndexForInsert = useCallback((): number => {
         const editor = editorRef.current;
         if (!editor) {
             return draftExpression.length;
         }
-        const sel = editor.ownerDocument?.defaultView?.getSelection() ?? null;
+        const sel = window.getSelection();
         if (sel?.rangeCount && editor.contains(sel.getRangeAt(0).startContainer)) {
             const idx = getCaretExpressionIndex(editor);
             lastCaretRef.current = idx;
@@ -200,99 +212,83 @@ export const useFormulaEditor = (params: {
         [draftExpression],
     );
 
-    const handleKeyDown = useCallback(
-        (e: ReactKeyboardEvent<HTMLDivElement>) => {
-            if (e.ctrlKey || e.metaKey) {
-                const key = e.key.toLowerCase();
-                if (key === 'z') {
-                    e.preventDefault();
-                    if (historyIndexRef.current > 0) {
-                        const next = historyRef.current[historyIndexRef.current - 1];
-                        updateSourceRef.current = 'state';
-                        pendingCaretRef.current = next.length;
-                        setDraftExpression(next);
-                        setHistoryIndex(historyIndexRef.current - 1);
-                        setIsDirty(true);
-                    }
-                    return;
-                }
-                if (key === 'y' || (e.shiftKey && key === 'z')) {
-                    e.preventDefault();
-                    const cur = historyIndexRef.current;
-                    const hist = historyRef.current;
-                    if (cur < hist.length - 1) {
-                        const next = hist[cur + 1];
-                        updateSourceRef.current = 'state';
-                        pendingCaretRef.current = next.length;
-                        setDraftExpression(next);
-                        setHistoryIndex(cur + 1);
-                        setIsDirty(true);
-                    }
-                    return;
+    useEffect(() => {
+        knownDateFieldsRef.current = knownDateFields;
+    }, [knownDateFields]);
+
+    const handleKeyDown = useCallback((e: ReactKeyboardEvent<HTMLDivElement>) => {
+        if (e.ctrlKey || e.metaKey) {
+            const key = e.key.toLowerCase();
+            if (key === 'z') {
+                e.preventDefault();
+                if (historyIndexRef.current > 0) {
+                    const next = historyRef.current[historyIndexRef.current - 1];
+                    updateSourceRef.current = 'state';
+                    pendingCaretRef.current = next.length;
+                    setDraftExpression(next);
+                    setHistoryIndex(historyIndexRef.current - 1);
+                    setIsDirty(true);
                 }
+                return;
             }
-            if (e.key === 'Backspace') {
-                const editor = editorRef.current;
-                if (editor) {
-                    const currentExpression = readExpressionFromEditor(editor);
-                    let caretIndex = getCaretExpressionIndex(editor);
-                    /*
-                     * Selection can collapse to (element, childCount) after DOM updates, yielding
-                     * expression.length (e.g. 33) instead of the real position (e.g. 16). Use last
-                     * known valid position when reported position is at end but we had a mid-string index.
-                     */
-                    if (
-                        caretIndex === currentExpression.length &&
-                        lastCaretRef.current >= 0 &&
-                        lastCaretRef.current < currentExpression.length
-                    ) {
-                        caretIndex = lastCaretRef.current;
-                    }
-                    lastCaretRef.current = caretIndex;
-                    const result = backspaceBetweenTwoFields(currentExpression, caretIndex);
-                    if (result) {
-                        e.preventDefault();
-                        updateSourceRef.current = 'state';
-                        pushHistory(result.newExpression, result.newCaret);
-                        return;
-                    }
+            if (key === 'y' || (e.shiftKey && key === 'z')) {
+                e.preventDefault();
+                const cur = historyIndexRef.current;
+                const hist = historyRef.current;
+                if (cur < hist.length - 1) {
+                    const next = hist[cur + 1];
+                    updateSourceRef.current = 'state';
+                    pendingCaretRef.current = next.length;
+                    setDraftExpression(next);
+                    setHistoryIndex(cur + 1);
+                    setIsDirty(true);
                 }
+                return;
             }
-            const allowed = new Set([
-                '+',
-                '-',
-                '*',
-                '/',
-                '(',
-                ')',
-                '0',
-                '1',
-                '2',
-                '3',
-                '4',
-                '5',
-                '6',
-                '7',
-                '8',
-                '9',
-                '.',
-                'Backspace',
-                'Delete',
-                'ArrowLeft',
-                'ArrowRight',
-                'ArrowUp',
-                'ArrowDown',
-                'Home',
-                'End',
-                'Tab',
-                ' ',
-            ]);
-            if (!allowed.has(e.key)) {
+        }
+        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;
             }
-        },
-        [pushHistory],
-    );
+        }
+        const allowed = new Set([
+            '+',
+            '-',
+            '*',
+            '/',
+            '(',
+            ')',
+            '0',
+            '1',
+            '2',
+            '3',
+            '4',
+            '5',
+            '6',
+            '7',
+            '8',
+            '9',
+            '.',
+            'Backspace',
+            'Delete',
+            'ArrowLeft',
+            'ArrowRight',
+            'ArrowUp',
+            'ArrowDown',
+            'Home',
+            'End',
+            'Tab',
+            ' ',
+        ]);
+        if (!allowed.has(e.key)) {
+            e.preventDefault();
+        }
+    }, []);
 
     const handlePaste = useCallback(
         (text: string) => {
@@ -351,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 {
@@ -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 {
@@ -227,5 +233,6 @@ export const VALUE_LESS_OPERATORS: ConditionOperator[] = ['is_empty', 'is_not_em
 export interface DataPointOption {
     fieldType: 'number' | 'string';
     fullKey: string;
+    group: string;
     title: string;
 }

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

@@ -39,9 +39,11 @@ function walkSchema(
         if (node?.type === 'object') {
             result.push(...walkSchema(node as SchemaObject, fullKey, [...parentTitles, title]));
         } else if (isValueNode(node) && isUseInConditionals(node)) {
+            const fieldType = node.type === 'number' ? 'number' : 'string';
             result.push({
-                fieldType: node.type === 'number' ? 'number' : 'string',
+                fieldType,
                 fullKey,
+                group: fieldType === 'number' ? 'Numeric Fields' : 'Data Model',
                 title: fullTitle || fullKey,
             });
         }
@@ -73,6 +75,7 @@ export function getDocumentFieldsDataPointOptions(
         result.push({
             fieldType,
             fullKey: f.path,
+            group: 'Document Fields',
             title: f.label || f.path,
         });
     }

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/caret.utils.ts

@@ -1,7 +1,7 @@
 import { placeCaretAtEnd, readExpressionFromEditor } from './dom.utils';
 
 function getExpressionBeforeCaret(element: HTMLElement): string {
-    const selection = element.ownerDocument?.defaultView?.getSelection() ?? null;
+    const selection = window.getSelection() ?? null;
     if (!selection || selection.rangeCount === 0) {
         return readExpressionFromEditor(element);
     }

package/src/utils/formula/dom.utils.ts

@@ -23,7 +23,7 @@ export function readExpressionFromEditor(node: HTMLElement): string {
 }
 
 export function placeCaretAtEnd(element: HTMLElement): void {
-    const selection = element.ownerDocument?.defaultView?.getSelection() ?? null;
+    const selection = window.getSelection() ?? null;
     if (!selection) {
         return;
     }