@smythos/sre 1.5.53 → 1.5.54

package/src/Components/LogicAtLeast.class.ts

@@ -1,85 +1,85 @@
-import Joi from 'joi';
-
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-
-export class LogicAtLeast extends Component {
-    protected configSchema = Joi.object({
-        // TODO (Forhad): Need to check if min and max work instead of the custom validateInteger
-        minSetInputs: Joi.alternatives([Joi.string(), Joi.number()]) // Value is now a number; keep string fallback for backward compatibility.
-            .custom(validateInteger({ min: 0, max: 9 }), 'custom range validation')
-            .label('Minimum Inputs'),
-    });
-    constructor() {
-        super();
-    }
-
-    init() {}
-
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const logger = this.createComponentLogger(agent, config);
-        const result: any = { Output: undefined };
-
-        if (config.data.minSetInputs === '' || isNaN(Number(config.data.minSetInputs))) {
-            return result;
-        }
-
-        const minSetInputs = Number(config.data.minSetInputs);
-        if (config.inputs.length < minSetInputs) {
-            return result;
-        }
-
-        let trueCount = 0;
-        for (let cfgInput of config.inputs) {
-            if (input[cfgInput.name]) {
-                trueCount++;
-            }
-        }
-
-        if (trueCount >= minSetInputs) {
-            result.Output = true;
-        }
-
-        result.Verified = result.Output !== undefined;
-        result.Unverified = !result.Verified;
-        if (!result.Verified) delete result.Verified;
-        if (!result.Unverified) delete result.Unverified;
-
-        return result;
-    }
-}
-
-interface RangeValidationArgs {
-    min?: number;
-    max?: number;
-}
-
-function validateInteger(args: RangeValidationArgs) {
-    return (value: string, helpers: any) => {
-        const numValue = Number(value);
-        const fieldName = helpers.schema._flags.label || helpers.state.path[helpers.state.path.length - 1];
-
-        // Check if the value is a number
-        if (isNaN(numValue)) {
-            throw new Error(`The value for '${fieldName}' must be a number`);
-        }
-
-        // Range validations
-        if (args.min !== undefined && args.max !== undefined) {
-            if (numValue < args.min || numValue > args.max) {
-                throw new Error(`The value for '${fieldName}' must be from ${args.min} to ${args.max}`);
-            }
-        } else if (args.min !== undefined) {
-            if (numValue < args.min) {
-                throw new Error(`The value for '${fieldName}' must be greater or equal to ${args.min}`);
-            }
-        } else if (args.max !== undefined) {
-            if (numValue > args.max) {
-                throw new Error(`The value for '${fieldName}' must be less or equal to ${args.max}`);
-            }
-        }
-
-        return value; // Value is valid
-    };
-}
+import Joi from 'joi';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+
+export class LogicAtLeast extends Component {
+    protected configSchema = Joi.object({
+        // TODO (Forhad): Need to check if min and max work instead of the custom validateInteger
+        minSetInputs: Joi.alternatives([Joi.string(), Joi.number()]) // Value is now a number; keep string fallback for backward compatibility.
+            .custom(validateInteger({ min: 0, max: 9 }), 'custom range validation')
+            .label('Minimum Inputs'),
+    });
+    constructor() {
+        super();
+    }
+
+    init() {}
+
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const logger = this.createComponentLogger(agent, config);
+        const result: any = { Output: undefined };
+
+        if (config.data.minSetInputs === '' || isNaN(Number(config.data.minSetInputs))) {
+            return result;
+        }
+
+        const minSetInputs = Number(config.data.minSetInputs);
+        if (config.inputs.length < minSetInputs) {
+            return result;
+        }
+
+        let trueCount = 0;
+        for (let cfgInput of config.inputs) {
+            if (input[cfgInput.name]) {
+                trueCount++;
+            }
+        }
+
+        if (trueCount >= minSetInputs) {
+            result.Output = true;
+        }
+
+        result.Verified = result.Output !== undefined;
+        result.Unverified = !result.Verified;
+        if (!result.Verified) delete result.Verified;
+        if (!result.Unverified) delete result.Unverified;
+
+        return result;
+    }
+}
+
+interface RangeValidationArgs {
+    min?: number;
+    max?: number;
+}
+
+function validateInteger(args: RangeValidationArgs) {
+    return (value: string, helpers: any) => {
+        const numValue = Number(value);
+        const fieldName = helpers.schema._flags.label || helpers.state.path[helpers.state.path.length - 1];
+
+        // Check if the value is a number
+        if (isNaN(numValue)) {
+            throw new Error(`The value for '${fieldName}' must be a number`);
+        }
+
+        // Range validations
+        if (args.min !== undefined && args.max !== undefined) {
+            if (numValue < args.min || numValue > args.max) {
+                throw new Error(`The value for '${fieldName}' must be from ${args.min} to ${args.max}`);
+            }
+        } else if (args.min !== undefined) {
+            if (numValue < args.min) {
+                throw new Error(`The value for '${fieldName}' must be greater or equal to ${args.min}`);
+            }
+        } else if (args.max !== undefined) {
+            if (numValue > args.max) {
+                throw new Error(`The value for '${fieldName}' must be less or equal to ${args.max}`);
+            }
+        }
+
+        return value; // Value is valid
+    };
+}

