@servicetitan/dte-pdf-editor 1.20.0 → 1.22.0

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

@@ -0,0 +1,134 @@
+import {
+    ConditionOperator,
+    DataModelValues,
+    DisplayConditionGroup,
+    DisplayConditionState,
+    VALUE_LESS_OPERATORS,
+} from '../../interface/types';
+
+function getValueAtPath(
+    data: DataModelValues | undefined,
+    path: string,
+): string | number | undefined {
+    if (!data || !path) {
+        return undefined;
+    }
+    const keys = path.split('.');
+    let value: unknown = data;
+    for (const key of keys) {
+        if (value === null || value === undefined || typeof value !== 'object') {
+            return undefined;
+        }
+        value = (value as Record<string, unknown>)[key];
+    }
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    if (typeof value === 'number' || typeof value === 'string') {
+        return value;
+    }
+    return String(value);
+}
+
+function evaluateSingleCondition(
+    dataPointKey: string,
+    operator: string,
+    value: string,
+    data: DataModelValues | undefined,
+): boolean {
+    const raw = getValueAtPath(data, dataPointKey);
+    const strVal = raw === undefined ? '' : String(raw);
+    const numVal = typeof raw === 'number' ? raw : Number(strVal);
+    const trimmedInput = value.trim();
+    const parsed = Number(trimmedInput);
+    const numInput = trimmedInput !== '' && Number.isFinite(parsed) ? parsed : 0;
+
+    switch (operator as ConditionOperator) {
+        case 'is_equal_to':
+            return strVal === trimmedInput;
+        case 'is_not_equal_to':
+            return strVal !== trimmedInput;
+        case 'contains':
+            return strVal.includes(trimmedInput);
+        case 'does_not_contain':
+            return !strVal.includes(trimmedInput);
+        case 'starts_with':
+            return strVal.startsWith(trimmedInput);
+        case 'ends_with':
+            return strVal.endsWith(trimmedInput);
+        case 'is_empty':
+            return strVal === '' || strVal.length === 0;
+        case 'is_not_empty':
+            return strVal !== '' && strVal.length > 0;
+        case 'num_eq':
+            return numVal === numInput;
+        case 'num_neq':
+            return numVal !== numInput;
+        case 'num_gt':
+            return numVal > numInput;
+        case 'num_lt':
+            return numVal < numInput;
+        case 'num_gte':
+            return numVal >= numInput;
+        case 'num_lte':
+            return numVal <= numInput;
+        default:
+            return strVal === trimmedInput;
+    }
+}
+
+function evaluateGroup(group: DisplayConditionGroup, data: DataModelValues | undefined): boolean {
+    const valid = group.conditions.filter(
+        c =>
+            c.dataPointKey &&
+            (VALUE_LESS_OPERATORS.includes(c.operator as ConditionOperator) ||
+                c.value.trim() !== ''),
+    );
+    if (valid.length === 0) {
+        return false;
+    }
+    let result = evaluateSingleCondition(
+        valid[0].dataPointKey,
+        valid[0].operator,
+        valid[0].value,
+        data,
+    );
+    for (let i = 1; i < valid.length; i++) {
+        const op = valid[i].logicalOperator === 'or' ? 'or' : 'and';
+        const next = evaluateSingleCondition(
+            valid[i].dataPointKey,
+            valid[i].operator,
+            valid[i].value,
+            data,
+        );
+        result = op === 'or' ? result || next : result && next;
+    }
+    return result;
+}
+
+/**
+ * Evaluate display condition state against data. Returns true if the field should be visible.
+ */
+export function evaluateDisplayCondition(
+    state: DisplayConditionState,
+    data: DataModelValues | undefined,
+): boolean {
+    const validGroups = state.groups.filter(g =>
+        g.conditions.some(
+            c =>
+                c.dataPointKey &&
+                (VALUE_LESS_OPERATORS.includes(c.operator as ConditionOperator) ||
+                    c.value.trim() !== ''),
+        ),
+    );
+    if (validGroups.length === 0) {
+        return true;
+    }
+    let result = evaluateGroup(validGroups[0], data);
+    for (let i = 1; i < validGroups.length; i++) {
+        const op = validGroups[i].logicalOperator === 'or' ? 'or' : 'and';
+        const next = evaluateGroup(validGroups[i], data);
+        result = op === 'or' ? result || next : result && next;
+    }
+    return state.behavior === 'hide' ? !result : result;
+}

