@ngx-formly/core 7.0.1 → 7.1.0

package/fesm2022/ngx-formly-core.mjs

@@ -131,6 +131,7 @@ function isPromise(obj) {
 function clone(value) {
     if (!isObject(value) ||
         isObservable(value) ||
+        isPromise(value) ||
         value instanceof TemplateRef ||
         /* instanceof SafeHtmlImpl */ value.changingThisBreaksApplicationSecurity ||
         ['RegExp', 'FileList', 'File', 'Blob'].indexOf(value.constructor?.name) !== -1) {
@@ -317,7 +318,10 @@ function isSignalRequired() {
     return +VERSION.major > 18 || (+VERSION.major >= 18 && +VERSION.minor >= 1);
 }
 
-function evalStringExpression(expression, argNames) {
+/**
+ * Legacy implementation
+ */
+function evalStringExpressionLegacy(expression, argNames) {
     try {
         return Function(...argNames, `return ${expression};`);
     }
@@ -432,7 +436,7 @@ function clearControl(form) {
     }
 }
 
-class FieldExpressionExtension {
+let FieldExpressionExtension$1 = class FieldExpressionExtension {
     onPopulate(field) {
         if (field._expressions) {
             return;
@@ -515,7 +519,7 @@ class FieldExpressionExtension {
         }
         expr = expr || (() => false);
         if (typeof expr === 'string') {
-            expr = evalStringExpression(expr, ['model', 'formState', 'field']);
+            expr = this._evalStringExpression(expr, ['model', 'formState', 'field']);
         }
         let currentValue;
         return {
@@ -540,6 +544,9 @@ class FieldExpressionExtension {
             },
         };
     }
+    _evalStringExpression(expression, argNames) {
+        return evalStringExpressionLegacy(expression, argNames);
+    }
     checkExpressions(field, ignoreCache = false) {
         if (!field) {
             return false;
@@ -670,6 +677,471 @@ class FieldExpressionExtension {
         }
         return paths;
     }
+};
+
+// CSP-compliant expression parser for Formly expressions
+// Supports: model.path, formState.path, field.path, comparisons, logical operators, and negation
+// Tokenizer
+var TokenType;
+(function (TokenType) {
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    TokenType["DOT"] = "DOT";
+    TokenType["BRACKET_OPEN"] = "BRACKET_OPEN";
+    TokenType["BRACKET_CLOSE"] = "BRACKET_CLOSE";
+    TokenType["STRING"] = "STRING";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["BOOLEAN"] = "BOOLEAN";
+    TokenType["NULL"] = "NULL";
+    TokenType["UNDEFINED"] = "UNDEFINED";
+    TokenType["OPERATOR"] = "OPERATOR";
+    TokenType["LOGICAL"] = "LOGICAL";
+    TokenType["NOT"] = "NOT";
+    TokenType["ARITHMETIC"] = "ARITHMETIC";
+    TokenType["PAREN_OPEN"] = "PAREN_OPEN";
+    TokenType["PAREN_CLOSE"] = "PAREN_CLOSE";
+    TokenType["TERNARY_QUESTION"] = "TERNARY_QUESTION";
+    TokenType["TERNARY_COLON"] = "TERNARY_COLON";
+    TokenType["EOF"] = "EOF";
+})(TokenType || (TokenType = {}));
+class Tokenizer {
+    constructor(input) {
+        this.pos = 0;
+        this.input = input.trim();
+    }
+    tokenize() {
+        const tokens = [];
+        while (this.pos < this.input.length) {
+            this.skipWhitespace();
+            if (this.pos >= this.input.length)
+                break;
+            const char = this.input[this.pos];
+            // String literals
+            if (char === '"' || char === "'") {
+                tokens.push(this.readString());
+            }
+            // Numbers
+            else if (/\d/.test(char)) {
+                tokens.push(this.readNumber());
+            }
+            // Identifiers and keywords
+            else if (/[a-zA-Z_$]/.test(char)) {
+                tokens.push(this.readIdentifier());
+            }
+            // Operators and symbols
+            else if (char === '.') {
+                tokens.push({ type: TokenType.DOT, value: '.' });
+                this.pos++;
+            }
+            else if (char === '[') {
+                tokens.push({ type: TokenType.BRACKET_OPEN, value: '[' });
+                this.pos++;
+            }
+            else if (char === ']') {
+                tokens.push({ type: TokenType.BRACKET_CLOSE, value: ']' });
+                this.pos++;
+            }
+            else if (char === '(') {
+                tokens.push({ type: TokenType.PAREN_OPEN, value: '(' });
+                this.pos++;
+            }
+            else if (char === ')') {
+                tokens.push({ type: TokenType.PAREN_CLOSE, value: ')' });
+                this.pos++;
+            }
+            else if (char === '?') {
+                tokens.push({ type: TokenType.TERNARY_QUESTION, value: '?' });
+                this.pos++;
+            }
+            else if (char === ':') {
+                tokens.push({ type: TokenType.TERNARY_COLON, value: ':' });
+                this.pos++;
+            }
+            else if (char === '!') {
+                if (this.peek() === '=') {
+                    if (this.input[this.pos + 2] === '=') {
+                        tokens.push({ type: TokenType.OPERATOR, value: '!==' });
+                        this.pos += 3;
+                    }
+                    else {
+                        tokens.push({ type: TokenType.OPERATOR, value: '!=' });
+                        this.pos += 2;
+                    }
+                }
+                else {
+                    tokens.push({ type: TokenType.NOT, value: '!' });
+                    this.pos++;
+                }
+            }
+            else if (char === '=' || char === '<' || char === '>') {
+                tokens.push(this.readOperator());
+            }
+            else if (char === '+' || char === '*' || char === '/' || char === '%') {
+                tokens.push({ type: TokenType.ARITHMETIC, value: char });
+                this.pos++;
+            }
+            else if (char === '-') {
+                // Check if this is a negative number or subtraction
+                // It's a negative number if preceded by an operator, opening paren, or at the start
+                const lastToken = tokens[tokens.length - 1];
+                const isNegativeNumber = tokens.length === 0 ||
+                    lastToken?.type === TokenType.OPERATOR ||
+                    lastToken?.type === TokenType.LOGICAL ||
+                    lastToken?.type === TokenType.ARITHMETIC ||
+                    lastToken?.type === TokenType.PAREN_OPEN ||
+                    lastToken?.type === TokenType.TERNARY_QUESTION ||
+                    lastToken?.type === TokenType.TERNARY_COLON;
+                if (isNegativeNumber && this.peek() && /\d/.test(this.peek())) {
+                    tokens.push(this.readNumber());
+                }
+                else {
+                    tokens.push({ type: TokenType.ARITHMETIC, value: '-' });
+                    this.pos++;
+                }
+            }
+            else if (char === '&' && this.peek() === '&') {
+                tokens.push({ type: TokenType.LOGICAL, value: '&&' });
+                this.pos += 2;
+            }
+            else if (char === '|' && this.peek() === '|') {
+                tokens.push({ type: TokenType.LOGICAL, value: '||' });
+                this.pos += 2;
+            }
+            else {
+                throw new Error(`Unexpected character: ${char} at position ${this.pos}`);
+            }
+        }
+        tokens.push({ type: TokenType.EOF, value: null });
+        return tokens;
+    }
+    skipWhitespace() {
+        while (this.pos < this.input.length && /\s/.test(this.input[this.pos])) {
+            this.pos++;
+        }
+    }
+    peek(offset = 1) {
+        return this.input[this.pos + offset] || '';
+    }
+    readString() {
+        const quote = this.input[this.pos];
+        this.pos++;
+        let value = '';
+        while (this.pos < this.input.length && this.input[this.pos] !== quote) {
+            if (this.input[this.pos] === '\\') {
+                this.pos++;
+                if (this.pos < this.input.length) {
+                    const escaped = this.input[this.pos];
+                    switch (escaped) {
+                        case 'n':
+                            value += '\n';
+                            break;
+                        case 't':
+                            value += '\t';
+                            break;
+                        case 'r':
+                            value += '\r';
+                            break;
+                        default:
+                            value += escaped;
+                    }
+                }
+            }
+            else {
+                value += this.input[this.pos];
+            }
+            this.pos++;
+        }
+        this.pos++; // skip closing quote
+        return { type: TokenType.STRING, value };
+    }
+    readNumber() {
+        let value = '';
+        // Handle negatives
+        if (this.input[this.pos] === '-') {
+            value += '-';
+            this.pos++;
+        }
+        let hasDecimal = false;
+        while (this.pos < this.input.length && /[\d.]/.test(this.input[this.pos])) {
+            if (this.input[this.pos] === '.') {
+                if (hasDecimal) {
+                    throw new Error(`Invalid number format: multiple decimal points at position ${this.pos}`);
+                }
+                hasDecimal = true;
+            }
+            value += this.input[this.pos];
+            this.pos++;
+        }
+        const parsed = parseFloat(value);
+        if (isNaN(parsed)) {
+            throw new Error(`Invalid number format: ${value}`);
+        }
+        return { type: TokenType.NUMBER, value: parsed };
+    }
+    readIdentifier() {
+        let value = '';
+        while (this.pos < this.input.length && /[a-zA-Z0-9_$]/.test(this.input[this.pos])) {
+            value += this.input[this.pos];
+            this.pos++;
+        }
+        // Check for keywords
+        if (value === 'true' || value === 'false') {
+            return { type: TokenType.BOOLEAN, value: value === 'true' };
+        }
+        if (value === 'null') {
+            return { type: TokenType.NULL, value: null };
+        }
+        if (value === 'undefined') {
+            return { type: TokenType.UNDEFINED, value: undefined };
+        }
+        return { type: TokenType.IDENTIFIER, value };
+    }
+    readOperator() {
+        let op = this.input[this.pos];
+        this.pos++;
+        if (this.pos < this.input.length) {
+            const next = this.input[this.pos];
+            if ((op === '=' && next === '=') ||
+                (op === '!' && next === '=') ||
+                (op === '<' && next === '=') ||
+                (op === '>' && next === '=')) {
+                op += next;
+                this.pos++;
+                // Check for === or !==
+                if (this.pos < this.input.length && this.input[this.pos] === '=') {
+                    op += '=';
+                    this.pos++;
+                }
+            }
+        }
+        return { type: TokenType.OPERATOR, value: op };
+    }
+}
+// Parser and Evaluator
+class ExpressionParser {
+    constructor(tokens) {
+        this.pos = 0;
+        this.tokens = tokens;
+    }
+    parse() {
+        const expr = this.parseTernary();
+        return (context) => expr(context);
+    }
+    parseTernary() {
+        const expr = this.parseLogicalOr();
+        if (this.current().type === TokenType.TERNARY_QUESTION) {
+            this.consume(TokenType.TERNARY_QUESTION);
+            const trueExpr = this.parseLogicalOr();
+            this.consume(TokenType.TERNARY_COLON);
+            const falseExpr = this.parseTernary();
+            return (context) => {
+                return expr(context) ? trueExpr(context) : falseExpr(context);
+            };
+        }
+        return expr;
+    }
+    parseLogicalOr() {
+        let left = this.parseLogicalAnd();
+        while (this.current().type === TokenType.LOGICAL && this.current().value === '||') {
+            this.consume(TokenType.LOGICAL);
+            const right = this.parseLogicalAnd();
+            const prevLeft = left;
+            left = (context) => prevLeft(context) || right(context);
+        }
+        return left;
+    }
+    parseLogicalAnd() {
+        let left = this.parseComparison();
+        while (this.current().type === TokenType.LOGICAL && this.current().value === '&&') {
+            this.consume(TokenType.LOGICAL);
+            const right = this.parseComparison();
+            const prevLeft = left;
+            left = (context) => prevLeft(context) && right(context);
+        }
+        return left;
+    }
+    parseComparison() {
+        const left = this.parseAdditive();
+        if (this.current().type === TokenType.OPERATOR) {
+            const op = this.consume(TokenType.OPERATOR).value;
+            const right = this.parseAdditive();
+            return (context) => {
+                const leftVal = left(context);
+                const rightVal = right(context);
+                switch (op) {
+                    case '===':
+                        return leftVal === rightVal;
+                    case '!==':
+                        return leftVal !== rightVal;
+                    case '==':
+                        return leftVal == rightVal;
+                    case '!=':
+                        return leftVal != rightVal;
+                    case '<':
+                        return leftVal < rightVal;
+                    case '<=':
+                        return leftVal <= rightVal;
+                    case '>':
+                        return leftVal > rightVal;
+                    case '>=':
+                        return leftVal >= rightVal;
+                    default:
+                        throw new Error(`Unknown operator: ${op}`);
+                }
+            };
+        }
+        return left;
+    }
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.current().type === TokenType.ARITHMETIC &&
+            (this.current().value === '+' || this.current().value === '-')) {
+            const op = this.consume(TokenType.ARITHMETIC).value;
+            const right = this.parseMultiplicative();
+            const prevLeft = left;
+            if (op === '+') {
+                left = (context) => prevLeft(context) + right(context);
+            }
+            else {
+                left = (context) => prevLeft(context) - right(context);
+            }
+        }
+        return left;
+    }
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (this.current().type === TokenType.ARITHMETIC &&
+            (this.current().value === '*' || this.current().value === '/' || this.current().value === '%')) {
+            const op = this.consume(TokenType.ARITHMETIC).value;
+            const right = this.parseUnary();
+            const prevLeft = left;
+            if (op === '*') {
+                left = (context) => prevLeft(context) * right(context);
+            }
+            else if (op === '/') {
+                left = (context) => prevLeft(context) / right(context);
+            }
+            else {
+                left = (context) => prevLeft(context) % right(context);
+            }
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.current().type === TokenType.NOT) {
+            this.consume(TokenType.NOT);
+            const expr = this.parseUnary();
+            return (context) => !expr(context);
+        }
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        const token = this.current();
+        // Parentheses
+        if (token.type === TokenType.PAREN_OPEN) {
+            this.consume(TokenType.PAREN_OPEN);
+            const expr = this.parseTernary();
+            this.consume(TokenType.PAREN_CLOSE);
+            return expr;
+        }
+        // Literals
+        if (token.type === TokenType.STRING ||
+            token.type === TokenType.NUMBER ||
+            token.type === TokenType.BOOLEAN ||
+            token.type === TokenType.NULL ||
+            token.type === TokenType.UNDEFINED) {
+            const value = token.value;
+            this.pos++;
+            return () => value;
+        }
+        // Property access (model.field, formState.prop, etc)
+        if (token.type === TokenType.IDENTIFIER) {
+            return this.parsePropertyAccess();
+        }
+        throw new Error(`Unexpected token: ${JSON.stringify(token)}`);
+    }
+    parsePropertyAccess() {
+        const path = [];
+        // Read first identifier
+        path.push(this.consume(TokenType.IDENTIFIER).value);
+        // Read rest of path (dots and brackets)
+        while (this.current().type === TokenType.DOT || this.current().type === TokenType.BRACKET_OPEN) {
+            if (this.current().type === TokenType.DOT) {
+                this.consume(TokenType.DOT);
+                path.push(this.consume(TokenType.IDENTIFIER).value);
+            }
+            else {
+                this.consume(TokenType.BRACKET_OPEN);
+                // bracket notation can contain expressions
+                if (this.current().type === TokenType.STRING) {
+                    path.push(this.consume(TokenType.STRING).value);
+                }
+                else if (this.current().type === TokenType.NUMBER) {
+                    path.push(String(this.consume(TokenType.NUMBER).value));
+                }
+                else {
+                    // dynamic property access
+                    const expr = this.parseTernary();
+                    path.push(expr);
+                }
+                this.consume(TokenType.BRACKET_CLOSE);
+            }
+        }
+        return (context) => {
+            let value = context;
+            for (const segment of path) {
+                if (value === null || value === undefined) {
+                    return undefined;
+                }
+                if (typeof segment === 'function') {
+                    value = value[segment(context)];
+                }
+                else {
+                    value = value[segment];
+                }
+            }
+            return value;
+        };
+    }
+    current() {
+        return this.tokens[this.pos];
+    }
+    consume(expectedType) {
+        const token = this.current();
+        if (token.type !== expectedType) {
+            throw new Error(`Expected ${expectedType}, got ${token.type}`);
+        }
+        this.pos++;
+        return token;
+    }
+}
+/**
+ * Uses CSP-safe implementation
+ */
+function parseExpression(expression, argNames) {
+    try {
+        const tokenizer = new Tokenizer(expression);
+        const tokens = tokenizer.tokenize();
+        const parser = new ExpressionParser(tokens);
+        const evaluator = parser.parse();
+        // Return a function that maps the args to the context
+        return (...args) => {
+            const context = {};
+            argNames.forEach((name, i) => {
+                context[name] = args[i];
+            });
+            return evaluator(context);
+        };
+    }
+    catch (error) {
+        console.error('Expression parse error:', error);
+        return undefined;
+    }
+}
+
+class FieldExpressionExtension extends FieldExpressionExtension$1 {
+    _evalStringExpression(expression, argNames) {
+        return parseExpression(expression, argNames);
+    }
 }
 
 class CoreExtension {
@@ -1756,7 +2228,22 @@ function withDefaultConfig(config) {
             { name: 'core', extension: new CoreExtension(config), priority: -250 },
             { name: 'field-validation', extension: new FieldValidationExtension(config), priority: -200 },
             { name: 'field-form', extension: new FieldFormExtension(), priority: -150 },
-            { name: 'field-expression', extension: new FieldExpressionExtension(), priority: -100 },
+            {
+                name: 'field-expression',
+                extension: new FieldExpressionExtension$1(),
+                priority: -100,
+            },
+        ],
+    };
+}
+function withFormlyFieldExpression() {
+    return {
+        extensions: [
+            {
+                name: 'field-expression',
+                extension: new FieldExpressionExtension(),
+                priority: -100,
+            },
         ],
     };
 }
@@ -2470,5 +2957,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { FORMLY_CONFIG, FieldArrayType, FieldType, FieldWrapper, FormlyAttributes, FormlyConfig, FormlyField, FormlyForm, FormlyFormBuilder, FormlyModule, FormlyTemplate, FormlyValidationMessage, LegacyFormlyAttributes, LegacyFormlyField, LegacyFormlyForm, LegacyFormlyValidationMessage, provideFormlyConfig, provideFormlyCore, FormlyGroup as ɵFormlyGroup, LegacyFormlyTemplate as ɵFormlyTemplate, clone as ɵclone, defineHiddenProp as ɵdefineHiddenProp, getFieldValue as ɵgetFieldValue, hasKey as ɵhasKey, observe as ɵobserve, reverseDeepMerge as ɵreverseDeepMerge };
+export { FORMLY_CONFIG, FieldArrayType, FieldType, FieldWrapper, FormlyAttributes, FormlyConfig, FormlyField, FormlyForm, FormlyFormBuilder, FormlyModule, FormlyTemplate, FormlyValidationMessage, LegacyFormlyAttributes, LegacyFormlyField, LegacyFormlyForm, LegacyFormlyValidationMessage, provideFormlyConfig, provideFormlyCore, withFormlyFieldExpression, FormlyGroup as ɵFormlyGroup, LegacyFormlyTemplate as ɵFormlyTemplate, clone as ɵclone, defineHiddenProp as ɵdefineHiddenProp, getFieldValue as ɵgetFieldValue, hasKey as ɵhasKey, observe as ɵobserve, reverseDeepMerge as ɵreverseDeepMerge };
 //# sourceMappingURL=ngx-formly-core.mjs.map