@servicetitan/dte-unlayer 0.94.0 → 0.96.0

package/src/display-conditions/nunjucks.ts

@@ -0,0 +1,503 @@
+import { generateId } from './constants';
+import {
+    ConditionGroup,
+    ConditionOperator,
+    DisplayBehavior,
+    DisplayConditionState,
+    LogicalOperator,
+    SingleCondition,
+    UnlayerDisplayCondition,
+    VALUE_LESS_OPERATORS,
+} from './types';
+
+function escapeNunjucksString(s: string): string {
+    return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+
+function nunjucksValueLiteral(value: string): string {
+    return `'${escapeNunjucksString(value)}'`;
+}
+
+function isEscapedAt(s: string, index: number): boolean {
+    let slashCount = 0;
+    for (let i = index - 1; i >= 0 && s[i] === '\\'; i--) {
+        slashCount++;
+    }
+    return slashCount % 2 === 1;
+}
+
+function isValueLessOperator(operator: string): boolean {
+    return VALUE_LESS_OPERATORS.includes(operator as ConditionOperator);
+}
+
+/**
+ * Build a single condition expression in Nunjucks.
+ * Wrapped in () so splitting never breaks composite expressions.
+ */
+function buildSingleConditionExpression(
+    dataPointKey: string,
+    operator: string,
+    value: string,
+): string {
+    const path = dataPointKey;
+    const defaulted = `(${path} | default(''))`;
+    const numDefaulted = `(${path} | default(0))`;
+    const normalizedValue = value.trim();
+    const literal = normalizedValue ? nunjucksValueLiteral(normalizedValue) : "''";
+    const numLiteral =
+        /^-?(?:\d+\.?\d*|\.\d+)$/.test(normalizedValue) && normalizedValue !== '-'
+            ? normalizedValue
+            : '0';
+    let inner: string;
+
+    switch (operator) {
+        case 'is_equal_to':
+            inner = `${defaulted} == ${literal}`;
+            break;
+        case 'is_not_equal_to':
+            inner = `${defaulted} != ${literal}`;
+            break;
+        case 'contains':
+            inner = `${literal} in ${defaulted}`;
+            break;
+        case 'does_not_contain':
+            inner = `not (${literal} in ${defaulted})`;
+            break;
+        case 'starts_with':
+            inner = `(${defaulted} | startswith(${literal}))`;
+            break;
+        case 'ends_with':
+            inner = `(${defaulted} | endswith(${literal}))`;
+            break;
+        case 'is_empty':
+            inner = `${defaulted} == '' or (${defaulted} | length) == 0`;
+            break;
+        case 'is_not_empty':
+            inner = `${defaulted} != '' and (${defaulted} | length) > 0`;
+            break;
+        case 'num_eq':
+            inner = `${numDefaulted} == ${numLiteral}`;
+            break;
+        case 'num_neq':
+            inner = `${numDefaulted} != ${numLiteral}`;
+            break;
+        case 'num_gt':
+            inner = `${numDefaulted} > ${numLiteral}`;
+            break;
+        case 'num_lt':
+            inner = `${numDefaulted} < ${numLiteral}`;
+            break;
+        case 'num_gte':
+            inner = `${numDefaulted} >= ${numLiteral}`;
+            break;
+        case 'num_lte':
+            inner = `${numDefaulted} <= ${numLiteral}`;
+            break;
+        default:
+            inner = `${defaulted} == ${literal}`;
+    }
+    return `(${inner})`;
+}
+
+/**
+ * Build group expression. Each condition is connected by its own logical operator.
+ * E.g. (cond1) and (cond2) or (cond3)
+ */
+function buildGroupExpression(group: ConditionGroup): string {
+    const valid = group.conditions.filter(
+        c => c.dataPointKey && (isValueLessOperator(c.operator) || c.value.trim() !== ''),
+    );
+    if (valid.length === 0) {
+        return '';
+    }
+    let result = buildSingleConditionExpression(
+        valid[0].dataPointKey,
+        valid[0].operator,
+        valid[0].value,
+    );
+    for (let i = 1; i < valid.length; i++) {
+        const joiner = valid[i].logicalOperator === 'or' ? ' or ' : ' and ';
+        result +=
+            joiner +
+            buildSingleConditionExpression(
+                valid[i].dataPointKey,
+                valid[i].operator,
+                valid[i].value,
+            );
+    }
+    // Wrap group in parens so top-level rule AND split works cleanly
+    return valid.length > 1 ? `(${result})` : result;
+}
+
+/**
+ * Build full condition expression.
+ * Rules (groups) are connected by each group's logical operator.
+ * hide behavior wraps everything in not().
+ */
+function buildFullConditionExpression(state: DisplayConditionState): string {
+    const validGroups = state.groups
+        .map(group => ({ expression: buildGroupExpression(group), group }))
+        .filter(item => !!item.expression);
+    if (validGroups.length === 0) {
+        return '';
+    }
+    let combined = validGroups[0].expression;
+    for (let i = 1; i < validGroups.length; i++) {
+        const joiner = validGroups[i].group.logicalOperator === 'or' ? ' or ' : ' and ';
+        combined += `${joiner}${validGroups[i].expression}`;
+    }
+    if (state.behavior === 'hide') {
+        return `not (${combined})`;
+    }
+    return combined;
+}
+
+function generateTypeAndLabel(state: DisplayConditionState): { type: string; label: string } {
+    const parts: string[] = [];
+    for (const group of state.groups) {
+        for (const c of group.conditions) {
+            if (!c.dataPointKey) {
+                continue;
+            }
+            if (isValueLessOperator(c.operator)) {
+                parts.push(`${c.dataPointKey} ${c.operator}`);
+            } else if (c.value.trim()) {
+                parts.push(`${c.dataPointKey} ${c.operator} ${c.value.trim()}`);
+            }
+        }
+    }
+    const summary = parts.slice(0, 2).join('; ') + (parts.length > 2 ? '…' : '');
+    const type = state.behavior === 'show' ? 'Display when' : 'Hide when';
+    const label = summary || (state.behavior === 'show' ? 'Show when' : 'Hide when');
+    return { type, label };
+}
+
+export function buildUnlayerDisplayCondition(
+    state: DisplayConditionState,
+): UnlayerDisplayCondition | null {
+    const expr = buildFullConditionExpression(state);
+    if (!expr) {
+        return null;
+    }
+    const before = `{% if ${expr} %}`;
+    const after = '{% endif %}';
+    const { label, type } = generateTypeAndLabel(state);
+    const description = state.groups.length > 1 ? `${state.groups.length} rules` : undefined;
+    return { after, before, description, label, type };
+}
+
+/*
+ * ---------------------------------------------------------------------------
+ * Parse helpers
+ * ---------------------------------------------------------------------------
+ */
+
+function stripOuterParens(s: string): string {
+    const t = s.trim();
+    if (t.length < 2 || !t.startsWith('(') || t.at(-1) !== ')') {
+        return t;
+    }
+    let depth = 1;
+    for (let i = 1; i < t.length - 1; i++) {
+        if (t[i] === '(') {
+            depth++;
+        } else if (t[i] === ')') {
+            depth--;
+            if (depth === 0) {
+                return t;
+            }
+        }
+    }
+    return depth === 1 ? t.slice(1, -1).trim() : t;
+}
+
+/**
+ * Tokenize an expression into alternating tokens of (expr, operator).
+ * Returns: [expr, 'and'|'or', expr, 'and'|'or', expr, ...]
+ *
+ * This scans for top-level " and " / " or " while respecting parens,
+ * and records which separator was found between each pair.
+ */
+function tokenizeGroupExpression(expr: string): {
+    conditionExprs: string[];
+    operators: LogicalOperator[];
+} {
+    const conditionExprs: string[] = [];
+    const operators: LogicalOperator[] = [];
+    let depth = 0;
+    let inSingleQuote = false;
+    let start = 0;
+
+    for (let i = 0; i < expr.length; i++) {
+        const c = expr[i];
+        if (c === "'" && !isEscapedAt(expr, i)) {
+            inSingleQuote = !inSingleQuote;
+        } else if (!inSingleQuote && c === '(') {
+            depth++;
+        } else if (!inSingleQuote && c === ')') {
+            depth = Math.max(0, depth - 1);
+        } else if (!inSingleQuote && depth === 0) {
+            // Check for " and " or " or " at this position
+            if (expr.slice(i, i + 5) === ' and ') {
+                conditionExprs.push(expr.slice(start, i).trim());
+                operators.push('and');
+                start = i + 5;
+                i += 4;
+                continue;
+            }
+            if (expr.slice(i, i + 4) === ' or ') {
+                conditionExprs.push(expr.slice(start, i).trim());
+                operators.push('or');
+                start = i + 4;
+                i += 3;
+                continue;
+            }
+        }
+    }
+    conditionExprs.push(expr.slice(start).trim());
+    return { conditionExprs, operators };
+}
+
+function unescapeNunjucksString(s: string): string {
+    return s.replaceAll('\\\\', '\\').replaceAll(String.raw`\'`, "'");
+}
+
+const RE_STR_DEFAULT = String.raw`\(([\w.]+)\s*\|\s*default\s*\(\s*''\s*\)\)`;
+const RE_NUM_DEFAULT = String.raw`\(([\w.]+)\s*\|\s*default\s*\(\s*0\s*\)\)`;
+const QUOTED_CONTENT = String.raw`((?:[^'\\]|\\.)*)`;
+
+function toSingleCondition(
+    operator: ConditionOperator,
+    dataPointKey: string,
+    value: string,
+    logicalOp?: LogicalOperator,
+): SingleCondition {
+    const condition: SingleCondition = {
+        dataPointKey: dataPointKey.trim(),
+        id: generateId(),
+        operator,
+        value,
+    };
+    if (logicalOp) {
+        condition.logicalOperator = logicalOp;
+    }
+    return condition;
+}
+
+function parseQuotedValue(s: string): { value: string; rest: string } | null {
+    if (!s.startsWith("'")) {
+        return null;
+    }
+    let i = 1;
+    let value = '';
+    while (i < s.length) {
+        if (s[i] === '\\' && i + 1 < s.length) {
+            value += s[i + 1] === "'" ? "'" : s[i + 1];
+            i += 2;
+            continue;
+        }
+        if (s[i] === "'") {
+            return { rest: s.slice(i + 1).trim(), value: unescapeNunjucksString(value) };
+        }
+        value += s[i];
+        i++;
+    }
+    return null;
+}
+
+interface ParsePattern {
+    getValue: (match: RegExpMatchArray) => string | null;
+    operator: ConditionOperator;
+    pathGroup: number;
+    pattern: RegExp;
+}
+
+const PARSE_PATTERNS: ParsePattern[] = [
+    // value-less
+    {
+        getValue: () => '',
+        operator: 'is_empty',
+        pathGroup: 1,
+        pattern: new RegExp(
+            String.raw`^${RE_STR_DEFAULT}\s*==\s*''\s+or\s+\(\([\w.]+\s*\|\s*default\s*\(\s*''\s*\)\)\s*\|\s*length\)\s*==\s*0$`,
+        ),
+    },
+    {
+        getValue: () => '',
+        operator: 'is_not_empty',
+        pathGroup: 1,
+        pattern: new RegExp(
+            String.raw`^${RE_STR_DEFAULT}\s*!=\s*''\s+and\s+\(\([\w.]+\s*\|\s*default\s*\(\s*''\s*\)\)\s*\|\s*length\)\s*>\s*0$`,
+        ),
+    },
+    // string with value
+    {
+        getValue: m => parseQuotedValue(m[2].trim())?.value ?? null,
+        operator: 'is_equal_to',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_STR_DEFAULT}\s*==\s+(.+)$`),
+    },
+    {
+        getValue: m => parseQuotedValue(m[2].trim())?.value ?? null,
+        operator: 'is_not_equal_to',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_STR_DEFAULT}\s*!=\s+(.+)$`),
+    },
+    {
+        getValue: m => unescapeNunjucksString(m[1]),
+        operator: 'contains',
+        pathGroup: 2,
+        pattern: new RegExp(String.raw`^'${QUOTED_CONTENT}'\s+in\s+${RE_STR_DEFAULT}$`),
+    },
+    {
+        getValue: m => unescapeNunjucksString(m[1]),
+        operator: 'does_not_contain',
+        pathGroup: 2,
+        pattern: new RegExp(
+            String.raw`^not\s*\(\s*'${QUOTED_CONTENT}'\s+in\s+${RE_STR_DEFAULT}\s*\)\s*$`,
+        ),
+    },
+    {
+        getValue: m => parseQuotedValue(m[2].trim())?.value ?? null,
+        operator: 'starts_with',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_STR_DEFAULT}\s*\|\s*startswith\s*\(\s*(.+)\s*\)\s*$`),
+    },
+    {
+        getValue: m => parseQuotedValue(m[2].trim())?.value ?? null,
+        operator: 'ends_with',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_STR_DEFAULT}\s*\|\s*endswith\s*\(\s*(.+)\s*\)\s*$`),
+    },
+    // number operators (>= and <= before > and < to avoid partial match)
+    {
+        getValue: m => m[2].trim(),
+        operator: 'num_gte',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_NUM_DEFAULT}\s*>=\s*(.+)$`),
+    },
+    {
+        getValue: m => m[2].trim(),
+        operator: 'num_lte',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_NUM_DEFAULT}\s*<=\s*(.+)$`),
+    },
+    {
+        getValue: m => m[2].trim(),
+        operator: 'num_eq',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_NUM_DEFAULT}\s*==\s*(.+)$`),
+    },
+    {
+        getValue: m => m[2].trim(),
+        operator: 'num_neq',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_NUM_DEFAULT}\s*!=\s*(.+)$`),
+    },
+    {
+        getValue: m => m[2].trim(),
+        operator: 'num_gt',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_NUM_DEFAULT}\s*>\s*(.+)$`),
+    },
+    {
+        getValue: m => m[2].trim(),
+        operator: 'num_lt',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_NUM_DEFAULT}\s*<\s*(.+)$`),
+    },
+];
+
+function parseSingleConditionExpression(
+    expr: string,
+    logicalOp?: LogicalOperator,
+): SingleCondition | null {
+    const trimmed = expr.trim();
+    for (const { getValue, operator, pathGroup, pattern } of PARSE_PATTERNS) {
+        const match = new RegExp(pattern).exec(trimmed);
+        if (!match) {
+            continue;
+        }
+        const value = getValue(match);
+        if (value === null) {
+            continue;
+        }
+        return toSingleCondition(operator, match[pathGroup], value, logicalOp);
+    }
+    return null;
+}
+
+/**
+ * Parse a group expression into conditions with per-condition logical operators.
+ */
+function parseGroupExpression(groupExpr: string): SingleCondition[] | null {
+    const { conditionExprs, operators } = tokenizeGroupExpression(groupExpr);
+    const conditions: SingleCondition[] = [];
+
+    for (let i = 0; i < conditionExprs.length; i++) {
+        const cs = conditionExprs[i];
+        if (!cs) {
+            continue;
+        }
+        const unwrapped = stripOuterParens(cs);
+        const logicalOp = i > 0 ? operators[i - 1] : undefined;
+        const single = parseSingleConditionExpression(unwrapped, logicalOp);
+        if (single) {
+            conditions.push(single);
+        }
+    }
+
+    return conditions.length > 0 ? conditions : null;
+}
+
+/**
+ * Parse a saved Unlayer display condition back into modal state for prefilling.
+ * Returns null if the condition is missing or cannot be parsed.
+ */
+export function parseUnlayerDisplayCondition(
+    condition: UnlayerDisplayCondition | null | undefined,
+): DisplayConditionState | null {
+    if (!condition?.before) {
+        return null;
+    }
+    const ifMatch = new RegExp(/\{%\s*if\s+(.+)\s*%\}/s).exec(condition.before);
+    if (!ifMatch) {
+        return null;
+    }
+    let expr = ifMatch[1].trim();
+
+    let behavior: DisplayBehavior = 'show';
+    if (expr.startsWith('not (') && expr.endsWith(')')) {
+        behavior = 'hide';
+        expr = expr.slice(5, -1).trim();
+    }
+
+    const { conditionExprs: ruleStrings, operators: groupOperators } =
+        tokenizeGroupExpression(expr);
+    const groups: ConditionGroup[] = [];
+
+    for (let i = 0; i < ruleStrings.length; i++) {
+        const rs = ruleStrings[i];
+        if (!rs) {
+            continue;
+        }
+        const unwrapped = stripOuterParens(rs);
+        const conditions = parseGroupExpression(unwrapped);
+        if (conditions) {
+            const group: ConditionGroup = {
+                conditions,
+                id: generateId(),
+            };
+            if (i > 0) {
+                group.logicalOperator = groupOperators[i - 1] ?? 'and';
+            }
+            groups.push(group);
+        }
+    }
+
+    if (groups.length === 0) {
+        return null;
+    }
+
+    return { behavior, groups };
+}