package/src/utils/conditions/index.ts

@@ -0,0 +1,2 @@
+export * from './evaluate.utils';
+export * from './schema-data-points.utils';

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

@@ -0,0 +1,93 @@
+import {
+    DataPointOption,
+    FieldTypeEnum,
+    type PdfField,
+    type SchemaNode,
+    type SchemaObject,
+} from '../../interface/types';
+
+function isUseInConditionals(
+    node:
+        | { options?: { useInConditionals?: boolean; useInCalculatedFields?: boolean } }
+        | undefined,
+): boolean {
+    return (
+        node?.options?.useInConditionals === true || node?.options?.useInCalculatedFields === true
+    );
+}
+
+function isValueNode(
+    node: SchemaNode,
+): node is { type: 'string' | 'number'; title?: string; options?: object } {
+    return node?.type === 'string' || node?.type === 'number';
+}
+
+function walkSchema(
+    schema: SchemaObject | undefined,
+    prefix: string,
+    parentTitles: string[],
+): DataPointOption[] {
+    if (!schema?.properties) {
+        return [];
+    }
+    const result: DataPointOption[] = [];
+    for (const [key, node] of Object.entries(schema.properties)) {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        const title = (node as { title?: string }).title ?? key;
+        const fullTitle = [...parentTitles, title].join(' - ');
+
+        if (node?.type === 'object') {
+            result.push(...walkSchema(node as SchemaObject, fullKey, [...parentTitles, title]));
+        } else if (isValueNode(node) && isUseInConditionals(node)) {
+            result.push({
+                fieldType: node.type === 'number' ? 'number' : 'string',
+                fullKey,
+                title: fullTitle || fullKey,
+            });
+        }
+    }
+    return result;
+}
+
+export function getSchemaDataPointOptions(schema: SchemaObject | undefined): DataPointOption[] {
+    const options = walkSchema(schema, '', []);
+    return options.sort((a, b) => a.title.localeCompare(b.title));
+}
+
+/**
+ * Data point options from document fields: fillable only (no calculated fields).
+ * Uses field.path as fullKey so condition evaluation can read from the same data object.
+ */
+export function getDocumentFieldsDataPointOptions(
+    fields: PdfField[] | undefined,
+): DataPointOption[] {
+    if (!fields?.length) {
+        return [];
+    }
+    const result: DataPointOption[] = [];
+    for (const f of fields) {
+        if (!f.path || f.type !== FieldTypeEnum.fillable) {
+            continue;
+        }
+        const fieldType = f.subType === 'number' ? 'number' : 'string';
+        result.push({
+            fieldType,
+            fullKey: f.path,
+            title: f.label || f.path,
+        });
+    }
+    return result.sort((a, b) => a.title.localeCompare(b.title));
+}
+
+/**
+ * Combined data point options: schema (data model) + fillable fields.
+ */
+export function getDataPointOptions(
+    schema: SchemaObject | undefined,
+    documentFields: PdfField[] | undefined,
+): DataPointOption[] {
+    const schemaOptions = getSchemaDataPointOptions(schema);
+    const documentOptions = getDocumentFieldsDataPointOptions(documentFields);
+    const combined = [...schemaOptions, ...documentOptions];
+    return combined.sort((a, b) => a.title.localeCompare(b.title));
+}

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

@@ -4,6 +4,7 @@ import {
     FieldTypeOption,
     SchemaNode,
     SchemaObject,
+    SchemaSimpleDate,
     SchemaSimpleNumber,
 } from '../../interface/types';
 