package/src/Components/LogicAtMost.class.ts

@@ -1,86 +1,86 @@
-import Joi from 'joi';
-
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-
-export class LogicAtMost extends Component {
-    protected configSchema = Joi.object({
-        // TODO (Forhad): Need to check if min and max work instead of the custom validateInteger
-        maxSetInputs: Joi.alternatives([Joi.string(), Joi.number()]) // Value is now a number; keep string fallback for backward compatibility.
-            .custom(validateInteger({ min: 0, max: 9 }), 'custom range validation')
-            .label('Maximum Inputs'),
-    });
-    constructor() {
-        super();
-    }
-
-    init() {}
-
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const result: any = { Output: undefined };
-
-        if (config.data.maxSetInputs === '' || isNaN(Number(config.data.maxSetInputs))) {
-            return result;
-        }
-
-        const maxSetInputs = Number(config.data.maxSetInputs);
-        if (config.inputs.length < maxSetInputs) {
-            return result;
-        }
-
-        let trueCount = 0;
-        for (let cfgInput of config.inputs) {
-            if (input[cfgInput.name]) {
-                trueCount++;
-                if (trueCount > maxSetInputs) {
-                    break;
-                }
-            }
-        }
-
-        if (trueCount <= maxSetInputs) {
-            result.Output = true;
-        }
-
-        result.Verified = result.Output !== undefined;
-        result.Unverified = !result.Verified;
-        if (!result.Verified) delete result.Verified;
-        if (!result.Unverified) delete result.Unverified;
-
-        return result;
-    }
-}
-interface RangeValidationArgs {
-    min?: number;
-    max?: number;
-}
-
-function validateInteger(args: RangeValidationArgs) {
-    return (value: string, helpers: any) => {
-        const numValue = Number(value);
-        const fieldName = helpers.schema._flags.label || helpers.state.path[helpers.state.path.length - 1];
-
-        // Check if the value is a number
-        if (isNaN(numValue)) {
-            throw new Error(`The value for '${fieldName}' must be a number`);
-        }
-
-        // Range validations
-        if (args.min !== undefined && args.max !== undefined) {
-            if (numValue < args.min || numValue > args.max) {
-                throw new Error(`The value for '${fieldName}' must be from ${args.min} to ${args.max}`);
-            }
-        } else if (args.min !== undefined) {
-            if (numValue < args.min) {
-                throw new Error(`The value for '${fieldName}' must be greater or equal to ${args.min}`);
-            }
-        } else if (args.max !== undefined) {
-            if (numValue > args.max) {
-                throw new Error(`The value for '${fieldName}' must be less or equal to ${args.max}`);
-            }
-        }
-
-        return value; // Value is valid
-    };
-}
+import Joi from 'joi';
+
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+
+export class LogicAtMost extends Component {
+    protected configSchema = Joi.object({
+        // TODO (Forhad): Need to check if min and max work instead of the custom validateInteger
+        maxSetInputs: Joi.alternatives([Joi.string(), Joi.number()]) // Value is now a number; keep string fallback for backward compatibility.
+            .custom(validateInteger({ min: 0, max: 9 }), 'custom range validation')
+            .label('Maximum Inputs'),
+    });
+    constructor() {
+        super();
+    }
+
+    init() {}
+
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const result: any = { Output: undefined };
+
+        if (config.data.maxSetInputs === '' || isNaN(Number(config.data.maxSetInputs))) {
+            return result;
+        }
+
+        const maxSetInputs = Number(config.data.maxSetInputs);
+        if (config.inputs.length < maxSetInputs) {
+            return result;
+        }
+
+        let trueCount = 0;
+        for (let cfgInput of config.inputs) {
+            if (input[cfgInput.name]) {
+                trueCount++;
+                if (trueCount > maxSetInputs) {
+                    break;
+                }
+            }
+        }
+
+        if (trueCount <= maxSetInputs) {
+            result.Output = true;
+        }
+
+        result.Verified = result.Output !== undefined;
+        result.Unverified = !result.Verified;
+        if (!result.Verified) delete result.Verified;
+        if (!result.Unverified) delete result.Unverified;
+
+        return result;
+    }
+}
+interface RangeValidationArgs {
+    min?: number;
+    max?: number;
+}
+
+function validateInteger(args: RangeValidationArgs) {
+    return (value: string, helpers: any) => {
+        const numValue = Number(value);
+        const fieldName = helpers.schema._flags.label || helpers.state.path[helpers.state.path.length - 1];
+
+        // Check if the value is a number
+        if (isNaN(numValue)) {
+            throw new Error(`The value for '${fieldName}' must be a number`);
+        }
+
+        // Range validations
+        if (args.min !== undefined && args.max !== undefined) {
+            if (numValue < args.min || numValue > args.max) {
+                throw new Error(`The value for '${fieldName}' must be from ${args.min} to ${args.max}`);
+            }
+        } else if (args.min !== undefined) {
+            if (numValue < args.min) {
+                throw new Error(`The value for '${fieldName}' must be greater or equal to ${args.min}`);
+            }
+        } else if (args.max !== undefined) {
+            if (numValue > args.max) {
+                throw new Error(`The value for '${fieldName}' must be less or equal to ${args.max}`);
+            }
+        }
+
+        return value; // Value is valid
+    };
+}

