@uipath/apollo-wind 0.7.2-pr188.4865fad

package/dist/components/forms/rules-engine.cjs

@@ -0,0 +1,343 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    RuleBuilder: ()=>RuleBuilder,
+    RulesEngine: ()=>RulesEngine,
+    ExpressionBuilder: ()=>ExpressionBuilder
+});
+const external_jsep_namespaceObject = require("jsep");
+var external_jsep_default = /*#__PURE__*/ __webpack_require__.n(external_jsep_namespaceObject);
+const index_cjs_namespaceObject = require("../../lib/index.cjs");
+class RulesEngine {
+    static evaluateConditions(conditions, values, operator = 'AND') {
+        if (0 === conditions.length) return true;
+        const results = conditions.map((condition)=>RulesEngine.evaluateCondition(condition, values));
+        return 'AND' === operator ? results.every(Boolean) : results.some(Boolean);
+    }
+    static evaluateCondition(condition, values) {
+        const fieldValue = (0, index_cjs_namespaceObject.get)(values, condition.when);
+        if (condition.custom) {
+            const result = RulesEngine.evaluateExpression(condition.custom, values);
+            return 'boolean' == typeof result ? result : Boolean(result);
+        }
+        if (void 0 !== condition.is) return fieldValue === condition.is;
+        if (void 0 !== condition.isNot) return fieldValue !== condition.isNot;
+        if (void 0 !== condition.in) return condition.in.includes(fieldValue);
+        if (void 0 !== condition.notIn) return !condition.notIn.includes(fieldValue);
+        if (void 0 !== condition.matches) {
+            const regex = new RegExp(condition.matches);
+            return regex.test(String(fieldValue));
+        }
+        return false;
+    }
+    static applyRules(rules, values, _context) {
+        const state = {};
+        for (const rule of rules){
+            const conditionsMet = RulesEngine.evaluateConditions(rule.conditions, values, rule.operator);
+            if (conditionsMet) {
+                if (void 0 !== rule.effects.visible) state.visible = rule.effects.visible;
+                if (void 0 !== rule.effects.disabled) state.disabled = rule.effects.disabled;
+                if (void 0 !== rule.effects.required) state.required = rule.effects.required;
+                if (void 0 !== rule.effects.value) state.value = rule.effects.value;
+            }
+        }
+        return state;
+    }
+    static evaluateExpression(expression, values) {
+        try {
+            const ast = external_jsep_default()(expression);
+            return RulesEngine.evaluateNode(ast, values);
+        } catch (error) {
+            console.error('Expression evaluation error:', error);
+            return false;
+        }
+    }
+    static evaluateNode(node, values) {
+        switch(node.type){
+            case 'Literal':
+                return node.value;
+            case 'Identifier':
+                return (0, index_cjs_namespaceObject.get)(values, node.name);
+            case 'BinaryExpression':
+                {
+                    const binary = node;
+                    const left = RulesEngine.evaluateNode(binary.left, values);
+                    const right = RulesEngine.evaluateNode(binary.right, values);
+                    switch(binary.operator){
+                        case '==':
+                            return left == right;
+                        case '===':
+                            return left === right;
+                        case '!=':
+                            return left != right;
+                        case '!==':
+                            return left !== right;
+                        case '<':
+                            return left < right;
+                        case '>':
+                            return left > right;
+                        case '<=':
+                            return left <= right;
+                        case '>=':
+                            return left >= right;
+                        case '&&':
+                            return left && right;
+                        case '||':
+                            return left || right;
+                        case '+':
+                            return left + right;
+                        case '-':
+                            return left - right;
+                        case '*':
+                            return left * right;
+                        case '/':
+                            return left / right;
+                        case '%':
+                            return left % right;
+                        default:
+                            throw new Error(`Unsupported operator: ${binary.operator}`);
+                    }
+                }
+            case 'UnaryExpression':
+                {
+                    const unary = node;
+                    const arg = RulesEngine.evaluateNode(unary.argument, values);
+                    switch(unary.operator){
+                        case '!':
+                            return !arg;
+                        case '-':
+                            return -arg;
+                        case '+':
+                            return +arg;
+                        default:
+                            throw new Error(`Unsupported unary operator: ${unary.operator}`);
+                    }
+                }
+            case 'MemberExpression':
+                {
+                    const member = node;
+                    const obj = RulesEngine.evaluateNode(member.object, values);
+                    const prop = member.computed ? RulesEngine.evaluateNode(member.property, values) : member.property.name;
+                    return obj?.[prop];
+                }
+            case 'ConditionalExpression':
+                {
+                    const cond = node;
+                    return RulesEngine.evaluateNode(cond.test, values) ? RulesEngine.evaluateNode(cond.consequent, values) : RulesEngine.evaluateNode(cond.alternate, values);
+                }
+            default:
+                throw new Error(`Unsupported expression type: ${node.type}`);
+        }
+    }
+    static isFieldVisible(rules, values) {
+        if (!rules || 0 === rules.length) return true;
+        const ruleResult = RulesEngine.applyRules(rules, values, {});
+        const hasShowRule = rules.some((rule)=>rule.effects?.visible === true);
+        rules.some((rule)=>rule.effects?.visible === false);
+        if (void 0 !== ruleResult.visible) return ruleResult.visible;
+        if (hasShowRule) return false;
+        return true;
+    }
+    static buildDependencyGraph(rules) {
+        const graph = new Map();
+        for (const rule of rules)for (const condition of rule.conditions){
+            if (!graph.has(condition.when)) graph.set(condition.when, new Set());
+            graph.get(condition.when).add(rule.id);
+        }
+        return graph;
+    }
+}
+class ExpressionBuilder {
+    static equals(field, value) {
+        return `${field} == ${JSON.stringify(value)}`;
+    }
+    static notEquals(field, value) {
+        return `${field} != ${JSON.stringify(value)}`;
+    }
+    static greaterThan(field, value) {
+        return `${field} > ${value}`;
+    }
+    static lessThan(field, value) {
+        return `${field} < ${value}`;
+    }
+    static greaterThanOrEqual(field, value) {
+        return `${field} >= ${value}`;
+    }
+    static lessThanOrEqual(field, value) {
+        return `${field} <= ${value}`;
+    }
+    static isEmpty(field) {
+        return `!${field} || ${field} == ''`;
+    }
+    static isNotEmpty(field) {
+        return `${field} && ${field} != ''`;
+    }
+    static and(...expressions) {
+        return `(${expressions.join(' && ')})`;
+    }
+    static or(...expressions) {
+        return `(${expressions.join(' || ')})`;
+    }
+    static not(expression) {
+        return `!(${expression})`;
+    }
+    static between(field, min, max) {
+        return `${field} >= ${min} && ${field} <= ${max}`;
+    }
+    static sum(fields) {
+        return fields.map((f)=>`(${f} || 0)`).join(' + ');
+    }
+    static product(fields) {
+        return fields.map((f)=>`(${f} || 0)`).join(' * ');
+    }
+    static average(fields) {
+        const sum = ExpressionBuilder.sum(fields);
+        return `(${sum}) / ${fields.length}`;
+    }
+    static inArray(field, values) {
+        const checks = values.map((v)=>`${field} == ${JSON.stringify(v)}`);
+        return ExpressionBuilder.or(...checks);
+    }
+}
+class RuleBuilder {
+    rule;
+    constructor(id){
+        this.rule = {
+            id,
+            conditions: [],
+            operator: 'AND',
+            effects: {}
+        };
+    }
+    when(field) {
+        return new ConditionBuilder(this, field);
+    }
+    withCustomExpression(expression) {
+        this.rule.conditions.push({
+            when: '',
+            custom: expression
+        });
+        return this;
+    }
+    useOperator(operator) {
+        this.rule.operator = operator;
+        return this;
+    }
+    show() {
+        this.rule.effects.visible = true;
+        return this;
+    }
+    hide() {
+        this.rule.effects.visible = false;
+        return this;
+    }
+    enable() {
+        this.rule.effects.disabled = false;
+        return this;
+    }
+    disable() {
+        this.rule.effects.disabled = true;
+        return this;
+    }
+    require() {
+        this.rule.effects.required = true;
+        return this;
+    }
+    optional() {
+        this.rule.effects.required = false;
+        return this;
+    }
+    setValue(value) {
+        this.rule.effects.value = value;
+        return this;
+    }
+    build() {
+        return this.rule;
+    }
+}
+class ConditionBuilder {
+    ruleBuilder;
+    field;
+    constructor(ruleBuilder, field){
+        this.ruleBuilder = ruleBuilder;
+        this.field = field;
+    }
+    is(value) {
+        this.ruleBuilder['rule'].conditions.push({
+            when: this.field,
+            is: value
+        });
+        return this.ruleBuilder;
+    }
+    isNot(value) {
+        this.ruleBuilder['rule'].conditions.push({
+            when: this.field,
+            isNot: value
+        });
+        return this.ruleBuilder;
+    }
+    in(values) {
+        this.ruleBuilder['rule'].conditions.push({
+            when: this.field,
+            in: values
+        });
+        return this.ruleBuilder;
+    }
+    notIn(values) {
+        this.ruleBuilder['rule'].conditions.push({
+            when: this.field,
+            notIn: values
+        });
+        return this.ruleBuilder;
+    }
+    matches(pattern) {
+        this.ruleBuilder['rule'].conditions.push({
+            when: this.field,
+            matches: pattern
+        });
+        return this.ruleBuilder;
+    }
+}
+exports.ExpressionBuilder = __webpack_exports__.ExpressionBuilder;
+exports.RuleBuilder = __webpack_exports__.RuleBuilder;
+exports.RulesEngine = __webpack_exports__.RulesEngine;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "ExpressionBuilder",
+    "RuleBuilder",
+    "RulesEngine"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/forms/rules-engine.d.ts

