@servicetitan/dte-pdf-editor 1.34.0 → 1.36.0

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 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

@@ -26,7 +26,7 @@ export interface ExpressionPart {
     value: string;
 }
 
-// Field paths may contain hyphens (e.g. fillable_recipient_uuid with UUIDs)
+// Field paths may contain hyphens (e.g., fillable_recipient_uuid with UUIDs)
 const EXPRESSION_REGEX = /[A-Za-z_][A-Za-z0-9_.-]*|\d+(?:\.\d+)?|[()+\-*/]|\s+|./g;
 
 export function tokenizeExpression(expression: string): ExpressionPart[] {
@@ -98,57 +98,54 @@ export function parseExpression(
     return tokens;
 }
 
-export interface BackspaceBetweenFieldsResult {
-    newExpression: string;
-    newCaret: number;
+export interface NormalizeMergeTagsResult {
+    normalized: string;
+    removed: { start: number; end: number } | null;
 }
 
 /**
- * If Backspace at caret deletes a space (or whitespace) that is between two field tokens,
- * returns the new expression and caret:
- * - If there is more than one space between the two fields: delete only one space.
- * - If there is exactly one space: remove the left field and the space.
- * Otherwise, returns null.
+ * When two merge tags (valid field paths) become adjacent with no separator,
+ * removes the LEFT tag so merge tags stay atomic. Returns the normalized
+ * expression and the removed range (for caret adjustment).
  */
-export function backspaceBetweenTwoFields(
+export function normalizeMergeTags(
     expression: string,
-    caretIndex: number,
-): BackspaceBetweenFieldsResult | null {
-    if (caretIndex <= 0) {
-        return null;
-    }
-    const parts = tokenizeExpression(expression);
-    let pos = 0;
-    const withPos: { part: ExpressionPart; start: number; end: number }[] = [];
-    for (const part of parts) {
-        withPos.push({ part, start: pos, end: pos + part.value.length });
-        pos += part.value.length;
-    }
-    const deleteIdx = caretIndex - 1;
-    const spacePartIdx = withPos.findIndex(p => p.start <= deleteIdx && deleteIdx < p.end);
-    if (spacePartIdx < 0) {
-        return null;
-    }
-    const spacePart = withPos[spacePartIdx];
-    if (spacePart.part.type !== 'text' || !/^\s+$/.test(spacePart.part.value)) {
-        return null;
-    }
-    const prevIdx = spacePartIdx - 1;
-    const nextIdx = spacePartIdx + 1;
-    if (prevIdx < 0 || nextIdx >= withPos.length) {
-        return null;
-    }
-    if (withPos[prevIdx].part.type !== 'field' || withPos[nextIdx].part.type !== 'field') {
-        return null;
+    validPaths: Set<string>,
+): NormalizeMergeTagsResult {
+    if (validPaths.size === 0) {
+        return { normalized: expression, removed: null };
     }
-    const spacePartLength = spacePart.part.value.length;
-    if (spacePartLength > 1) {
-        const newExpression = expression.slice(0, deleteIdx) + expression.slice(deleteIdx + 1);
-        const newCaret = deleteIdx;
-        return { newExpression, newCaret };
+    const pathsByLength = [...validPaths].sort((a, b) => b.length - a.length);
+    for (let i = 0; i < expression.length; i++) {
+        for (const path1 of pathsByLength) {
+            if (i + path1.length > expression.length) {
+                continue;
+            }
+            const slice1 = expression.slice(i, i + path1.length);
+            if (slice1 !== path1) {
+                continue;
+            }
+            const beforeFirst = expression[i - 1];
+            if (beforeFirst !== undefined && /[A-Za-z0-9_.-]/.test(beforeFirst)) {
+                continue;
+            }
+            const restStart = i + path1.length;
+            for (const path2 of pathsByLength) {
+                if (restStart + path2.length > expression.length) {
+                    continue;
+                }
+                const slice2 = expression.slice(restStart, restStart + path2.length);
+                if (slice2 !== path2) {
+                    continue;
+                }
+                const afterSecond = expression[restStart + path2.length];
+                if (afterSecond !== undefined && /[A-Za-z0-9_.-]/.test(afterSecond)) {
+                    continue;
+                }
+                const normalized = expression.slice(0, i) + expression.slice(restStart);
+                return { normalized, removed: { start: i, end: restStart } };
+            }
+        }
     }
-    const newExpression =
-        expression.slice(0, withPos[prevIdx].start) + expression.slice(withPos[nextIdx].start);
-    const newCaret = withPos[prevIdx].start;
-    return { newExpression, newCaret };
+    return { normalized: expression, removed: null };
 }

package/src/utils/formula/format-calculated-result.utils.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_DATE_FORMAT } from '../../constants';
 import { CalculatedFieldFormat } from '../../interface/types';
 
 function roundValue(
@@ -36,9 +37,33 @@ function formatIntegerPart(
     return parts.join(sep);
 }
 
+const DATE_FORMAT_TOKENS: Record<string, (d: Date) => string> = {
+    YYYY: d => String(d.getFullYear()),
+    YY: d => String(d.getFullYear()).slice(-2),
+    MMMM: d => d.toLocaleString('en-US', { month: 'long' }),
+    MMM: d => d.toLocaleString('en-US', { month: 'short' }),
+    MM: d => String(d.getMonth() + 1).padStart(2, '0'),
+    M: d => String(d.getMonth() + 1),
+    DD: d => String(d.getDate()).padStart(2, '0'),
+    D: d => String(d.getDate()),
+};
+
+const DATE_TOKEN_PATTERN = new RegExp(Object.keys(DATE_FORMAT_TOKENS).join('|'), 'g');
+
+function formatDateValue(epochMs: number, dateFormat: string): string {
+    const date = new Date(epochMs);
+    if (isNaN(date.getTime())) {
+        return '';
+    }
+    return dateFormat.replace(DATE_TOKEN_PATTERN, match => {
+        const fn = DATE_FORMAT_TOKENS[match];
+        return fn ? fn(date) : match;
+    });
+}
+
 /**
  * Format a calculated formula result for display using advanced settings.
- * Applies rounding, decimal places, thousands/decimal separators, result type (number/currency/percent), and prefix/postfix.
+ * Applies rounding, decimal places, thousands/decimal separators, result type (number/currency/percent/date), and prefix/postfix.
  */
 export function formatCalculatedResult(
     value: number,
@@ -48,23 +73,21 @@ export function formatCalculatedResult(
         return String(value);
     }
 
+    if (format.resultType === 'date') {
+        return formatDateValue(value, format.dateFormat ?? DEFAULT_DATE_FORMAT);
+    }
+
     const {
         decimalSeparator,
         decimalSeparatorEnabled,
         decimals,
         postfixText,
         prefixText,
-        resultType,
         roundingMode,
         thousandsSeparator,
     } = format;
 
-    let num = value;
-    if (resultType === 'percent') {
-        num = value * 100;
-    }
-
-    const rounded = roundValue(num, decimals, roundingMode);
+    const rounded = roundValue(value, decimals, roundingMode);
     const fixed = rounded.toFixed(decimals);
     const [intPart, decPart] = fixed.split('.');
 
@@ -73,7 +96,6 @@ export function formatCalculatedResult(
     const decSuffix = decimals > 0 ? decimalSep + (decPart ?? '') : '';
 
     const numberStr = intFormatted + decSuffix;
-    const suffix = resultType === 'percent' ? '%' : '';
 
-    return `${prefixText}${numberStr}${suffix}${postfixText}`;
+    return `${prefixText}${numberStr}${postfixText}`;
 }

package/src/utils/formula/index.ts

@@ -4,7 +4,5 @@ export * from './evaluate-formula.utils';
 export * from './expression.utils';
 export * from './format-calculated-result.utils';
 export * from './formula-types';
-export * from './referenced-paths.utils';
 export * from './render-formula.utils';
-export * from './serialize-formula.utils';
 export * from './validate-formula.utils';

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

@@ -1,3 +1,4 @@
+import { MAX_DATE_CALC_DAYS } from '../../constants';
 import { FormulaToken, StructuredFormula } from '../../interface/types';
 
 export interface FormulaValidationResult {
@@ -20,6 +21,7 @@ function isOperandToken(t: FormulaToken): boolean {
 export function validateFormula(
     formula: StructuredFormula | undefined | null,
     validPaths: Set<string>,
+    knownDateFields?: Set<string>,
 ): FormulaValidationResult {
     const errors: string[] = [];
 
@@ -90,6 +92,28 @@ export function validateFormula(
         errors.push('Formula must end with an operand or closing parenthesis');
     }
 
+    if (knownDateFields?.size) {
+        const hasDateField = tokens.some(t => t.type === 'field' && knownDateFields.has(t.path));
+        if (hasDateField) {
+            const hasMultiplyOrDivide = tokens.some(
+                t => t.type === 'operator' && (t.value === '*' || t.value === '/'),
+            );
+            if (hasMultiplyOrDivide) {
+                errors.push(
+                    'Multiply (*) and divide (/) operators cannot be used with date fields. Only +, -, and parentheses are allowed.',
+                );
+            }
+            const hasLargeNumber = tokens.some(
+                t => t.type === 'number' && Math.abs(Number(t.value)) > MAX_DATE_CALC_DAYS,
+            );
+            if (hasLargeNumber) {
+                errors.push(
+                    `Number of days cannot exceed ${MAX_DATE_CALC_DAYS} in date calculations.`,
+                );
+            }
+        }
+    }
+
     return {
         valid: errors.length === 0,
         errors,

package/src/utils/shared/date.utils.ts

@@ -0,0 +1,6 @@
+export const dateToUtcZero = (dateString: string): string => {
+    const [year, month, day] = dateString.split('-').map(Number);
+    const utcDate = new Date(Date.UTC(year, month - 1, day));
+
+    return utcDate.toISOString();
+};

package/src/utils/shared/index.ts

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

package/dist/utils/formula/referenced-paths.utils.d.ts

@@ -1,7 +0,0 @@
-import { StructuredFormula } from '../../interface/types';
-/**
- * Returns the set of data model field paths referenced in the formula.
- * Used for recalculation scope: only these fields should trigger formula updates.
- */
-export declare function getReferencedPaths(formula: StructuredFormula | undefined | null): string[];
-//# sourceMappingURL=referenced-paths.utils.d.ts.map

package/dist/utils/formula/referenced-paths.utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"referenced-paths.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/formula/referenced-paths.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,EAAE,CAW1F"}

package/dist/utils/formula/referenced-paths.utils.js

@@ -1,18 +0,0 @@
-/**
- * Returns the set of data model field paths referenced in the formula.
- * Used for recalculation scope: only these fields should trigger formula updates.
- */
-export function getReferencedPaths(formula) {
-    var _a;
-    if (!((_a = formula === null || formula === void 0 ? void 0 : formula.tokens) === null || _a === void 0 ? void 0 : _a.length)) {
-        return [];
-    }
-    const paths = [];
-    for (const token of formula.tokens) {
-        if (token.type === 'field') {
-            paths.push(token.path);
-        }
-    }
-    return paths;
-}
-//# sourceMappingURL=referenced-paths.utils.js.map

package/dist/utils/formula/referenced-paths.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"referenced-paths.utils.js","sourceRoot":"","sources":["../../../src/utils/formula/referenced-paths.utils.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAAC,OAA6C;;IAC5E,IAAI,CAAC,CAAA,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,MAAM,0CAAE,MAAM,CAAA,EAAE,CAAC;QAC3B,OAAO,EAAE,CAAC;IACd,CAAC;IACD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;QACjC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YACzB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC3B,CAAC;IACL,CAAC;IACD,OAAO,KAAK,CAAC;AACjB,CAAC"}

package/dist/utils/formula/serialize-formula.utils.d.ts

@@ -1,14 +0,0 @@
-import { StructuredFormula } from '../../interface/types';
-export interface SerializedFormula {
-    v: number;
-    tokens: StructuredFormula['tokens'];
-}
-/**
- * Serialize structured formula for persistence (e.g. to JSON in store).
- */
-export declare function serializeFormula(formula: StructuredFormula): string;
-/**
- * Deserialize formula from persisted string. Returns null if invalid.
- */
-export declare function deserializeFormula(json: string): StructuredFormula | null;
-//# sourceMappingURL=serialize-formula.utils.d.ts.map

package/dist/utils/formula/serialize-formula.utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serialize-formula.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/formula/serialize-formula.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAI1D,MAAM,WAAW,iBAAiB;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC;CACvC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAMnE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAgBzE"}

package/dist/utils/formula/serialize-formula.utils.js

@@ -1,33 +0,0 @@
-const SERIALIZATION_VERSION = 1;
-/**
- * Serialize structured formula for persistence (e.g. to JSON in store).
- */
-export function serializeFormula(formula) {
-    const payload = {
-        v: SERIALIZATION_VERSION,
-        tokens: formula.tokens,
-    };
-    return JSON.stringify(payload);
-}
-/**
- * Deserialize formula from persisted string. Returns null if invalid.
- */
-export function deserializeFormula(json) {
-    if (!json || typeof json !== 'string') {
-        return null;
-    }
-    try {
-        const payload = JSON.parse(json);
-        if ((payload === null || payload === void 0 ? void 0 : payload.v) !== SERIALIZATION_VERSION || !Array.isArray(payload.tokens)) {
-            return null;
-        }
-        if (payload.tokens.length === 0) {
-            return { tokens: [] };
-        }
-        return { tokens: payload.tokens };
-    }
-    catch (_a) {
-        return null;
-    }
-}
-//# sourceMappingURL=serialize-formula.utils.js.map

package/dist/utils/formula/serialize-formula.utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"serialize-formula.utils.js","sourceRoot":"","sources":["../../../src/utils/formula/serialize-formula.utils.ts"],"names":[],"mappings":"AAEA,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAOhC;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAA0B;IACvD,MAAM,OAAO,GAAsB;QAC/B,CAAC,EAAE,qBAAqB;QACxB,MAAM,EAAE,OAAO,CAAC,MAAM;KACzB,CAAC;IACF,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AACnC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC3C,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QACpC,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,IAAI,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAsB,CAAC;QACtD,IAAI,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,CAAC,MAAK,qBAAqB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACzE,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;QAC1B,CAAC;QACD,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;IACtC,CAAC;IAAC,WAAM,CAAC;QACL,OAAO,IAAI,CAAC;IAChB,CAAC;AACL,CAAC"}

package/src/utils/formula/referenced-paths.utils.ts

@@ -1,18 +0,0 @@
-import { StructuredFormula } from '../../interface/types';
-
-/**
- * Returns the set of data model field paths referenced in the formula.
- * Used for recalculation scope: only these fields should trigger formula updates.
- */
-export function getReferencedPaths(formula: StructuredFormula | undefined | null): string[] {
-    if (!formula?.tokens?.length) {
-        return [];
-    }
-    const paths: string[] = [];
-    for (const token of formula.tokens) {
-        if (token.type === 'field') {
-            paths.push(token.path);
-        }
-    }
-    return paths;
-}