package/src/Components/LogicOR.class.ts

@@ -1,29 +1,29 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-
-export class LogicOR extends Component {
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const result: any = { Output: undefined };
-        console.log(input);
-        console.log(config);
-        for (let cfgInput of config.inputs) {
-            // check if one of the inputs are set (expected inputs are in "config.inputs" actual inputs are in "input")
-            if (input[cfgInput.name]) {
-                result.Output = true;
-                break;
-            }
-        }
-
-        result.Verified = result.Output !== undefined;
-        result.Unverified = !result.Verified;
-        if (!result.Verified) delete result.Verified;
-        if (!result.Unverified) delete result.Unverified;
-
-        return result;
-    }
-}
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+
+export class LogicOR extends Component {
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const result: any = { Output: undefined };
+        console.log(input);
+        console.log(config);
+        for (let cfgInput of config.inputs) {
+            // check if one of the inputs are set (expected inputs are in "config.inputs" actual inputs are in "input")
+            if (input[cfgInput.name]) {
+                result.Output = true;
+                break;
+            }
+        }
+
+        result.Verified = result.Output !== undefined;
+        result.Unverified = !result.Verified;
+        if (!result.Verified) delete result.Verified;
+        if (!result.Unverified) delete result.Unverified;
+
+        return result;
+    }
+}

package/src/Components/LogicXOR.class.ts

@@ -1,34 +1,34 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-
-export class LogicXOR extends Component {
-    constructor() {
-        super();
-    }
-
-    init() {}
-
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const result: any = { Output: undefined };
-        let trueCount = 0;
-
-        for (let cfgInput of config.inputs) {
-            // counts the number of set inputs
-            if (input[cfgInput.name]) {
-                trueCount++;
-            }
-        }
-        // checks if only one input is set, to trigger output
-        if (trueCount === 1) {
-            result.Output = true;
-        }
-
-        result.Verified = result.Output !== undefined;
-        result.Unverified = !result.Verified;
-        if (!result.Verified) delete result.Verified;
-        if (!result.Unverified) delete result.Unverified;
-
-        return result;
-    }
-}
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+
+export class LogicXOR extends Component {
+    constructor() {
+        super();
+    }
+
+    init() {}
+
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const result: any = { Output: undefined };
+        let trueCount = 0;
+
+        for (let cfgInput of config.inputs) {
+            // counts the number of set inputs
+            if (input[cfgInput.name]) {
+                trueCount++;
+            }
+        }
+        // checks if only one input is set, to trigger output
+        if (trueCount === 1) {
+            result.Output = true;
+        }
+
+        result.Verified = result.Output !== undefined;
+        result.Unverified = !result.Verified;
+        if (!result.Verified) delete result.Verified;
+        if (!result.Unverified) delete result.Unverified;
+
+        return result;
+    }
+}