@grnsft/if 0.7.0 → 0.7.1

package/build/if-run/builtins/sci/index.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sci = void 0;
+const zod_1 = require("zod");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const validations_1 = require("../../../common/util/validations");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_2 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { MissingInputDataError, ConfigError } = utils_1.ERRORS;
+const { MISSING_FUNCTIONAL_UNIT_CONFIG, MISSING_FUNCTIONAL_UNIT_INPUT, SCI_MISSING_FN_UNIT, ZERO_DIVISION, MISSING_CONFIG, } = config_1.STRINGS;
+exports.Sci = (0, interfaces_1.PluginFactory)({
+    metadata: {
+        inputs: {
+            carbon: {
+                description: 'an amount of carbon emitted into the atmosphere',
+                unit: 'gCO2e',
+                'aggregation-method': {
+                    time: 'sum',
+                    component: 'sum',
+                },
+            },
+            'functional-unit': {
+                description: 'the name of the functional unit in which the final SCI value should be expressed, e.g. requests, users',
+                unit: 'none',
+                'aggregation-method': {
+                    time: 'sum',
+                    component: 'sum',
+                },
+            },
+        },
+        outputs: {
+            sci: {
+                description: 'carbon expressed in terms of the given functional unit',
+                unit: 'gCO2e',
+                'aggregation-method': {
+                    time: 'avg',
+                    component: 'sum',
+                },
+            },
+        },
+    },
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const schema = zod_1.z
+            .object({
+            'functional-unit': zod_1.z.string(),
+        })
+            .refine(data => data['functional-unit'], {
+            message: MISSING_FUNCTIONAL_UNIT_CONFIG,
+        });
+        return (0, validations_1.validate)(schema, config);
+    },
+    inputValidation: (input, config) => {
+        const functionalUnit = config['functional-unit'];
+        if (!(functionalUnit in input && input[functionalUnit] >= 0)) {
+            throw new MissingInputDataError(MISSING_FUNCTIONAL_UNIT_INPUT);
+        }
+        const schema = zod_1.z
+            .object({
+            carbon: zod_1.z.number().gte(0),
+            duration: zod_1.z.number().gte(1),
+        })
+            .refine(validations_2.allDefined, {
+            message: SCI_MISSING_FN_UNIT(config['functional-unit']),
+        });
+        return (0, validations_1.validate)(schema, input);
+    },
+    implementation: async (inputs, config) => {
+        return inputs.map((input, index) => {
+            const functionalUnit = isNaN(config['functional-unit'])
+                ? input[config['functional-unit']]
+                : config['functional-unit'];
+            if (functionalUnit === 0) {
+                console.warn(ZERO_DIVISION(exports.Sci.name, index));
+                return {
+                    ...input,
+                    sci: input['carbon'],
+                };
+            }
+            const calculatedResult = input['carbon'] / functionalUnit;
+            return {
+                ...input,
+                sci: calculatedResult,
+            };
+        });
+    },
+    allowArithmeticExpressions: ['functional-unit'],
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/sci-embodied/index.d.ts

@@ -0,0 +1,16 @@
+import { ConfigParams, PluginParams } from '@grnsft/if-core/types';
+export declare const SciEmbodied: (config: ConfigParams | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: import("@grnsft/if-core/types").MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};

package/build/if-run/builtins/sci-embodied/index.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SciEmbodied = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@grnsft/if-core/utils");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+exports.SciEmbodied = (0, interfaces_1.PluginFactory)({
+    metadata: {
+        inputs: {
+            vCPUs: {
+                description: 'number of CPUs allocated to an application',
+                unit: 'CPUs',
+                'aggregation-method': {
+                    time: 'copy',
+                    component: 'copy',
+                },
+            },
+            memory: {
+                description: 'RAM available for a resource, in GB',
+                unit: 'GB',
+                'aggregation-method': {
+                    time: 'copy',
+                    component: 'copy',
+                },
+            },
+            ssd: {
+                description: 'number of SSDs available for a resource',
+                unit: 'SSDs',
+                'aggregation-method': {
+                    time: 'copy',
+                    component: 'copy',
+                },
+            },
+            hdd: {
+                description: 'number of HDDs available for a resource',
+                unit: 'HDDs',
+                'aggregation-method': {
+                    time: 'copy',
+                    component: 'copy',
+                },
+            },
+            gpu: {
+                description: 'number of GPUs available for a resource',
+                unit: 'GPUs',
+                'aggregation-method': {
+                    time: 'copy',
+                    component: 'copy',
+                },
+            },
+            'usage-ratio': {
+                description: 'a scaling factor that can be used to describe the ratio of actual resource usage comapred to real device usage, e.g. 0.25 if you are using 2 out of 8 vCPUs, 0.1 if you are responsible for 1 out of 10 GB of storage, etc',
+                unit: 'dimensionless',
+                'aggregation-method': {
+                    time: 'copy',
+                    component: 'copy',
+                },
+            },
+            time: {
+                description: 'a time unit to scale the embodied carbon by, in seconds. If not provided,time defaults to the value of the timestep duration.',
+                unit: 'seconds',
+                'aggregation-method': {
+                    time: 'copy',
+                    component: 'copy',
+                },
+            },
+        },
+        outputs: {
+            'embodied-carbon': {
+                description: 'embodied carbon for a resource, scaled by usage',
+                unit: 'gCO2eq',
+                'aggregation-method': {
+                    time: 'sum',
+                    component: 'sum',
+                },
+            },
+        },
+    },
+    configValidation: zod_1.z.object({
+        'baseline-vcpus': zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('baseline-vcpus', value, 'number'), zod_1.z.number().gte(0).default(1)),
+        'baseline-memory': zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('baseline-memory', value, 'number'), zod_1.z.number().gte(0).default(16)),
+        'baseline-emissions': zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('baseline-emissions', value, 'number'), zod_1.z.number().gte(0).default(1000000)),
+        lifespan: zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('lifespan', value, 'number'), zod_1.z.number().gt(0).default(126144000)),
+        'vcpu-emissions-constant': zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('vcpu-emissions-constant', value, 'number'), zod_1.z.number().gte(0).default(100000)),
+        'memory-emissions-constant': zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('memory-emissions-constant', value, 'number'), zod_1.z
+            .number()
+            .gte(0)
+            .default(533 / 384)),
+        'ssd-emissions-constant': zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('ssd-emissions-constant', value, 'number'), zod_1.z.number().gte(0).default(50000)),
+        'hdd-emissions-constant': zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('hdd-emissions-constant', value, 'number'), zod_1.z.number().gte(0).default(100000)),
+        'gpu-emissions-constant': zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('gpu-emissions-constant', value, 'number'), zod_1.z.number().gte(0).default(150000)),
+        'output-parameter': zod_1.z.string().optional(),
+    }),
+    inputValidation: zod_1.z.object({
+        duration: zod_1.z.number().gt(0),
+        vCPUs: zod_1.z.number().gt(0).default(1),
+        memory: zod_1.z.number().gt(0).default(16),
+        ssd: zod_1.z.number().gte(0).default(0),
+        hdd: zod_1.z.number().gte(0).default(0),
+        gpu: zod_1.z.number().gte(0).default(0),
+        'usage-ratio': zod_1.z.number().gt(0).default(1),
+        time: zod_1.z.number().gt(0).optional(),
+    }),
+    implementation: async (inputs, config) => {
+        /**
+         * 1. Validates configuration and assigns defaults values if not provided.
+         * 2. Maps through observations and validates them.
+         * 3. Calculates total embodied carbon by substracting and the difference between baseline server and given one.
+         */
+        return inputs.map(input => {
+            const cpuE = (input.vCPUs - config['baseline-vcpus']) *
+                config['vcpu-emissions-constant'];
+            const memoryE = (input.memory - config['baseline-memory']) *
+                ((config['memory-emissions-constant'] * config['baseline-memory']) /
+                    16) *
+                1000;
+            const hddE = input.hdd * config['hdd-emissions-constant'];
+            const gpuE = input.gpu * config['gpu-emissions-constant'];
+            const ssdE = input.ssd * config['ssd-emissions-constant'];
+            const time = input['time'] || input.duration;
+            const totalEmbodied = config['baseline-emissions'] + cpuE + memoryE + ssdE + hddE + gpuE;
+            const totalEmbodiedScaledByUsage = totalEmbodied * input['usage-ratio'];
+            const totalEmbodiedScaledByUsageAndTime = totalEmbodiedScaledByUsage * (time / config['lifespan']);
+            const embodiedCarbonKey = config['output-parameter'] || 'embodied-carbon';
+            return {
+                ...input,
+                [embodiedCarbonKey]: totalEmbodiedScaledByUsageAndTime,
+            };
+        });
+    },
+    allowArithmeticExpressions: [
+        'baseline-vcpus',
+        'baseline-memory',
+        'baseline-emissions',
+        'lifespan',
+        'vcpu-emissions-constant',
+        'memory-emissions-constant',
+        'ssd-emissions-constant',
+        'hdd-emissions-constant',
+        'gpu-emissions-constant',
+    ],
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/if-run/builtins/sci-embodied/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {z} from 'zod';\n\nimport {validateArithmeticExpression} from '@grnsft/if-core/utils';\nimport {ConfigParams, PluginParams} from '@grnsft/if-core/types';\nimport {PluginFactory} from '@grnsft/if-core/interfaces';\n\nexport const SciEmbodied = PluginFactory({\n  metadata: {\n    inputs: {\n      vCPUs: {\n        description: 'number of CPUs allocated to an application',\n        unit: 'CPUs',\n        'aggregation-method': {\n          time: 'copy',\n          component: 'copy',\n        },\n      },\n      memory: {\n        description: 'RAM available for a resource, in GB',\n        unit: 'GB',\n        'aggregation-method': {\n          time: 'copy',\n          component: 'copy',\n        },\n      },\n      ssd: {\n        description: 'number of SSDs available for a resource',\n        unit: 'SSDs',\n        'aggregation-method': {\n          time: 'copy',\n          component: 'copy',\n        },\n      },\n      hdd: {\n        description: 'number of HDDs available for a resource',\n        unit: 'HDDs',\n        'aggregation-method': {\n          time: 'copy',\n          component: 'copy',\n        },\n      },\n      gpu: {\n        description: 'number of GPUs available for a resource',\n        unit: 'GPUs',\n        'aggregation-method': {\n          time: 'copy',\n          component: 'copy',\n        },\n      },\n      'usage-ratio': {\n        description:\n          'a scaling factor that can be used to describe the ratio of actual resource usage comapred to real device usage, e.g. 0.25 if you are using 2 out of 8 vCPUs, 0.1 if you are responsible for 1 out of 10 GB of storage, etc',\n        unit: 'dimensionless',\n        'aggregation-method': {\n          time: 'copy',\n          component: 'copy',\n        },\n      },\n      time: {\n        description:\n          'a time unit to scale the embodied carbon by, in seconds. If not provided,time defaults to the value of the timestep duration.',\n        unit: 'seconds',\n        'aggregation-method': {\n          time: 'copy',\n          component: 'copy',\n        },\n      },\n    },\n    outputs: {\n      'embodied-carbon': {\n        description: 'embodied carbon for a resource, scaled by usage',\n        unit: 'gCO2eq',\n        'aggregation-method': {\n          time: 'sum',\n          component: 'sum',\n        },\n      },\n    },\n  },\n  configValidation: z.object({\n    'baseline-vcpus': z.preprocess(\n      value => validateArithmeticExpression('baseline-vcpus', value, 'number'),\n      z.number().gte(0).default(1)\n    ),\n    'baseline-memory': z.preprocess(\n      value => validateArithmeticExpression('baseline-memory', value, 'number'),\n      z.number().gte(0).default(16)\n    ),\n    'baseline-emissions': z.preprocess(\n      value =>\n        validateArithmeticExpression('baseline-emissions', value, 'number'),\n      z.number().gte(0).default(1000000)\n    ),\n    lifespan: z.preprocess(\n      value => validateArithmeticExpression('lifespan', value, 'number'),\n      z.number().gt(0).default(126144000)\n    ),\n    'vcpu-emissions-constant': z.preprocess(\n      value =>\n        validateArithmeticExpression(\n          'vcpu-emissions-constant',\n          value,\n          'number'\n        ),\n      z.number().gte(0).default(100000)\n    ),\n    'memory-emissions-constant': z.preprocess(\n      value =>\n        validateArithmeticExpression(\n          'memory-emissions-constant',\n          value,\n          'number'\n        ),\n      z\n        .number()\n        .gte(0)\n        .default(533 / 384)\n    ),\n    'ssd-emissions-constant': z.preprocess(\n      value =>\n        validateArithmeticExpression('ssd-emissions-constant', value, 'number'),\n      z.number().gte(0).default(50000)\n    ),\n    'hdd-emissions-constant': z.preprocess(\n      value =>\n        validateArithmeticExpression('hdd-emissions-constant', value, 'number'),\n      z.number().gte(0).default(100000)\n    ),\n    'gpu-emissions-constant': z.preprocess(\n      value =>\n        validateArithmeticExpression('gpu-emissions-constant', value, 'number'),\n      z.number().gte(0).default(150000)\n    ),\n    'output-parameter': z.string().optional(),\n  }),\n  inputValidation: z.object({\n    duration: z.number().gt(0),\n    vCPUs: z.number().gt(0).default(1),\n    memory: z.number().gt(0).default(16),\n    ssd: z.number().gte(0).default(0),\n    hdd: z.number().gte(0).default(0),\n    gpu: z.number().gte(0).default(0),\n    'usage-ratio': z.number().gt(0).default(1),\n    time: z.number().gt(0).optional(),\n  }),\n  implementation: async (inputs: PluginParams[], config: ConfigParams) => {\n    /**\n     * 1. Validates configuration and assigns defaults values if not provided.\n     * 2. Maps through observations and validates them.\n     * 3. Calculates total embodied carbon by substracting and the difference between baseline server and given one.\n     */\n    return inputs.map(input => {\n      const cpuE =\n        (input.vCPUs - config['baseline-vcpus']) *\n        config['vcpu-emissions-constant'];\n      const memoryE =\n        (input.memory - config['baseline-memory']) *\n        ((config['memory-emissions-constant'] * config['baseline-memory']) /\n          16) *\n        1000;\n      const hddE = input.hdd * config['hdd-emissions-constant'];\n      const gpuE = input.gpu * config['gpu-emissions-constant'];\n      const ssdE = input.ssd * config['ssd-emissions-constant'];\n      const time = input['time'] || input.duration;\n\n      const totalEmbodied =\n        config['baseline-emissions'] + cpuE + memoryE + ssdE + hddE + gpuE;\n\n      const totalEmbodiedScaledByUsage = totalEmbodied * input['usage-ratio'];\n\n      const totalEmbodiedScaledByUsageAndTime =\n        totalEmbodiedScaledByUsage * (time / config['lifespan']);\n\n      const embodiedCarbonKey = config['output-parameter'] || 'embodied-carbon';\n\n      return {\n        ...input,\n        [embodiedCarbonKey]: totalEmbodiedScaledByUsageAndTime,\n      };\n    });\n  },\n  allowArithmeticExpressions: [\n    'baseline-vcpus',\n    'baseline-memory',\n    'baseline-emissions',\n    'lifespan',\n    'vcpu-emissions-constant',\n    'memory-emissions-constant',\n    'ssd-emissions-constant',\n    'hdd-emissions-constant',\n    'gpu-emissions-constant',\n  ],\n});\n"]}

