@servicetitan/dte-pdf-editor 1.87.0 → 1.89.0

package/src/utils/conditions/condition-match-type.utils.ts

@@ -0,0 +1,80 @@
+import type {
+    DataPointOption,
+    DisplayConditionGroup,
+    DisplayConditionState,
+    FormFieldsByFormIdI,
+} from '../../interface/types';
+import { getDisplayConditionFieldTypeForKey } from '../formula';
+import { isValidNumber } from '../shared';
+
+export type ConditionMatchType = 'and' | 'or';
+
+/** Derives All/Any (and/or) toggle value from the operators already stored on a condition state. */
+export const deriveConditionMatchType = (
+    conditionState: DisplayConditionState,
+): ConditionMatchType => {
+    for (let g = 0; g < conditionState.groups.length; g++) {
+        const group = conditionState.groups[g];
+        if (g > 0 && group.logicalOperator === 'or') {
+            return 'or';
+        }
+        for (let i = 1; i < group.conditions.length; i++) {
+            if (group.conditions[i]?.logicalOperator === 'or') {
+                return 'or';
+            }
+        }
+    }
+    return 'and';
+};
+
+/** Stamps the given All/Any (and/or) value onto every group/condition after the first in each. */
+export const applyConditionMatchType = (
+    conditionState: DisplayConditionState,
+    matchType: ConditionMatchType,
+): DisplayConditionState => ({
+    ...conditionState,
+    groups: conditionState.groups.map((group, groupIndex) => ({
+        ...group,
+        ...(groupIndex > 0 ? { logicalOperator: matchType } : {}),
+        conditions: group.conditions.map((c, i) =>
+            i === 0 ? { ...c, logicalOperator: undefined } : { ...c, logicalOperator: matchType },
+        ),
+    })),
+});
+
+export interface ConditionValidationDeps {
+    mergeTagOptions: DataPointOption[];
+    fillableOptions: DataPointOption[];
+    formFieldsByFormId?: FormFieldsByFormIdI;
+}
+
+/** True when every condition in every group has a data point and a usable value for its type. */
+export const isValidConditionGroups = (
+    groups: DisplayConditionGroup[],
+    { fillableOptions, formFieldsByFormId, mergeTagOptions }: ConditionValidationDeps,
+): boolean => {
+    for (const group of groups) {
+        for (const condition of group.conditions) {
+            if (!condition.dataPointKey) {
+                return false;
+            }
+            if (condition.operator === 'is_empty' || condition.operator === 'is_not_empty') {
+                continue;
+            }
+            const trimmedValue = condition.value.trim();
+            if (!trimmedValue) {
+                return false;
+            }
+            const fieldType = getDisplayConditionFieldTypeForKey(
+                condition.dataPointKey,
+                mergeTagOptions,
+                fillableOptions,
+                formFieldsByFormId ?? {},
+            );
+            if (fieldType === 'number' && !isValidNumber(trimmedValue)) {
+                return false;
+            }
+        }
+    }
+    return groups.length > 0;
+};

package/src/utils/conditions/e-sign-offset-rules.utils.ts

@@ -0,0 +1,61 @@
+import { defaultGroup } from '../../constants';
+import type {
+    ESignDateSignedOffsetSettings,
+    ESignDateSignedOffsetSettingsRule,
+} from '../../interface/types';
+
+/**
+ * Product limit: rules (the conditioned rules managed here, plus the trailing else row that
+ * lives outside this array) may not exceed this total.
+ */
+export const MAX_ESIGN_OFFSET_RULES = 5;
+
+export const createESignOffsetRule = (): ESignDateSignedOffsetSettingsRule => ({
+    days: 0,
+    condition: { behavior: 'show', groups: [defaultGroup()] },
+});
+
+/** Same single blank rule shown when the user first clicks Set Date Rule. */
+export const createInitialESignOffsetRules = (): ESignDateSignedOffsetSettingsRule[] => {
+    return [createESignOffsetRule()];
+};
+
+export const canAddESignOffsetRule = (rules: ESignDateSignedOffsetSettingsRule[]): boolean =>
+    rules.length < MAX_ESIGN_OFFSET_RULES - 1;
+
+/** Appends a new rule. No-op past the max. */
+export const addESignOffsetRule = (
+    rules: ESignDateSignedOffsetSettingsRule[],
+): ESignDateSignedOffsetSettingsRule[] =>
+    canAddESignOffsetRule(rules) ? [...rules, createESignOffsetRule()] : rules;
+
+export const updateESignOffsetRule = (
+    rules: ESignDateSignedOffsetSettingsRule[],
+    index: number,
+    rule: ESignDateSignedOffsetSettingsRule,
+): ESignDateSignedOffsetSettingsRule[] => {
+    const next = [...rules];
+    next[index] = rule;
+    return next;
+};
+
+export const removeESignOffsetRule = (
+    rules: ESignDateSignedOffsetSettingsRule[],
+    index: number,
+): ESignDateSignedOffsetSettingsRule[] => {
+    return rules.filter((_, i) => i !== index);
+};
+
+export const createClearedESignOffsetSettings = (): ESignDateSignedOffsetSettings => {
+    return {
+        rules: [{ days: 0 }],
+    };
+};
+
+export const getESignOffsetRulesForSave = (
+    rules: ESignDateSignedOffsetSettingsRule[],
+    hasClearedRules: boolean,
+    hasConfiguredRules: boolean,
+): ESignDateSignedOffsetSettingsRule[] => {
+    return hasClearedRules && !hasConfiguredRules ? [] : rules;
+};

package/src/utils/conditions/index.ts

@@ -1,2 +1,4 @@
+export * from './condition-match-type.utils';
+export * from './e-sign-offset-rules.utils';
 export * from './evaluate.utils';
 export * from './schema-data-points.utils';