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

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

@@ -0,0 +1,293 @@
+import jsep from "jsep";
+import { get } from "../../lib/index.js";
+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 = 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 = jsep(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 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;
+    }
+}
+export { ExpressionBuilder, RuleBuilder, RulesEngine };

package/dist/components/forms/schema-serializer.cjs

@@ -0,0 +1,250 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    schemaToJson: ()=>schemaToJson,
+    serializeSchema: ()=>serializeSchema
+});
+function serializeOptions(options) {
+    return options.map((opt)=>({
+            label: opt.label,
+            value: opt.value,
+            ...void 0 !== opt.disabled && {
+                disabled: opt.disabled
+            }
+        }));
+}
+function serializeValidationConfig(config) {
+    const result = {};
+    if (void 0 !== config.required) result.required = config.required;
+    if (void 0 !== config.minLength) result.minLength = config.minLength;
+    if (void 0 !== config.maxLength) result.maxLength = config.maxLength;
+    if (void 0 !== config.pattern) result.pattern = config.pattern;
+    if (void 0 !== config.email) result.email = config.email;
+    if (void 0 !== config.url) result.url = config.url;
+    if (void 0 !== config.min) result.min = config.min;
+    if (void 0 !== config.max) result.max = config.max;
+    if (void 0 !== config.integer) result.integer = config.integer;
+    if (void 0 !== config.positive) result.positive = config.positive;
+    if (void 0 !== config.negative) result.negative = config.negative;
+    if (void 0 !== config.minItems) result.minItems = config.minItems;
+    if (void 0 !== config.maxItems) result.maxItems = config.maxItems;
+    if (void 0 !== config.maxFileSize) result.maxFileSize = config.maxFileSize;
+    if (void 0 !== config.allowedTypes) result.allowedTypes = config.allowedTypes;
+    if (void 0 !== config.custom) result.custom = config.custom;
+    if (config.messages && Object.keys(config.messages).length > 0) {
+        const messages = {};
+        const m = config.messages;
+        if (m.required) messages.required = m.required;
+        if (m.minLength) messages.minLength = m.minLength;
+        if (m.maxLength) messages.maxLength = m.maxLength;
+        if (m.pattern) messages.pattern = m.pattern;
+        if (m.min) messages.min = m.min;
+        if (m.max) messages.max = m.max;
+        if (m.email) messages.email = m.email;
+        if (m.url) messages.url = m.url;
+        if (m.integer) messages.integer = m.integer;
+        if (m.positive) messages.positive = m.positive;
+        if (m.negative) messages.negative = m.negative;
+        if (m.minItems) messages.minItems = m.minItems;
+        if (m.maxItems) messages.maxItems = m.maxItems;
+        if (m.custom) messages.custom = m.custom;
+        if (Object.keys(messages).length > 0) result.messages = messages;
+    }
+    return result;
+}
+function serializeActions(actions) {
+    return actions.map((action)=>({
+            id: action.id,
+            type: action.type,
+            label: action.label,
+            ...action.variant && {
+                variant: action.variant
+            },
+            ...void 0 !== action.loading && {
+                loading: action.loading
+            },
+            ...void 0 !== action.disabled && {
+                disabled: action.disabled
+            },
+            ...action.conditions && {
+                conditions: action.conditions.map(serializeCondition)
+            }
+        }));
+}
+function serializeCondition(condition) {
+    const result = {
+        when: condition.when
+    };
+    if (void 0 !== condition.is) result.is = condition.is;
+    if (void 0 !== condition.isNot) result.isNot = condition.isNot;
+    if (void 0 !== condition.in) result.in = condition.in;
+    if (void 0 !== condition.notIn) result.notIn = condition.notIn;
+    if (void 0 !== condition.matches) result.matches = condition.matches;
+    if (void 0 !== condition.custom) result.custom = condition.custom;
+    return result;
+}
+function serializeRule(rule) {
+    const result = {
+        id: rule.id,
+        conditions: rule.conditions.map(serializeCondition)
+    };
+    if (rule.operator && 'AND' !== rule.operator) result.operator = rule.operator;
+    const effects = {};
+    if (void 0 !== rule.effects.visible) effects.visible = rule.effects.visible;
+    if (void 0 !== rule.effects.disabled) effects.disabled = rule.effects.disabled;
+    if (void 0 !== rule.effects.required) effects.required = rule.effects.required;
+    if (void 0 !== rule.effects.value) effects.value = rule.effects.value;
+    if (rule.effects.validate) effects.validate = serializeValidationConfig(rule.effects.validate);
+    if (rule.effects.options) effects.options = serializeDataSource(rule.effects.options);
+    result.effects = effects;
+    return result;
+}
+function serializeDataSource(dataSource) {
+    switch(dataSource.type){
+        case 'static':
+            return {
+                type: 'static',
+                options: serializeOptions(dataSource.options)
+            };
+        case 'fetch':
+            return {
+                type: 'fetch',
+                url: dataSource.url,
+                ...dataSource.method && {
+                    method: dataSource.method
+                },
+                ...dataSource.transform && {
+                    transform: dataSource.transform
+                },
+                ...dataSource.params && {
+                    params: dataSource.params
+                }
+            };
+        case 'remote':
+            return {
+                type: 'remote',
+                endpoint: dataSource.endpoint,
+                ...dataSource.method && {
+                    method: dataSource.method
+                },
+                ...dataSource.params && {
+                    params: dataSource.params
+                },
+                ...dataSource.transform && {
+                    transform: dataSource.transform
+                }
+            };
+        case 'computed':
+            return {
+                type: 'computed',
+                dependency: dataSource.dependency,
+                compute: dataSource.compute
+            };
+    }
+}
+function serializeField(field) {
+    const result = {
+        name: field.name,
+        type: field.type,
+        label: field.label
+    };
+    if (field.placeholder) result.placeholder = field.placeholder;
+    if (field.description) result.description = field.description;
+    if (void 0 !== field.defaultValue) result.defaultValue = field.defaultValue;
+    if (field.validation) result.validation = serializeValidationConfig(field.validation);
+    if (field.dataSource) result.dataSource = serializeDataSource(field.dataSource);
+    if (field.rules && field.rules.length > 0) result.rules = field.rules.map(serializeRule);
+    if (field.grid) result.grid = field.grid;
+    if (field.ariaLabel) result.ariaLabel = field.ariaLabel;
+    if (field.ariaDescribedBy) result.ariaDescribedBy = field.ariaDescribedBy;
+    if ('options' in field && field.options) result.options = serializeOptions(field.options);
+    if ('rows' in field && field.rows) result.rows = field.rows;
+    if ('min' in field && void 0 !== field.min) result.min = field.min;
+    if ('max' in field && void 0 !== field.max) result.max = field.max;
+    if ('step' in field && void 0 !== field.step) result.step = field.step;
+    if ('maxSelected' in field && field.maxSelected) result.maxSelected = field.maxSelected;
+    if ('accept' in field && field.accept) result.accept = field.accept;
+    if ('multiple' in field && field.multiple) result.multiple = field.multiple;
+    if ('maxSize' in field && field.maxSize) result.maxSize = field.maxSize;
+    if ('showPreview' in field && field.showPreview) result.showPreview = field.showPreview;
+    if ('use12Hour' in field && field.use12Hour) result.use12Hour = field.use12Hour;
+    if ('component' in field && field.component) result.component = field.component;
+    if ('componentProps' in field && field.componentProps) result.componentProps = field.componentProps;
+    return result;
+}
+function serializeSection(section) {
+    const result = {
+        id: section.id,
+        fields: section.fields.map(serializeField)
+    };
+    if (section.title) result.title = section.title;
+    if (section.description) result.description = section.description;
+    if (void 0 !== section.collapsible) result.collapsible = section.collapsible;
+    if (void 0 !== section.defaultExpanded) result.defaultExpanded = section.defaultExpanded;
+    if (section.conditions && section.conditions.length > 0) result.conditions = section.conditions.map(serializeCondition);
+    return result;
+}
+function serializeStep(step) {
+    const result = {
+        id: step.id,
+        title: step.title,
+        sections: step.sections.map(serializeSection)
+    };
+    if (step.description) result.description = step.description;
+    if (step.validation) result.validation = step.validation;
+    if (void 0 !== step.canSkip) result.canSkip = step.canSkip;
+    if (step.conditions && step.conditions.length > 0) result.conditions = step.conditions.map(serializeCondition);
+    return result;
+}
+function serializeSchema(schema) {
+    const result = {
+        id: schema.id,
+        title: schema.title
+    };
+    if (schema.description) result.description = schema.description;
+    if (schema.version) result.version = schema.version;
+    if (schema.initialData) result.initialData = schema.initialData;
+    if (schema.mode) result.mode = schema.mode;
+    if (schema.reValidateMode) result.reValidateMode = schema.reValidateMode;
+    if (schema.actions && schema.actions.length > 0) result.actions = serializeActions(schema.actions);
+    if (schema.layout) result.layout = schema.layout;
+    if (schema.metadata) result.metadata = schema.metadata;
+    if ('sections' in schema && schema.sections) result.sections = schema.sections.map(serializeSection);
+    if ('steps' in schema && schema.steps) result.steps = schema.steps.map(serializeStep);
+    return result;
+}
+function schemaToJson(schema, indent = 2) {
+    return JSON.stringify(serializeSchema(schema), null, indent);
+}
+exports.schemaToJson = __webpack_exports__.schemaToJson;
+exports.serializeSchema = __webpack_exports__.serializeSchema;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "schemaToJson",
+    "serializeSchema"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/forms/schema-serializer.d.ts

@@ -0,0 +1,27 @@
+import type { FormSchema } from './form-schema';
+/**
+ * Schema Serializer - Converts FormSchema to JSON-safe format
+ *
+ * With ValidationConfig being JSON-serializable by design, this serializer
+ * now performs straightforward object-to-JSON conversion without complex
+ * Zod schema transformation.
+ *
+ * Output format:
+ * - Clean JSON that can be stored in databases
+ * - Can be transmitted over APIs
+ * - Fully round-trippable (JSON → FormSchema → JSON)
+ */
+type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type JsonArray = JsonValue[];
+/**
+ * Serialize a FormSchema to JSON-safe format
+ */
+export declare function serializeSchema(schema: FormSchema): JsonObject;
+/**
+ * Convert schema to formatted JSON string
+ */
+export declare function schemaToJson(schema: FormSchema, indent?: number): string;
+export {};