package/build/if-run/builtins/shell/index.d.ts

@@ -0,0 +1,16 @@
+import { ConfigParams, PluginParams } from '@grnsft/if-core/types';
+export declare const Shell: (config: ConfigParams | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: import("@grnsft/if-core/types").MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};

package/build/if-run/builtins/shell/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shell = void 0;
+const child_process_1 = require("child_process");
+const js_yaml_1 = require("js-yaml");
+const zod_1 = require("zod");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { ProcessExecutionError, ConfigError } = utils_1.ERRORS;
+const { MISSING_CONFIG } = config_1.STRINGS;
+exports.Shell = (0, interfaces_1.PluginFactory)({
+    configValidation: (config) => {
+        if (!config) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const schema = zod_1.z.object({
+            command: zod_1.z.string(),
+        });
+        return (0, validations_1.validate)(schema, config);
+    },
+    implementation: async (inputs, config) => {
+        const inputWithConfig = Object.assign({}, inputs[0], config);
+        const command = inputWithConfig.command;
+        const inputAsString = (0, js_yaml_1.dump)(inputs, { indent: 2 });
+        const results = runModelInShell(inputAsString, command);
+        return results?.outputs?.flat();
+    },
+});
+/**
+ * Runs the model in a shell. Spawns a child process to run an external IMP,
+ * an executable with a CLI exposing two methods: `--execute` and `--manifest`.
+ * The shell command then calls the `--command` method passing var manifest as the path to the desired manifest file.
+ */
+const runModelInShell = (input, command) => {
+    try {
+        const [executable, ...args] = command.split(' ');
+        const result = (0, child_process_1.spawnSync)(executable, args, {
+            input,
+            encoding: 'utf8',
+        });
+        const outputs = (0, js_yaml_1.loadAll)(result.stdout);
+        return { outputs };
+    }
+    catch (error) {
+        throw new ProcessExecutionError(error.message);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/subtract/index.d.ts

@@ -0,0 +1,16 @@
+import { ConfigParams, PluginParams } from '@grnsft/if-core/types';
+export declare const Subtract: (config: ConfigParams | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: import("@grnsft/if-core/types").MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};

package/build/if-run/builtins/subtract/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subtract = void 0;
+const zod_1 = require("zod");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { ConfigError } = utils_1.ERRORS;
+const { MISSING_CONFIG } = config_1.STRINGS;
+exports.Subtract = (0, interfaces_1.PluginFactory)({
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const configSchema = zod_1.z.object({
+            'input-parameters': zod_1.z.array(zod_1.z.string()),
+            'output-parameter': zod_1.z.string().min(1),
+        });
+        return (0, validations_1.validate)(configSchema, config);
+    },
+    inputValidation: (input, config) => {
+        const inputParameters = config['input-parameters'];
+        const inputData = inputParameters.reduce((acc, param) => {
+            acc[param] = input[param];
+            return acc;
+        }, {});
+        const validationSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.number());
+        return (0, validations_1.validate)(validationSchema, inputData);
+    },
+    implementation: async (inputs, config) => {
+        const { 'input-parameters': inputParameters, 'output-parameter': outputParameter, } = config;
+        return inputs.map(input => {
+            const calculatedResult = calculateDiff(input, inputParameters);
+            return {
+                ...input,
+                [outputParameter]: calculatedResult,
+            };
+        });
+    },
+    allowArithmeticExpressions: [],
+});
+/**
+ * Calculates the diff between the 1st item in the inputs nad the rest of the items
+ */
+const calculateDiff = (input, inputParameters) => {
+    const [firstItem, ...restItems] = inputParameters;
+    return restItems.reduce((accumulator, metricToSubtract) => accumulator - input[metricToSubtract], input[firstItem] // Starting accumulator with the value of the first item
+    );
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/sum/index.d.ts

@@ -0,0 +1,16 @@
+import { PluginParams, ConfigParams } from '@grnsft/if-core/types';
+export declare const Sum: (config: ConfigParams | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: import("@grnsft/if-core/types").MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};

package/build/if-run/builtins/sum/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sum = void 0;
+const zod_1 = require("zod");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const validations_1 = require("../../../common/util/validations");
+exports.Sum = (0, interfaces_1.PluginFactory)({
+    configValidation: zod_1.z.object({
+        'input-parameters': zod_1.z.array(zod_1.z.string()),
+        'output-parameter': zod_1.z.string().min(1),
+    }),
+    inputValidation: (input, config) => {
+        const inputParameters = config['input-parameters'];
+        const inputData = inputParameters.reduce((acc, param) => {
+            acc[param] = input[param];
+            return acc;
+        }, {});
+        const validationSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.number());
+        return (0, validations_1.validate)(validationSchema, inputData);
+    },
+    implementation: async (inputs, config) => {
+        const { 'input-parameters': inputParameters, 'output-parameter': outputParameter, } = config;
+        return inputs.map(input => {
+            const calculatedResult = calculateSum(input, inputParameters);
+            return {
+                ...input,
+                [outputParameter]: calculatedResult,
+            };
+        });
+    },
+    allowArithmeticExpressions: [],
+});
+/**
+ * Calculates the sum of the energy components.
+ */
+const calculateSum = (input, inputParameters) => inputParameters.reduce((accumulator, metricToSum) => accumulator + input[metricToSum], 0);
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/time-converter/config.d.ts