@@ -11,6 +12,10 @@ function isSchemaSimpleNumber(node: SchemaNode): node is SchemaSimpleNumber {
     return node.type === 'number';
 }
 
+function isSchemaSimpleDate(node: SchemaNode): node is SchemaSimpleDate {
+    return node.type === 'date';
+}
+
 function useInCalculatedFields(node: SchemaNode): boolean {
     return node.options?.useInCalculatedFields === true;
 }
@@ -18,6 +23,7 @@ function useInCalculatedFields(node: SchemaNode): boolean {
 export interface ExtractGroupedFieldsOptions {
     /** When true, only include fields with SchemaFieldBaseOptions.useInCalculatedFields === true */
     onlyUseInCalculatedFields?: boolean;
+    onlyUseInConditionals?: boolean;
 }
 
 /**
@@ -64,13 +70,13 @@ export const extractGroupedFieldsFromDataModel = (
             const rawType = (property as { type?: string }).type;
             const isLeaf =
                 property.type === 'string' ||
-                isSchemaSimpleNumber(property as SchemaNode) ||
+                isSchemaSimpleNumber(property) ||
+                isSchemaSimpleDate(property) ||
                 rawType === 'boolean';
-            const includeField =
-                !onlyUseInCalculatedFields || useInCalculatedFields(property as SchemaNode);
+            const includeField = !onlyUseInCalculatedFields || useInCalculatedFields(property);
             if (isLeaf && includeField) {
                 topLevelFields.push({
-                    label: (property as SchemaNode).title ?? key,
+                    label: property.title ?? key,
                     type: FieldTypeEnum.dataModel,
                     path: key,
                 });
@@ -98,14 +104,13 @@ const extractFieldsRecursive = (
 ): void => {
     Object.keys(properties).forEach(fieldKey => {
         const fieldProperty = properties[fieldKey];
-        const currentPath = basePath.includes('[]')
-            ? `${basePath}.${fieldKey}`
-            : `${basePath}.${fieldKey}`;
+        const currentPath = `${basePath}.${fieldKey}`;
 
         const rawType = (fieldProperty as { type?: string }).type;
         const isLeaf =
             fieldProperty.type === 'string' ||
             isSchemaSimpleNumber(fieldProperty) ||
+            isSchemaSimpleDate(fieldProperty) ||
             rawType === 'boolean';
         const includeField = !onlyUseInCalculatedFields || useInCalculatedFields(fieldProperty);
         if (isLeaf && includeField) {

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

@@ -1,25 +1,6 @@
-import { FormulaToken } from '../../interface/types';
 import { escapeHtml } from './dom.utils';
 import { tokenizeExpression } from './expression.utils';
 
-/**
- * Renders formula tokens to HTML for the read-only preview (e.g. formula box).
- * Uses the same token classes as the modal (dte-formula-token, dte-formula-token-field, etc.).
- */
-export function renderFormulaPreviewHtml(tokens: FormulaToken[]): string {
-    if (!tokens?.length) {
-        return '';
-    }
-    return tokens
-        .map(token => {
-            const type = token.type;
-            const text = type === 'field' ? token.label : (token as { value: string }).value;
-            const escaped = escapeHtml(text).replace(/ /g, ' ');
-            return `<span class="dte-formula-token dte-formula-token-${type}">${escaped}</span>`;
-        })
-        .join('');
-}
-
 export function renderFormulaHtml(expression: string, labelMap: Map<string, string>): string {
     if (!expression.trim()) {
         return '';

package/src/utils/index.ts

@@ -4,3 +4,5 @@ export * from './data-model';
 export * from './formula';
 export * from './path';
 export * from './recipients';
+export * from './conditions';
+export * from './shared';

package/src/utils/shared/index.ts

@@ -0,0 +1 @@
+export * from './number.utils';

package/src/utils/shared/number.utils.ts

@@ -0,0 +1,13 @@
+export function isValidNumber(value: string | number): boolean {
+    if (typeof value === 'number') {
+        return Number.isFinite(value);
+    }
+
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        return false;
+    }
+
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed);
+}