package/src/display-conditions/schemaDataPoints.ts

@@ -0,0 +1,33 @@
+import {
+    SchemaFieldBaseOptions,
+    SchemaObject,
+    schemaBuildMap,
+    schemaIsNumber,
+} from '../shared/schema';
+import { DataPointOption } from './types';
+
+function isUseInConditionals(node: { options?: SchemaFieldBaseOptions } | undefined): boolean {
+    return (
+        node?.options?.useInConditionals === true || node?.options?.useInCalculatedFields === true
+    );
+}
+
+export function getSchemaDataPointOptions(schema: SchemaObject | undefined): DataPointOption[] {
+    if (!schema?.properties) {
+        return [];
+    }
+    const { map } = schemaBuildMap(schema);
+    return Object.values(map)
+        .filter(
+            f =>
+                f.isValue &&
+                !f.isArrayed &&
+                isUseInConditionals(f.node as { options?: SchemaFieldBaseOptions }),
+        )
+        .map(f => ({
+            fieldType: schemaIsNumber(f.node) ? ('number' as const) : ('string' as const),
+            fullKey: f.fullKey,
+            title: f.fullTitle || f.title || f.fullKey,
+        }))
+        .sort((a, b) => a.title.localeCompare(b.title));
+}

package/src/display-conditions/types.ts