@@ -0,0 +1 @@
+export declare const TIME_UNITS_IN_SECONDS: Record<string, number>;

package/build/if-run/builtins/time-converter/config.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIME_UNITS_IN_SECONDS = void 0;
+exports.TIME_UNITS_IN_SECONDS = {
+    s: 1,
+    second: 1,
+    sec: 1,
+    secs: 1,
+    seconds: 1,
+    min: 60,
+    mins: 60,
+    minute: 60,
+    minutes: 60,
+    h: 3600,
+    hs: 3600,
+    hr: 3600,
+    hrs: 3600,
+    hour: 3600,
+    hours: 3600,
+    d: 86400,
+    ds: 86400,
+    day: 86400,
+    days: 86400,
+    w: 604800,
+    ws: 604800,
+    wk: 604800,
+    wks: 604800,
+    week: 604800,
+    weeks: 604800,
+    m: 2628336,
+    mnth: 2628336,
+    mth: 2628336,
+    mnths: 2628336,
+    mths: 2628336,
+    month: 2628336,
+    months: 2628336,
+    y: 31556952,
+    ys: 31556952,
+    yr: 31556952,
+    yrs: 31556952,
+    year: 31556952,
+    years: 31556952,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/time-converter/index.d.ts

@@ -0,0 +1,16 @@
+import { PluginParams, ConfigParams } from '@grnsft/if-core/types';
+export declare const TimeConverter: (config: ConfigParams | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: import("@grnsft/if-core/types").MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};