@masterteam/components 0.0.92 → 0.0.93

package/fesm2022/masterteam-components-formula.mjs

@@ -1920,11 +1920,995 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImpor
             args: [{ selector: 'mt-formula-status-bar', standalone: true, imports: [CommonModule], template: "<div\r\n  class=\"flex items-center gap-4 border-t border-slate-200 px-4 py-2 text-sm dark:border-slate-700\"\r\n>\r\n  <!-- Validation Status -->\r\n  <div class=\"flex items-center gap-1.5\">\r\n    @if (isValid()) {\r\n      <span\r\n        class=\"flex h-5 w-5 items-center justify-center rounded-full bg-emerald-100 text-emerald-600 dark:bg-emerald-900 dark:text-emerald-400\"\r\n      >\r\n        <svg\r\n          class=\"h-3.5 w-3.5\"\r\n          fill=\"none\"\r\n          viewBox=\"0 0 24 24\"\r\n          stroke=\"currentColor\"\r\n          stroke-width=\"2.5\"\r\n        >\r\n          <path\r\n            stroke-linecap=\"round\"\r\n            stroke-linejoin=\"round\"\r\n            d=\"M5 13l4 4L19 7\"\r\n          />\r\n        </svg>\r\n      </span>\r\n      <span class=\"font-medium text-emerald-600 dark:text-emerald-400\">\r\n        {{ labelValid() }}\r\n      </span>\r\n    } @else {\r\n      <span\r\n        class=\"flex h-5 w-5 items-center justify-center rounded-full bg-rose-100 text-rose-600 dark:bg-rose-900 dark:text-rose-400\"\r\n      >\r\n        <svg\r\n          class=\"h-3.5 w-3.5\"\r\n          fill=\"none\"\r\n          viewBox=\"0 0 24 24\"\r\n          stroke=\"currentColor\"\r\n          stroke-width=\"2.5\"\r\n        >\r\n          <path\r\n            stroke-linecap=\"round\"\r\n            stroke-linejoin=\"round\"\r\n            d=\"M6 18L18 6M6 6l12 12\"\r\n          />\r\n        </svg>\r\n      </span>\r\n      <span class=\"font-medium text-rose-600 dark:text-rose-400\">\r\n        {{ labelInvalid() }}\r\n      </span>\r\n    }\r\n  </div>\r\n\r\n  <!-- Separator -->\r\n  <div class=\"h-4 w-px bg-slate-300 dark:bg-slate-600\"></div>\r\n\r\n  <!-- Complexity -->\r\n  <div class=\"flex items-center gap-1.5 text-slate-500 dark:text-slate-400\">\r\n    <svg class=\"h-4 w-4\" fill=\"none\" viewBox=\"0 0 24 24\" stroke=\"currentColor\">\r\n      <path\r\n        stroke-linecap=\"round\"\r\n        stroke-linejoin=\"round\"\r\n        stroke-width=\"2\"\r\n        d=\"M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z\"\r\n      />\r\n    </svg>\r\n    <span>{{ labelComplexity() }}:</span>\r\n    <span class=\"font-medium\" [class]=\"complexityClass()\">\r\n      {{ complexity() }}\r\n    </span>\r\n  </div>\r\n\r\n  <!-- Dependencies -->\r\n  @if (dependencies().length > 0) {\r\n    <div class=\"h-4 w-px bg-slate-300 dark:bg-slate-600\"></div>\r\n    <div class=\"flex items-center gap-1.5 text-slate-500 dark:text-slate-400\">\r\n      <svg\r\n        class=\"h-4 w-4\"\r\n        fill=\"none\"\r\n        viewBox=\"0 0 24 24\"\r\n        stroke=\"currentColor\"\r\n      >\r\n        <path\r\n          stroke-linecap=\"round\"\r\n          stroke-linejoin=\"round\"\r\n          stroke-width=\"2\"\r\n          d=\"M13.828 10.172a4 4 0 00-5.656 0l-4 4a4 4 0 105.656 5.656l1.102-1.101m-.758-4.899a4 4 0 005.656 0l4-4a4 4 0 00-5.656-5.656l-1.1 1.1\"\r\n        />\r\n      </svg>\r\n      <span>{{ labelDependencies() }}:</span>\r\n      <span class=\"font-medium text-slate-700 dark:text-slate-300\">\r\n        {{ dependenciesText() }}\r\n      </span>\r\n    </div>\r\n  }\r\n\r\n  <!-- Error message (if any) -->\r\n  @if (firstError(); as error) {\r\n    <div\r\n      class=\"ms-auto flex items-center gap-1.5 text-rose-600 dark:text-rose-400\"\r\n    >\r\n      <svg\r\n        class=\"h-4 w-4\"\r\n        fill=\"none\"\r\n        viewBox=\"0 0 24 24\"\r\n        stroke=\"currentColor\"\r\n      >\r\n        <path\r\n          stroke-linecap=\"round\"\r\n          stroke-linejoin=\"round\"\r\n          stroke-width=\"2\"\r\n          d=\"M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z\"\r\n        />\r\n      </svg>\r\n      <span class=\"text-xs\">{{ error.message }}</span>\r\n      <span class=\"text-xs opacity-60\"\r\n        >({{ error.line }}:{{ error.column }})</span\r\n      >\r\n    </div>\r\n  }\r\n</div>\r\n" }]
         }], propDecorators: { validation: [{ type: i0.Input, args: [{ isSignal: true, alias: "validation", required: false }] }], labels: [{ type: i0.Input, args: [{ isSignal: true, alias: "labels", required: false }] }] } });
 
