@servicetitan/dte-unlayer 0.94.0 → 0.95.0

package/dist/display-conditions/nunjucks.js

@@ -0,0 +1,448 @@
+import { generateId } from './constants';
+import { VALUE_LESS_OPERATORS } from './types';
+function escapeNunjucksString(s) {
+    return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+function nunjucksValueLiteral(value) {
+    return `'${escapeNunjucksString(value)}'`;
+}
+function isEscapedAt(s, index) {
+    let slashCount = 0;
+    for(let i = index - 1; i >= 0 && s[i] === '\\'; i--){
+        slashCount++;
+    }
+    return slashCount % 2 === 1;
+}
+function isValueLessOperator(operator) {
+    return VALUE_LESS_OPERATORS.includes(operator);
+}
+/**
+ * Build a single condition expression in Nunjucks.
+ * Wrapped in () so splitting never breaks composite expressions.
+ */ function buildSingleConditionExpression(dataPointKey, operator, value) {
+    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;
+    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) {
+    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) {
+    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) {
+    const parts = [];
+    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) {
+    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) {
+    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) {
+    const conditionExprs = [];
+    const operators = [];
+    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) {
+    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, dataPointKey, value, logicalOp) {
+    const condition = {
+        dataPointKey: dataPointKey.trim(),
+        id: generateId(),
+        operator,
+        value
+    };
+    if (logicalOp) {
+        condition.logicalOperator = logicalOp;
+    }
+    return condition;
+}
+function parseQuotedValue(s) {
+    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;
+}
+const PARSE_PATTERNS = [
+    // 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)=>{
+            var _parseQuotedValue;
+            var _parseQuotedValue_value;
+            return (_parseQuotedValue_value = (_parseQuotedValue = parseQuotedValue(m[2].trim())) === null || _parseQuotedValue === void 0 ? void 0 : _parseQuotedValue.value) !== null && _parseQuotedValue_value !== void 0 ? _parseQuotedValue_value : null;
+        },
+        operator: 'is_equal_to',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_STR_DEFAULT}\s*==\s+(.+)$`)
+    },
+    {
+        getValue: (m)=>{
+            var _parseQuotedValue;
+            var _parseQuotedValue_value;
+            return (_parseQuotedValue_value = (_parseQuotedValue = parseQuotedValue(m[2].trim())) === null || _parseQuotedValue === void 0 ? void 0 : _parseQuotedValue.value) !== null && _parseQuotedValue_value !== void 0 ? _parseQuotedValue_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)=>{
+            var _parseQuotedValue;
+            var _parseQuotedValue_value;
+            return (_parseQuotedValue_value = (_parseQuotedValue = parseQuotedValue(m[2].trim())) === null || _parseQuotedValue === void 0 ? void 0 : _parseQuotedValue.value) !== null && _parseQuotedValue_value !== void 0 ? _parseQuotedValue_value : null;
+        },
+        operator: 'starts_with',
+        pathGroup: 1,
+        pattern: new RegExp(String.raw`^${RE_STR_DEFAULT}\s*\|\s*startswith\s*\(\s*(.+)\s*\)\s*$`)
+    },
+    {
+        getValue: (m)=>{
+            var _parseQuotedValue;
+            var _parseQuotedValue_value;
+            return (_parseQuotedValue_value = (_parseQuotedValue = parseQuotedValue(m[2].trim())) === null || _parseQuotedValue === void 0 ? void 0 : _parseQuotedValue.value) !== null && _parseQuotedValue_value !== void 0 ? _parseQuotedValue_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, logicalOp) {
+    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) {
+    const { conditionExprs, operators } = tokenizeGroupExpression(groupExpr);
+    const conditions = [];
+    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) {
+    if (!(condition === null || condition === void 0 ? void 0 : 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 = 'show';
+    if (expr.startsWith('not (') && expr.endsWith(')')) {
+        behavior = 'hide';
+        expr = expr.slice(5, -1).trim();
+    }
+    const { conditionExprs: ruleStrings, operators: groupOperators } = tokenizeGroupExpression(expr);
+    const groups = [];
+    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 = {
+                conditions,
+                id: generateId()
+            };
+            if (i > 0) {
+                var _groupOperators_;
+                group.logicalOperator = (_groupOperators_ = groupOperators[i - 1]) !== null && _groupOperators_ !== void 0 ? _groupOperators_ : 'and';
+            }
+            groups.push(group);
+        }
+    }
+    if (groups.length === 0) {
+        return null;
+    }
+    return {
+        behavior,
+        groups
+    };
+}
+
+//# sourceMappingURL=nunjucks.js.map

package/dist/display-conditions/nunjucks.js.map

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

package/dist/display-conditions/schemaDataPoints.d.ts

@@ -0,0 +1,4 @@
+import { SchemaObject } from '../shared/schema';
+import { DataPointOption } from './types';
+export declare function getSchemaDataPointOptions(schema: SchemaObject | undefined): DataPointOption[];
+//# sourceMappingURL=schemaDataPoints.d.ts.map

package/dist/display-conditions/schemaDataPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaDataPoints.d.ts","sourceRoot":"","sources":["../../src/display-conditions/schemaDataPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,YAAY,EAGf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAQ1C,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,GAAG,eAAe,EAAE,CAkB7F"}

package/dist/display-conditions/schemaDataPoints.js

@@ -0,0 +1,18 @@
+import { schemaBuildMap, schemaIsNumber } from '../shared/schema';
+function isUseInConditionals(node) {
+    var _node_options, _node_options1;
+    return (node === null || node === void 0 ? void 0 : (_node_options = node.options) === null || _node_options === void 0 ? void 0 : _node_options.useInConditionals) === true || (node === null || node === void 0 ? void 0 : (_node_options1 = node.options) === null || _node_options1 === void 0 ? void 0 : _node_options1.useInCalculatedFields) === true;
+}
+export function getSchemaDataPointOptions(schema) {
+    if (!(schema === null || schema === void 0 ? void 0 : schema.properties)) {
+        return [];
+    }
+    const { map } = schemaBuildMap(schema);
+    return Object.values(map).filter((f)=>f.isValue && !f.isArrayed && isUseInConditionals(f.node)).map((f)=>({
+            fieldType: schemaIsNumber(f.node) ? 'number' : 'string',
+            fullKey: f.fullKey,
+            title: f.fullTitle || f.title || f.fullKey
+        })).sort((a, b)=>a.title.localeCompare(b.title));
+}
+
+//# sourceMappingURL=schemaDataPoints.js.map

package/dist/display-conditions/schemaDataPoints.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/display-conditions/schemaDataPoints.ts"],"sourcesContent":["import {\n    SchemaFieldBaseOptions,\n    SchemaObject,\n    schemaBuildMap,\n    schemaIsNumber,\n} from '../shared/schema';\nimport { DataPointOption } from './types';\n\nfunction isUseInConditionals(node: { options?: SchemaFieldBaseOptions } | undefined): boolean {\n    return (\n        node?.options?.useInConditionals === true || node?.options?.useInCalculatedFields === true\n    );\n}\n\nexport function getSchemaDataPointOptions(schema: SchemaObject | undefined): DataPointOption[] {\n    if (!schema?.properties) {\n        return [];\n    }\n    const { map } = schemaBuildMap(schema);\n    return Object.values(map)\n        .filter(\n            f =>\n                f.isValue &&\n                !f.isArrayed &&\n                isUseInConditionals(f.node as { options?: SchemaFieldBaseOptions }),\n        )\n        .map(f => ({\n            fieldType: schemaIsNumber(f.node) ? ('number' as const) : ('string' as const),\n            fullKey: f.fullKey,\n            title: f.fullTitle || f.title || f.fullKey,\n        }))\n        .sort((a, b) => a.title.localeCompare(b.title));\n}\n"],"names":["schemaBuildMap","schemaIsNumber","isUseInConditionals","node","options","useInConditionals","useInCalculatedFields","getSchemaDataPointOptions","schema","properties","map","Object","values","filter","f","isValue","isArrayed","fieldType","fullKey","title","fullTitle","sort","a","b","localeCompare"],"mappings":"AAAA,SAGIA,cAAc,EACdC,cAAc,QACX,mBAAmB;AAG1B,SAASC,oBAAoBC,IAAsD;QAE3EA,eAA6CA;IADjD,OACIA,CAAAA,iBAAAA,4BAAAA,gBAAAA,KAAMC,OAAO,cAAbD,oCAAAA,cAAeE,iBAAiB,MAAK,QAAQF,CAAAA,iBAAAA,4BAAAA,iBAAAA,KAAMC,OAAO,cAAbD,qCAAAA,eAAeG,qBAAqB,MAAK;AAE9F;AAEA,OAAO,SAASC,0BAA0BC,MAAgC;IACtE,IAAI,EAACA,mBAAAA,6BAAAA,OAAQC,UAAU,GAAE;QACrB,OAAO,EAAE;IACb;IACA,MAAM,EAAEC,GAAG,EAAE,GAAGV,eAAeQ;IAC/B,OAAOG,OAAOC,MAAM,CAACF,KAChBG,MAAM,CACHC,CAAAA,IACIA,EAAEC,OAAO,IACT,CAACD,EAAEE,SAAS,IACZd,oBAAoBY,EAAEX,IAAI,GAEjCO,GAAG,CAACI,CAAAA,IAAM,CAAA;YACPG,WAAWhB,eAAea,EAAEX,IAAI,IAAK,WAAsB;YAC3De,SAASJ,EAAEI,OAAO;YAClBC,OAAOL,EAAEM,SAAS,IAAIN,EAAEK,KAAK,IAAIL,EAAEI,OAAO;QAC9C,CAAA,GACCG,IAAI,CAAC,CAACC,GAAGC,IAAMD,EAAEH,KAAK,CAACK,aAAa,CAACD,EAAEJ,KAAK;AACrD"}