@@ -0,0 +1,75 @@
+/**
+ * Display condition types for the modal and Nunjucks generation.
+ */
+
+export type DisplayBehavior = 'show' | 'hide';
+
+export type LogicalOperator = 'and' | 'or';
+
+/** Operators for string-type fields. */
+export const STRING_OPERATORS = [
+    { label: 'Contains', value: 'contains' },
+    { label: 'Does not contain', value: 'does_not_contain' },
+    { label: 'Is equal to', value: 'is_equal_to' },
+    { label: 'Is not equal to', value: 'is_not_equal_to' },
+    { label: 'Starts with', value: 'starts_with' },
+    { label: 'Ends with', value: 'ends_with' },
+    { label: 'Is empty', value: 'is_empty' },
+    { label: 'Is not empty', value: 'is_not_empty' },
+] as const;
+
+/** Operators for number-type fields. */
+export const NUMBER_OPERATORS = [
+    { label: '== (equal to)', value: 'num_eq' },
+    { label: '!= (not equal to)', value: 'num_neq' },
+    { label: '> (greater than)', value: 'num_gt' },
+    { label: '< (less than)', value: 'num_lt' },
+    { label: '>= (greater than or equal to)', value: 'num_gte' },
+    { label: '<= (less than or equal to)', value: 'num_lte' },
+] as const;
+
+/** All operators combined for type definitions. */
+export const CONDITION_OPERATORS = [...STRING_OPERATORS, ...NUMBER_OPERATORS] as const;
+
+export type ConditionOperator =
+    | (typeof STRING_OPERATORS)[number]['value']
+    | (typeof NUMBER_OPERATORS)[number]['value'];
+
+/** Operators that do not require a value (empty/is not empty) */
+export const VALUE_LESS_OPERATORS: ConditionOperator[] = ['is_empty', 'is_not_empty'];
+
+export interface SingleCondition {
+    id: string;
+    dataPointKey: string;
+    /** How this condition connects to the PREVIOUS condition. Absent on the first condition. */
+    logicalOperator?: LogicalOperator;
+    operator: ConditionOperator;
+    value: string;
+}
+
+export interface ConditionGroup {
+    id: string;
+    /** How this group connects to the PREVIOUS group. Absent on the first group. */
+    logicalOperator?: LogicalOperator;
+    conditions: SingleCondition[];
+}
+
+export interface DisplayConditionState {
+    behavior: DisplayBehavior;
+    groups: ConditionGroup[];
+}
+
+export interface DataPointOption {
+    fieldType: 'number' | 'string';
+    fullKey: string;
+    title: string;
+}
+
+/** Unlayer display condition shape passed to done() */
+export interface UnlayerDisplayCondition {
+    type: string;
+    label: string;
+    description?: string;
+    before: string;
+    after: string;
+}