@@ -0,0 +1,99 @@
+import type { FieldRule, FieldCondition, FormContext, FieldOption } from './form-schema';
+/**
+ * Rules Engine - Evaluates conditions and applies effects using jsep
+ * Powers show/hide, enable/disable, validation changes, etc.
+ * Uses jsep for safe expression parsing with minimal evaluator
+ */
+export declare class RulesEngine {
+    /**
+     * Evaluate if conditions are met
+     */
+    static evaluateConditions(conditions: FieldCondition[], values: Record<string, unknown>, operator?: 'AND' | 'OR'): boolean;
+    /**
+     * Evaluate a single condition
+     */
+    static evaluateCondition(condition: FieldCondition, values: Record<string, unknown>): boolean;
+    /**
+     * Apply all rules for a field and return the resulting state
+     */
+    static applyRules(rules: FieldRule[], values: Record<string, unknown>, _context: FormContext): {
+        visible?: boolean;
+        disabled?: boolean;
+        required?: boolean;
+        value?: unknown;
+        options?: FieldOption[];
+    };
+    /**
+     * Evaluate custom expression using jsep
+     *
+     * Supports expressions like:
+     * - "age > 18"
+     * - "quantity * price"
+     * - "status == 'active' && role == 'admin'"
+     * - "total >= 100 ? 'discount' : 'regular'"
+     */
+    static evaluateExpression(expression: string, values: Record<string, unknown>): unknown;
+    /**
+     * Minimal AST evaluator - only supports operators needed for form rules
+     */
+    private static evaluateNode;
+    /**
+     * Determine if a field is visible based on its rules and current form values
+     * Extracted for reuse in validation and field rendering
+     */
+    static isFieldVisible(rules: FieldRule[] | undefined, values: Record<string, unknown>): boolean;
+    /**
+     * Build a dependency graph for optimized field watching
+     */
+    static buildDependencyGraph(rules: FieldRule[]): Map<string, Set<string>>;
+}
+/**
+ * Expression Builder - Helper for creating common expressions
+ */
+export declare class ExpressionBuilder {
+    static equals(field: string, value: unknown): string;
+    static notEquals(field: string, value: unknown): string;
+    static greaterThan(field: string, value: number): string;
+    static lessThan(field: string, value: number): string;
+    static greaterThanOrEqual(field: string, value: number): string;
+    static lessThanOrEqual(field: string, value: number): string;
+    static isEmpty(field: string): string;
+    static isNotEmpty(field: string): string;
+    static and(...expressions: string[]): string;
+    static or(...expressions: string[]): string;
+    static not(expression: string): string;
+    static between(field: string, min: number, max: number): string;
+    static sum(fields: string[]): string;
+    static product(fields: string[]): string;
+    static average(fields: string[]): string;
+    static inArray(field: string, values: unknown[]): string;
+}
+/**
+ * Rule Builder - Fluent API for creating rules
+ */
+export declare class RuleBuilder {
+    private rule;
+    constructor(id: string);
+    when(field: string): ConditionBuilder;
+    withCustomExpression(expression: string): this;
+    useOperator(operator: 'AND' | 'OR'): this;
+    show(): this;
+    hide(): this;
+    enable(): this;
+    disable(): this;
+    require(): this;
+    optional(): this;
+    setValue(value: unknown): this;
+    build(): FieldRule;
+}
+declare class ConditionBuilder {
+    private ruleBuilder;
+    private field;
+    constructor(ruleBuilder: RuleBuilder, field: string);
+    is(value: unknown): RuleBuilder;
+    isNot(value: unknown): RuleBuilder;
+    in(values: unknown[]): RuleBuilder;
+    notIn(values: unknown[]): RuleBuilder;
+    matches(pattern: string): RuleBuilder;
+}
+export {};