+const CONDITION_FUNCTION_CATEGORIES = [
+    {
+        name: 'Logic',
+        displayName: 'Field Visibility',
+        functions: [
+            {
+                name: 'SHOW_IF',
+                category: 'Logic',
+                description: 'Show this field when condition is true',
+                signature: 'SHOW_IF(condition)',
+                parameters: [
+                    {
+                        name: 'condition',
+                        type: 'boolean',
+                        description: 'When true, field is visible',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['SHOW_IF(@Status == "Active")'],
+            },
+            {
+                name: 'HIDE_IF',
+                category: 'Logic',
+                description: 'Hide this field when condition is true',
+                signature: 'HIDE_IF(condition)',
+                parameters: [
+                    {
+                        name: 'condition',
+                        type: 'boolean',
+                        description: 'When true, field is hidden',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['HIDE_IF(@Status == "Closed")'],
+            },
+            {
+                name: 'DISABLE_IF',
+                category: 'Logic',
+                description: 'Disable this field when condition is true',
+                signature: 'DISABLE_IF(condition)',
+                parameters: [
+                    {
+                        name: 'condition',
+                        type: 'boolean',
+                        description: 'When true, field is disabled',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['DISABLE_IF(@Status == "Approved")'],
+            },
+            {
+                name: 'ENABLE_IF',
+                category: 'Logic',
+                description: 'Enable this field when condition is true',
+                signature: 'ENABLE_IF(condition)',
+                parameters: [
+                    {
+                        name: 'condition',
+                        type: 'boolean',
+                        description: 'When true, field is enabled',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['ENABLE_IF(@Status == "Draft")'],
+            },
+        ],
+    },
+    {
+        name: 'Aggregation',
+        displayName: 'Logic Helpers',
+        functions: [
+            {
+                name: 'AND',
+                category: 'Aggregation',
+                description: 'Returns true if all conditions are true',
+                signature: 'AND(condition1, condition2)',
+                parameters: [
+                    {
+                        name: 'condition1',
+                        type: 'boolean',
+                        description: 'First condition',
+                        required: true,
+                    },
+                    {
+                        name: 'condition2',
+                        type: 'boolean',
+                        description: 'Second condition',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['AND(@Status == "Active", @Priority > 0)'],
+            },
+            {
+                name: 'OR',
+                category: 'Aggregation',
+                description: 'Returns true if any condition is true',
+                signature: 'OR(condition1, condition2)',
+                parameters: [
+                    {
+                        name: 'condition1',
+                        type: 'boolean',
+                        description: 'First condition',
+                        required: true,
+                    },
+                    {
+                        name: 'condition2',
+                        type: 'boolean',
+                        description: 'Second condition',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['OR(@Status == "Active", @Status == "Pending")'],
+            },
+            {
+                name: 'NOT',
+                category: 'Aggregation',
+                description: 'Returns the opposite of the condition',
+                signature: 'NOT(condition)',
+                parameters: [
+                    {
+                        name: 'condition',
+                        type: 'boolean',
+                        description: 'Condition to negate',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['NOT(@IsCompleted)'],
+            },
+            {
+                name: 'ISNULL',
+                category: 'Aggregation',
+                description: 'Returns true if value is null or empty',
+                signature: 'ISNULL(value)',
+                parameters: [
+                    {
+                        name: 'value',
+                        type: 'any',
+                        description: 'Value to check',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['ISNULL(@Description)'],
+            },
+            {
+                name: 'CONTAINS',
+                category: 'Aggregation',
+                description: 'Returns true if text contains the search string',
+                signature: 'CONTAINS(text, search)',
+                parameters: [
+                    {
+                        name: 'text',
+                        type: 'string',
+                        description: 'Text to search in',
+                        required: true,
+                    },
+                    {
+                        name: 'search',
+                        type: 'string',
+                        description: 'String to search for',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['CONTAINS(@Name, "Project")'],
+            },
+        ],
+    },
+];
+const CONDITION_OPERATORS = [
+    { symbol: '==', name: 'Equal', type: 'comparison', description: 'Equal to', precedence: 3 },
+    { symbol: '!=', name: 'Not Equal', type: 'comparison', description: 'Not equal to', precedence: 3 },
+    { symbol: '>', name: 'Greater Than', type: 'comparison', description: 'Greater than', precedence: 4 },
+    { symbol: '<', name: 'Less Than', type: 'comparison', description: 'Less than', precedence: 4 },
+    { symbol: '>=', name: 'Greater or Equal', type: 'comparison', description: 'Greater than or equal', precedence: 4 },
+    { symbol: '<=', name: 'Less or Equal', type: 'comparison', description: 'Less than or equal', precedence: 4 },
+    { symbol: '&&', name: 'And', type: 'logical', description: 'Logical AND', precedence: 2 },
+    { symbol: '||', name: 'Or', type: 'logical', description: 'Logical OR', precedence: 1 },
+];
+const VALIDATION_FUNCTION_CATEGORIES = [
+    {
+        name: 'Validation',
+        displayName: 'Validation',
+        functions: [
+            {
+                name: 'REQUIRED',
+                category: 'Validation',
+                description: 'Returns true when value is not empty',
+                signature: 'REQUIRED(value)',
+                parameters: [
+                    {
+                        name: 'value',
+                        type: 'any',
+                        description: 'Value to check',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['REQUIRED(@Email)'],
+            },
+            {
+                name: 'ISNULL',
+                category: 'Validation',
+                description: 'Returns true if value is null or empty',
+                signature: 'ISNULL(value)',
+                parameters: [
+                    {
+                        name: 'value',
+                        type: 'any',
+                        description: 'Value to check',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['ISNULL(@Phone)'],
+            },
+            {
+                name: 'MIN_LENGTH',
+                category: 'Validation',
+                description: 'Returns true if value length is at least min',
+                signature: 'MIN_LENGTH(value, min)',
+                parameters: [
+                    {
+                        name: 'value',
+                        type: 'string',
+                        description: 'Value to check',
+                        required: true,
+                    },
+                    {
+                        name: 'min',
+                        type: 'number',
+                        description: 'Minimum length',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['MIN_LENGTH(@Password, 8)'],
+            },
+            {
+                name: 'MAX_LENGTH',
+                category: 'Validation',
+                description: 'Returns true if value length is at most max',
+                signature: 'MAX_LENGTH(value, max)',
+                parameters: [
+                    {
+                        name: 'value',
+                        type: 'string',
+                        description: 'Value to check',
+                        required: true,
+                    },
+                    {
+                        name: 'max',
+                        type: 'number',
+                        description: 'Maximum length',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['MAX_LENGTH(@Title, 120)'],
+            },
+            {
+                name: 'REGEX',
+                category: 'Validation',
+                description: 'Returns true if value matches regex pattern',
+                signature: 'REGEX(value, pattern)',
+                parameters: [
+                    {
+                        name: 'value',
+                        type: 'string',
+                        description: 'Value to check',
+                        required: true,
+                    },
+                    {
+                        name: 'pattern',
+                        type: 'string',
+                        description: 'Regex pattern',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['REGEX(@Email, "^[^@]+@[^@]+\\.[^@]+$")'],
+            },
+            {
+                name: 'BEFORE',
+                category: 'Validation',
+                description: 'Returns true if date is before reference date',
+                signature: 'BEFORE(date, reference)',
+                parameters: [
+                    {
+                        name: 'date',
+                        type: 'date',
+                        description: 'Date to check',
+                        required: true,
+                    },
+                    {
+                        name: 'reference',
+                        type: 'date',
+                        description: 'Reference date',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['BEFORE(@EndDate, @StartDate)'],
+            },
+            {
+                name: 'AFTER',
+                category: 'Validation',
+                description: 'Returns true if date is after reference date',
+                signature: 'AFTER(date, reference)',
+                parameters: [
+                    {
+                        name: 'date',
+                        type: 'date',
+                        description: 'Date to check',
+                        required: true,
+                    },
+                    {
+                        name: 'reference',
+                        type: 'date',
+                        description: 'Reference date',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['AFTER(@StartDate, @EndDate)'],
+            },
+        ],
+    },
+    {
+        name: 'Logic',
+        displayName: 'Logic Helpers',
+        functions: [
+            {
+                name: 'AND',
+                category: 'Logic',
+                description: 'Returns true if all conditions are true',
+                signature: 'AND(condition1, condition2)',
+                parameters: [
+                    {
+                        name: 'condition1',
+                        type: 'boolean',
+                        description: 'First condition',
+                        required: true,
+                    },
+                    {
+                        name: 'condition2',
+                        type: 'boolean',
+                        description: 'Second condition',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['AND(REQUIRED(@Email), REGEX(@Email, "^.+@.+$"))'],
+            },
+            {
+                name: 'OR',
+                category: 'Logic',
+                description: 'Returns true if any condition is true',
+                signature: 'OR(condition1, condition2)',
+                parameters: [
+                    {
+                        name: 'condition1',
+                        type: 'boolean',
+                        description: 'First condition',
+                        required: true,
+                    },
+                    {
+                        name: 'condition2',
+                        type: 'boolean',
+                        description: 'Second condition',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['OR(ISNULL(@Phone), REGEX(@Phone, "^\\+?[0-9]+$"))'],
+            },
+            {
+                name: 'NOT',
+                category: 'Logic',
+                description: 'Returns the opposite of a condition',
+                signature: 'NOT(condition)',
+                parameters: [
+                    {
+                        name: 'condition',
+                        type: 'boolean',
+                        description: 'Condition to negate',
+                        required: true,
+                    },
+                ],
+                returnType: 'boolean',
+                examples: ['NOT(ISNULL(@Password))'],
+            },
+        ],
+    },
+];
+const VALIDATION_OPERATORS = [
+    { symbol: '+', name: 'Add', type: 'arithmetic', description: 'Addition', precedence: 4 },
+    { symbol: '-', name: 'Subtract', type: 'arithmetic', description: 'Subtraction', precedence: 4 },
+    { symbol: '*', name: 'Multiply', type: 'arithmetic', description: 'Multiplication', precedence: 5 },
+    { symbol: '/', name: 'Divide', type: 'arithmetic', description: 'Division', precedence: 5 },
+    { symbol: '==', name: 'Equal', type: 'comparison', description: 'Equal to', precedence: 3 },
+    { symbol: '!=', name: 'Not Equal', type: 'comparison', description: 'Not equal to', precedence: 3 },
+    { symbol: '>', name: 'Greater Than', type: 'comparison', description: 'Greater than', precedence: 3 },
+    { symbol: '<', name: 'Less Than', type: 'comparison', description: 'Less than', precedence: 3 },
+    { symbol: '>=', name: 'Greater or Equal', type: 'comparison', description: 'Greater than or equal', precedence: 3 },
+    { symbol: '<=', name: 'Less or Equal', type: 'comparison', description: 'Less than or equal', precedence: 3 },
+    { symbol: '&&', name: 'And', type: 'logical', description: 'Logical AND', precedence: 2 },
+    { symbol: '||', name: 'Or', type: 'logical', description: 'Logical OR', precedence: 1 },
+];
+const CONDITION_RUNTIME_CATALOG = {
+    domain: 'condition',
+    functions: CONDITION_FUNCTION_CATEGORIES,
+    operators: CONDITION_OPERATORS,
+};
+const VALIDATION_RUNTIME_CATALOG = {
+    domain: 'validation',
+    functions: VALIDATION_FUNCTION_CATEGORIES,
+    operators: VALIDATION_OPERATORS,
+};
+
+const CONDITION_WRAPPER_NAMES = new Set([
+    'show',
+    'hide',
+    'enable',
+    'disable',
+]);
+const PROPERTY_PREFIXES = ['@', '*.', '$.'];
+class FormulaParser {
+    tokens;
+    current = 0;
+    dependencies = new Set();
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        const ast = this.expression();
+        this.consume('eof', 'Unexpected tokens after formula end');
+        const topLevelWrapper = ast.type === 'call' ? normalizeWrapperAction(ast.name) : null;
+        return {
+            ast,
+            dependencies: Array.from(this.dependencies),
+            topLevelWrapper,
+        };
+    }
+    expression() {
+        return this.logicalOr();
+    }
+    logicalOr() {
+        let expr = this.logicalAnd();
+        while (this.matchOperator('||')) {
+            const operator = this.previousOperator();
+            const right = this.logicalAnd();
+            expr = { type: 'binary', operator, left: expr, right };
+        }
+        return expr;
+    }
+    logicalAnd() {
+        let expr = this.equality();
+        while (this.matchOperator('&&')) {
+            const operator = this.previousOperator();
+            const right = this.equality();
+            expr = { type: 'binary', operator, left: expr, right };
+        }
+        return expr;
+    }
+    equality() {
+        let expr = this.comparison();
+        while (this.matchOperator('==', '!=')) {
+            const operator = this.previousOperator();
+            const right = this.comparison();
+            expr = { type: 'binary', operator, left: expr, right };
+        }
+        return expr;
+    }
+    comparison() {
+        let expr = this.addition();
+        while (this.matchOperator('>', '>=', '<', '<=')) {
+            const operator = this.previousOperator();
+            const right = this.addition();
+            expr = { type: 'binary', operator, left: expr, right };
+        }
+        return expr;
+    }
+    addition() {
+        let expr = this.multiplication();
+        while (this.matchOperator('+', '-')) {
+            const operator = this.previousOperator();
+            const right = this.multiplication();
+            expr = { type: 'binary', operator, left: expr, right };
+        }
+        return expr;
+    }
+    multiplication() {
+        let expr = this.unary();
+        while (this.matchOperator('*', '/')) {
+            const operator = this.previousOperator();
+            const right = this.unary();
+            expr = { type: 'binary', operator, left: expr, right };
+        }
+        return expr;
+    }
+    unary() {
+        if (this.matchOperator('!', '-')) {
+            const operator = this.previousOperator();
+            const right = this.unary();
+            return { type: 'unary', operator, right };
+        }
+        return this.primary();
+    }
+    primary() {
+        if (this.match('literal')) {
+            return { type: 'literal', value: this.previous().value };
+        }
+        if (this.match('property')) {
+            const token = this.previousProperty();
+            this.dependencies.add(token.value);
+            return { type: 'property', key: token.value, raw: token.raw };
+        }
+        if (this.match('identifier')) {
+            const name = this.previous().value;
+            if (!this.match('lparen')) {
+                throw new Error(`Expected "(" after function "${name}"`);
+            }
+            const args = [];
+            if (!this.check('rparen')) {
+                do {
+                    args.push(this.expression());
+                } while (this.match('comma'));
+            }
+            this.consume('rparen', `Expected ")" after function "${name}"`);
+            return { type: 'call', name, args };
+        }
+        if (this.match('lparen')) {
+            const expr = this.expression();
+            this.consume('rparen', 'Expected ")" after expression');
+            return expr;
+        }
+        throw new Error('Unexpected token while parsing formula');
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    previousProperty() {
+        return this.tokens[this.current - 1];
+    }
+    previousOperator() {
+        return this.tokens[this.current - 1].value;
+    }
+    consume(type, message) {
+        if (this.check(type)) {
+            this.advance();
+            return;
+        }
+        throw new Error(message);
+    }
+    match(type) {
+        if (!this.check(type))
+            return false;
+        this.advance();
+        return true;
+    }
+    matchOperator(...operators) {
+        if (!this.check('operator'))
+            return false;
+        const token = this.peek();
+        if (!operators.includes(token.value))
+            return false;
+        this.advance();
+        return true;
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return type === 'eof';
+        return this.peek().type === type;
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.current++;
+        return this.tokens[this.current - 1];
+    }
+    isAtEnd() {
+        return this.peek().type === 'eof';
+    }
+    peek() {
+        return this.tokens[this.current];
+    }
+}
+class FormulaRuntimeEngine {
+    compiledCache = new Map();
+    functionRegistry;
+    constructor(customFunctions) {
+        this.functionRegistry = {
+            ...buildDefaultFunctionRegistry(),
+            ...(customFunctions ?? {}),
+        };
+    }
+    evaluateCondition(config, context) {
+        try {
+            const compiled = this.getCompiledFormula(config.formulaTokens);
+            const rawValue = this.evaluateAst(compiled.ast, context.values);
+            const action = this.resolveConditionAction(config.mode, compiled);
+            const conditionValue = toBoolean(rawValue);
+            switch (action) {
+                case 'show':
+                    return {
+                        hidden: !conditionValue,
+                        dependencies: compiled.dependencies,
+                        errors: [],
+                    };
+                case 'hide':
+                    return {
+                        hidden: conditionValue,
+                        dependencies: compiled.dependencies,
+                        errors: [],
+                    };
+                case 'enable':
+                    return {
+                        disabled: !conditionValue,
+                        dependencies: compiled.dependencies,
+                        errors: [],
+                    };
+                case 'disable':
+                    return {
+                        disabled: conditionValue,
+                        dependencies: compiled.dependencies,
+                        errors: [],
+                    };
+                default:
+                    return {
+                        dependencies: compiled.dependencies,
+                        errors: [],
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                dependencies: [],
+                errors: [toErrorMessage(error)],
+            };
+        }
+    }
+    evaluateValidation(rule, context) {
+        try {
+            const compiled = this.getCompiledFormula(rule.formulaTokens);
+            const value = this.evaluateAst(compiled.ast, context.values);
+            return {
+                valid: toBoolean(value),
+                dependencies: compiled.dependencies,
+                errors: [],
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                dependencies: [],
+                errors: [toErrorMessage(error)],
+            };
+        }
+    }
+    extractDependencies(formulaTokens) {
+        try {
+            return this.getCompiledFormula(formulaTokens).dependencies;
+        }
+        catch {
+            return [];
+        }
+    }
+    resolveConditionAction(mode, compiled) {
+        if (mode && mode !== 'auto')
+            return mode;
+        return compiled.topLevelWrapper ?? 'show';
+    }
+    getCompiledFormula(formulaTokens) {
+        const key = formulaTokens?.trim();
+        if (!key) {
+            throw new Error('Formula tokens are empty');
+        }
+        const cached = this.compiledCache.get(key);
+        if (cached)
+            return cached;
+        const tokens = this.deserializeFormulaTokens(key);
+        const lexTokens = this.toLexTokens(tokens);
+        const compiled = new FormulaParser(lexTokens).parse();
+        this.compiledCache.set(key, compiled);
+        return compiled;
+    }
+    deserializeFormulaTokens(formulaTokens) {
+        let parsed;
+        try {
+            parsed = JSON.parse(formulaTokens);
+        }
+        catch {
+            throw new Error('Formula tokens JSON is invalid');
+        }
+        if (!Array.isArray(parsed)) {
+            throw new Error('Formula tokens must be an array');
+        }
+        return parsed;
+    }
+    toLexTokens(tokens) {
+        if (!tokens.length) {
+            throw new Error('Formula token array is empty');
+        }
+        const lex = [];
+        for (const token of tokens) {
+            switch (token.type) {
+                case 'fn-open': {
+                    const functionName = (token.functionName ?? token.value.replace(/\($/, '')).trim();
+                    if (!functionName) {
+                        throw new Error('Formula contains function token without a name');
+                    }
+                    lex.push({ type: 'identifier', value: functionName });
+                    lex.push({ type: 'lparen' });
+                    break;
+                }
+                case 'fn-close':
+                    lex.push({ type: 'rparen' });
+                    break;
+                case 'fn-separator':
+                    lex.push({ type: 'comma' });
+                    break;
+                case 'operator':
+                    lex.push({ type: 'operator', value: token.value });
+                    break;
+                case 'property':
+                    lex.push({
+                        type: 'property',
+                        value: normalizePropertyToken(token.value),
+                        raw: token.value,
+                    });
+                    break;
+                case 'literal':
+                    lex.push({ type: 'literal', value: parseLiteralTokenValue(token) });
+                    break;
+                default:
+                    throw new Error(`Unsupported formula token type: ${token.type}`);
+            }
+        }
+        lex.push({ type: 'eof' });
+        return lex;
+    }
+    evaluateAst(ast, values) {
+        switch (ast.type) {
+            case 'literal':
+                return ast.value;
+            case 'property':
+                return resolvePropertyValue(values, ast.key, ast.raw);
+            case 'unary': {
+                const right = this.evaluateAst(ast.right, values);
+                if (ast.operator === '!')
+                    return !toBoolean(right);
+                if (ast.operator === '-')
+                    return -toNumber(right);
+                throw new Error(`Unsupported unary operator: ${ast.operator}`);
+            }
+            case 'binary': {
+                const left = this.evaluateAst(ast.left, values);
+                const right = this.evaluateAst(ast.right, values);
+                return evaluateBinary(ast.operator, left, right);
+            }
+            case 'call': {
+                const fn = this.functionRegistry[ast.name.toUpperCase()];
+                if (!fn) {
+                    throw new Error(`Unsupported function: ${ast.name}`);
+                }
+                const args = ast.args.map((arg) => this.evaluateAst(arg, values));
+                return fn(...args);
+            }
+            default:
+                throw new Error('Unsupported formula AST node');
+        }
+    }
+}
+function evaluateBinary(operator, left, right) {
+    switch (operator) {
+        case '||':
+            return toBoolean(left) || toBoolean(right);
+        case '&&':
+            return toBoolean(left) && toBoolean(right);
+        case '==':
+            return looseEqual(left, right);
+        case '!=':
+            return !looseEqual(left, right);
+        case '>':
+            return compareValues(left, right) > 0;
+        case '>=':
+            return compareValues(left, right) >= 0;
+        case '<':
+            return compareValues(left, right) < 0;
+        case '<=':
+            return compareValues(left, right) <= 0;
+        case '+':
+            return typeof left === 'string' || typeof right === 'string'
+                ? `${left ?? ''}${right ?? ''}`
+                : toNumber(left) + toNumber(right);
+        case '-':
+            return toNumber(left) - toNumber(right);
+        case '*':
+            return toNumber(left) * toNumber(right);
+        case '/':
+            return toNumber(left) / toNumber(right);
+        default:
+            throw new Error(`Unsupported operator: ${operator}`);
+    }
+}
+function looseEqual(left, right) {
+    if (Array.isArray(left) && Array.isArray(right)) {
+        return right.every((item) => left.includes(item));
+    }
+    if (Array.isArray(left))
+        return left.includes(right);
+    if (Array.isArray(right))
+        return right.includes(left);
+    const leftDate = toDate(left);
+    const rightDate = toDate(right);
+    if (leftDate && rightDate) {
+        return leftDate.getTime() === rightDate.getTime();
+    }
+    const leftNumber = maybeNumber(left);
+    const rightNumber = maybeNumber(right);
+    if (leftNumber !== null && rightNumber !== null) {
+        return leftNumber === rightNumber;
+    }
+    return left === right;
+}
+function compareValues(left, right) {
+    const leftDate = toDate(left);
+    const rightDate = toDate(right);
+    if (leftDate && rightDate) {
+        return leftDate.getTime() - rightDate.getTime();
+    }
+    const leftNumber = toNumber(left);
+    const rightNumber = toNumber(right);
+    return leftNumber - rightNumber;
+}
+function buildDefaultFunctionRegistry() {
+    const isNull = (value) => value === null ||
+        value === undefined ||
+        value === '' ||
+        (Array.isArray(value) && value.length === 0);
+    return {
+        SHOW_IF: (condition) => toBoolean(condition),
+        HIDE_IF: (condition) => toBoolean(condition),
+        ENABLE_IF: (condition) => toBoolean(condition),
+        DISABLE_IF: (condition) => toBoolean(condition),
+        AND: (...args) => args.every((arg) => toBoolean(arg)),
+        OR: (...args) => args.some((arg) => toBoolean(arg)),
+        NOT: (condition) => !toBoolean(condition),
+        ISNULL: (value) => isNull(value),
+        CONTAINS: (text, search) => String(text ?? '')
+            .toLowerCase()
+            .includes(String(search ?? '').toLowerCase()),
+        REQUIRED: (value) => !isNull(value),
+        MIN_LENGTH: (value, min) => String(value ?? '').length >= toNumber(min),
+        MAX_LENGTH: (value, max) => String(value ?? '').length <= toNumber(max),
+        REGEX: (value, pattern) => {
+            try {
+                return new RegExp(String(pattern ?? '')).test(String(value ?? ''));
+            }
+            catch {
+                return false;
+            }
+        },
+        BEFORE: (date, reference) => {
+            const left = toDate(date);
+            const right = toDate(reference);
+            if (!left || !right)
+                return false;
+            return left.getTime() < right.getTime();
+        },
+        AFTER: (date, reference) => {
+            const left = toDate(date);
+            const right = toDate(reference);
+            if (!left || !right)
+                return false;
+            return left.getTime() > right.getTime();
+        },
+    };
+}
+function normalizeWrapperAction(name) {
+    const normalized = name.trim().toLowerCase();
+    return CONDITION_WRAPPER_NAMES.has(normalized)
+        ? normalized
+        : null;
+}
+function normalizePropertyToken(raw) {
+    const value = String(raw ?? '').trim();
+    const prefix = PROPERTY_PREFIXES.find((p) => value.startsWith(p));
+    return prefix ? value.slice(prefix.length) : value;
+}
+function parseLiteralTokenValue(token) {
+    if (token.literalType === 'number') {
+        return toNumber(token.value);
+    }
+    if (token.literalType === 'boolean') {
+        return toBoolean(token.value);
+    }
+    const value = String(token.value ?? '').trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    if (value.toLowerCase() === 'true')
+        return true;
+    if (value.toLowerCase() === 'false')
+        return false;
+    const asNumber = maybeNumber(value);
+    if (asNumber !== null)
+        return asNumber;
+    return value;
+}
+function resolvePropertyValue(values, key, raw) {
+    if (Object.prototype.hasOwnProperty.call(values, key)) {
+        return values[key];
+    }
+    if (Object.prototype.hasOwnProperty.call(values, raw)) {
+        return values[raw];
+    }
+    if (!key.includes('.')) {
+        return undefined;
+    }
+    const parts = key.split('.');
+    let current = values;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function toBoolean(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return !Number.isNaN(value) && value !== 0;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === '' ||
+            normalized === 'false' ||
+            normalized === '0' ||
+            normalized === 'null' ||
+            normalized === 'undefined') {
+            return false;
+        }
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.length > 0;
+    return Boolean(value);
+}
+function toNumber(value) {
+    const num = Number(value);
+    return Number.isFinite(num) ? num : 0;
+}
+function maybeNumber(value) {
+    if (value === '' || value === null || value === undefined)
+        return null;
+    const num = Number(value);
+    return Number.isFinite(num) ? num : null;
+}
+function toDate(value) {
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? null : value;
+    }
+    if (typeof value === 'string' || typeof value === 'number') {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    return null;
+}
+function toErrorMessage(error) {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return 'Formula evaluation failed';
+}
+
 // Formula components public API
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { DEFAULT_OPERATORS, FormulaEditor, FormulaEditorCode, FormulaStatusBar, FormulaToolbar, FormulaToolbarItem, cloneBlock, cloneToken, cloneTokens, createFunctionBlock, createFunctionTokens, createLiteralBlock, createLiteralToken, createOperatorBlock, createOperatorToken, createPropertyBlock, createPropertyToken, findFunctionRange, generateFunctionId, generateSmartBlockId, generateTokenId, getArgumentIndexAtPosition, getFunctionTokens, isValidDropPosition, parseSignature, recalculateDepths, serializeTokens };
+export { CONDITION_FUNCTION_CATEGORIES, CONDITION_OPERATORS, CONDITION_RUNTIME_CATALOG, DEFAULT_OPERATORS, FormulaEditor, FormulaEditorCode, FormulaRuntimeEngine, FormulaStatusBar, FormulaToolbar, FormulaToolbarItem, VALIDATION_FUNCTION_CATEGORIES, VALIDATION_OPERATORS, VALIDATION_RUNTIME_CATALOG, cloneBlock, cloneToken, cloneTokens, createFunctionBlock, createFunctionTokens, createLiteralBlock, createLiteralToken, createOperatorBlock, createOperatorToken, createPropertyBlock, createPropertyToken, findFunctionRange, generateFunctionId, generateSmartBlockId, generateTokenId, getArgumentIndexAtPosition, getFunctionTokens, isValidDropPosition, parseSignature, recalculateDepths, serializeTokens };
 //# sourceMappingURL=masterteam-components-formula.mjs.map