@posiwise/common-services 0.1.77 → 0.1.79

package/fesm2022/posiwise-common-services.mjs

@@ -965,6 +965,12 @@ class AuthService {
     clearTokens() {
         return this.secureTokenStorage.clearTokens();
     }
+    /**
+     * Remove only impersonation tokens (not all tokens)
+     */
+    removeImpersonationTokens() {
+        return this.secureTokenStorage.removeImpersonatedTokens();
+    }
     getToken$() {
         return this.secureTokenStorage.getToken$();
     }
@@ -1271,8 +1277,8 @@ class PermissionService {
         }
         expr = this.handleNonBooleanPermissions(permission, expr, productKey, permission_key, productSlug);
         // Now expr is made of true/false values with &&, ||, ()
-        // Safe evaluation of boolean expressions without using eval()
-        return this.evaluateBooleanExpression(expr);
+        // eslint-disable-next-line no-eval
+        return eval(expr); // NOSONAR
     }
     handleNonBooleanPermissions(permission, expr, productKey, permission_key, productSlug) {
         if (typeof permission !== 'boolean') {
@@ -1379,161 +1385,6 @@ class PermissionService {
     getCurrentProduct() {
         return JSON.parse(localStorage.getItem('product'));
     }
-    /**
-     * Safely evaluates boolean expressions without using eval()
-     * Supports: true, false, &&, ||, (, )
-     * @param expr - Boolean expression string like "true && false || (true && false)"
-     * @returns boolean result
-     */
-    evaluateBooleanExpression(expr) {
-        if (!expr || typeof expr !== 'string') {
-            return false;
-        }
-        try {
-            // Clean up the expression - remove extra spaces and normalize
-            const cleanExpr = expr.trim().replace(/\s+/g, ' ');
-            // Simple tokenizer for boolean expressions
-            const tokens = this.tokenizeBooleanExpression(cleanExpr);
-            // Parse and evaluate the expression
-            return this.parseBooleanExpression(tokens);
-        }
-        catch (error) {
-            console.warn('Error evaluating boolean expression:', expr, error);
-            return false;
-        }
-    }
-    /**
-     * Tokenizes a boolean expression string
-     */
-    tokenizeBooleanExpression(expr) {
-        const tokens = [];
-        let i = 0;
-        while (i < expr.length) {
-            const char = expr[i];
-            if (this.isWhitespace(char)) {
-                i++;
-            }
-            else if (this.isParenthesis(char)) {
-                tokens.push(char);
-                i++;
-            }
-            else if (this.isDoubleOperator(expr, i, '&')) {
-                tokens.push('&&');
-                i += 2;
-            }
-            else if (this.isDoubleOperator(expr, i, '|')) {
-                tokens.push('||');
-                i += 2;
-            }
-            else {
-                const token = this.collectToken(expr, i);
-                if (token.value) {
-                    tokens.push(token.value);
-                }
-                i = token.nextIndex;
-            }
-        }
-        return tokens;
-    }
-    isWhitespace(char) {
-        return char === ' ';
-    }
-    isParenthesis(char) {
-        return char === '(' || char === ')';
-    }
-    isDoubleOperator(expr, index, operator) {
-        return expr[index] === operator && expr[index + 1] === operator;
-    }
-    collectToken(expr, startIndex) {
-        let current = '';
-        let i = startIndex;
-        while (i < expr.length && ![' ', '(', ')', '&', '|'].includes(expr[i])) {
-            current += expr[i];
-            i++;
-        }
-        return { value: current, nextIndex: i };
-    }
-    /**
-     * Parses and evaluates boolean expression tokens
-     */
-    parseBooleanExpression(tokens) {
-        // Handle simple cases first
-        if (tokens.length === 1) {
-            return tokens[0] === 'true';
-        }
-        // Convert to postfix notation and evaluate
-        const postfix = this.infixToPostfix(tokens);
-        return this.evaluatePostfix(postfix);
-    }
-    /**
-     * Converts infix notation to postfix (Reverse Polish Notation)
-     */
-    infixToPostfix(tokens) {
-        const output = [];
-        const operators = [];
-        const precedence = { '||': 1, '&&': 2 };
-        for (const token of tokens) {
-            if (token === 'true' || token === 'false') {
-                output.push(token);
-            }
-            else if (token === '(') {
-                operators.push(token);
-            }
-            else if (token === ')') {
-                while (operators.length > 0 && operators[operators.length - 1] !== '(') {
-                    const op = operators.pop();
-                    if (op)
-                        output.push(op);
-                }
-                operators.pop(); // Remove '('
-            }
-            else if (token === '&&' || token === '||') {
-                while (operators.length > 0 &&
-                    operators[operators.length - 1] !== '(' &&
-                    precedence[operators[operators.length - 1]] >= precedence[token]) {
-                    const op = operators.pop();
-                    if (op)
-                        output.push(op);
-                }
-                operators.push(token);
-            }
-        }
-        while (operators.length > 0) {
-            const op = operators.pop();
-            if (op)
-                output.push(op);
-        }
-        return output;
-    }
-    /**
-     * Evaluates postfix boolean expression
-     */
-    evaluatePostfix(postfix) {
-        const stack = [];
-        for (const token of postfix) {
-            if (token === 'true') {
-                stack.push(true);
-            }
-            else if (token === 'false') {
-                stack.push(false);
-            }
-            else if (token === '&&') {
-                const b = stack.pop();
-                const a = stack.pop();
-                if (a !== undefined && b !== undefined) {
-                    stack.push(a && b);
-                }
-            }
-            else if (token === '||') {
-                const b = stack.pop();
-                const a = stack.pop();
-                if (a !== undefined && b !== undefined) {
-                    stack.push(a || b);
-                }
-            }
-        }
-        return stack[0] || false;
-    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: PermissionService, deps: [{ token: MainApiHttpService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: PermissionService, providedIn: 'root' }); }
 }