@grnsft/if 0.1.8 → 0.2.0

package/build/config/params.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARAMETERS = void 0;
+exports.PARAMETERS = {
+    carbon: {
+        description: 'an amount of carbon emitted into the atmosphere',
+        unit: 'gCO2e',
+        aggregation: 'sum',
+    },
+    'cpu/number-cores': {
+        description: 'number of cores available',
+        unit: 'cores',
+        aggregation: 'none',
+    },
+    'cpu/utilization': {
+        description: 'refers to CPU utilization.',
+        unit: 'percentage',
+        aggregation: 'avg',
+    },
+    'disk-io': {
+        description: 'refers to GB of data written/read from disk',
+        unit: 'GB',
+        aggregation: 'sum',
+    },
+    duration: {
+        description: 'refers to the duration of the input',
+        unit: 'seconds',
+        aggregation: 'sum',
+    },
+    energy: {
+        description: 'amount of energy utilised by the component',
+        unit: 'kWh',
+        aggregation: 'sum',
+    },
+    'cpu/energy': {
+        description: 'Energy consumed by the CPU of the component',
+        unit: 'kWh',
+        aggregation: 'sum',
+    },
+    'device/expected-lifespan': {
+        description: 'Total Expected Lifespan of the Component in Seconds',
+        unit: 'seconds',
+        aggregation: 'sum',
+    },
+    'memory/energy': {
+        description: 'Energy consumed by the Memory of the component',
+        unit: 'kWh',
+        aggregation: 'sum',
+    },
+    'carbon-embodied': {
+        description: 'Embodied Emissions of the component',
+        unit: 'gCO2e',
+        aggregation: 'sum',
+    },
+    'network/energy': {
+        description: 'Energy consumed by the Network of the component',
+        unit: 'kWh',
+        aggregation: '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: 'sum',
+    },
+    'functional-unit-time': {
+        description: 'string describing the unit of time in which the final SCI calculation should be expressed, e.g. "1-min"',
+        unit: 'none',
+        aggregation: 'none',
+    },
+    'gpu-util': {
+        description: 'refers to CPU utilization.',
+        unit: 'percentage',
+        aggregation: 'avg',
+    },
+    'grid/carbon-intensity': {
+        description: 'Carbon intensity for the grid',
+        unit: 'gCO2eq/kWh',
+        aggregation: 'avg',
+    },
+    'cloud/instance-type': {
+        description: 'Type of Cloud Instance name used in the cloud provider APIs',
+        unit: 'None',
+        aggregation: 'none',
+    },
+    geolocation: {
+        description: 'Geographic location of provider as string (for watt-time model it is provided as latitude and longitude, comma separated, in decimal degrees)',
+        unit: 'None (decimal degrees for watt-time model)',
+        aggregation: 'none',
+    },
+    'carbon-operational': {
+        description: 'Operational Emissions of the component',
+        unit: 'gCO2e',
+        aggregation: 'sum',
+    },
+    'cpu/name': {
+        description: 'Name of the physical processor',
+        unit: 'None',
+        aggregation: 'none',
+    },
+    'cloud/vendor': {
+        description: 'Name of the cloud service provider in the ccf model. Can be aws, gcp or azure',
+        unit: 'None',
+        aggregation: 'none',
+    },
+    'ram-alloc': {
+        description: 'refers to GB of memory allocated.',
+        unit: 'GB',
+        aggregation: 'avg',
+    },
+    'ram-util': {
+        description: 'refers to percentage of memory utilized.',
+        unit: 'percentage',
+        aggregation: 'avg',
+    },
+    'resources-reserved': {
+        description: 'resources reserved for an application',
+        unit: 'count',
+        aggregation: 'none',
+    },
+    'cpu/thermal-design-power': {
+        description: 'thermal design power for a processor',
+        unit: 'kwh',
+        aggregation: 'avg',
+    },
+    'device/emissions-embodied': {
+        description: 'total embodied emissions of some component',
+        unit: 'gCO2e',
+        aggregation: 'sum',
+    },
+    timestamp: {
+        description: 'refers to the time of occurrence of the input',
+        unit: 'RFC3339',
+        aggregation: 'none',
+    },
+    'time-reserved': {
+        description: 'time reserved for a component',
+        unit: 'seconds',
+        aggregation: 'avg',
+    },
+    'resources-total': {
+        description: 'total resources available',
+        unit: 'count',
+        aggregation: 'none',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"params.js","sourceRoot":"","sources":["../../src/config/params.ts"],"names":[],"mappings":";;;AAEa,QAAA,UAAU,GAAe;IACpC,MAAM,EAAE;QACN,WAAW,EAAE,iDAAiD;QAC9D,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,KAAK;KACnB;IACD,kBAAkB,EAAE;QAClB,WAAW,EAAE,2BAA2B;QACxC,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,MAAM;KACpB;IACD,iBAAiB,EAAE;QACjB,WAAW,EAAE,4BAA4B;QACzC,IAAI,EAAE,YAAY;QAClB,WAAW,EAAE,KAAK;KACnB;IACD,SAAS,EAAE;QACT,WAAW,EAAE,6CAA6C;QAC1D,IAAI,EAAE,IAAI;QACV,WAAW,EAAE,KAAK;KACnB;IACD,QAAQ,EAAE;QACR,WAAW,EAAE,qCAAqC;QAClD,IAAI,EAAE,SAAS;QACf,WAAW,EAAE,KAAK;KACnB;IACD,MAAM,EAAE;QACN,WAAW,EAAE,4CAA4C;QACzD,IAAI,EAAE,KAAK;QACX,WAAW,EAAE,KAAK;KACnB;IACD,YAAY,EAAE;QACZ,WAAW,EAAE,6CAA6C;QAC1D,IAAI,EAAE,KAAK;QACX,WAAW,EAAE,KAAK;KACnB;IACD,0BAA0B,EAAE;QAC1B,WAAW,EAAE,qDAAqD;QAClE,IAAI,EAAE,SAAS;QACf,WAAW,EAAE,KAAK;KACnB;IACD,eAAe,EAAE;QACf,WAAW,EAAE,gDAAgD;QAC7D,IAAI,EAAE,KAAK;QACX,WAAW,EAAE,KAAK;KACnB;IACD,iBAAiB,EAAE;QACjB,WAAW,EAAE,qCAAqC;QAClD,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,KAAK;KACnB;IACD,gBAAgB,EAAE;QAChB,WAAW,EAAE,iDAAiD;QAC9D,IAAI,EAAE,KAAK;QACX,WAAW,EAAE,KAAK;KACnB;IACD,iBAAiB,EAAE;QACjB,WAAW,EACT,wGAAwG;QAC1G,IAAI,EAAE,MAAM;QACZ,WAAW,EAAE,KAAK;KACnB;IACD,sBAAsB,EAAE;QACtB,WAAW,EACT,yGAAyG;QAC3G,IAAI,EAAE,MAAM;QACZ,WAAW,EAAE,MAAM;KACpB;IACD,UAAU,EAAE;QACV,WAAW,EAAE,4BAA4B;QACzC,IAAI,EAAE,YAAY;QAClB,WAAW,EAAE,KAAK;KACnB;IACD,uBAAuB,EAAE;QACvB,WAAW,EAAE,+BAA+B;QAC5C,IAAI,EAAE,YAAY;QAClB,WAAW,EAAE,KAAK;KACnB;IACD,qBAAqB,EAAE;QACrB,WAAW,EAAE,6DAA6D;QAC1E,IAAI,EAAE,MAAM;QACZ,WAAW,EAAE,MAAM;KACpB;IACD,WAAW,EAAE;QACX,WAAW,EACT,+IAA+I;QACjJ,IAAI,EAAE,4CAA4C;QAClD,WAAW,EAAE,MAAM;KACpB;IACD,oBAAoB,EAAE;QACpB,WAAW,EAAE,wCAAwC;QACrD,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,KAAK;KACnB;IACD,UAAU,EAAE;QACV,WAAW,EAAE,gCAAgC;QAC7C,IAAI,EAAE,MAAM;QACZ,WAAW,EAAE,MAAM;KACpB;IACD,cAAc,EAAE;QACd,WAAW,EACT,+EAA+E;QACjF,IAAI,EAAE,MAAM;QACZ,WAAW,EAAE,MAAM;KACpB;IACD,WAAW,EAAE;QACX,WAAW,EAAE,mCAAmC;QAChD,IAAI,EAAE,IAAI;QACV,WAAW,EAAE,KAAK;KACnB;IACD,UAAU,EAAE;QACV,WAAW,EAAE,0CAA0C;QACvD,IAAI,EAAE,YAAY;QAClB,WAAW,EAAE,KAAK;KACnB;IACD,oBAAoB,EAAE;QACpB,WAAW,EAAE,uCAAuC;QACpD,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,MAAM;KACpB;IACD,0BAA0B,EAAE;QAC1B,WAAW,EAAE,sCAAsC;QACnD,IAAI,EAAE,KAAK;QACX,WAAW,EAAE,KAAK;KACnB;IACD,2BAA2B,EAAE;QAC3B,WAAW,EAAE,4CAA4C;QACzD,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,KAAK;KACnB;IACD,SAAS,EAAE;QACT,WAAW,EAAE,+CAA+C;QAC5D,IAAI,EAAE,SAAS;QACf,WAAW,EAAE,MAAM;KACpB;IACD,eAAe,EAAE;QACf,WAAW,EAAE,+BAA+B;QAC5C,IAAI,EAAE,SAAS;QACf,WAAW,EAAE,KAAK;KACnB;IACD,iBAAiB,EAAE;QACjB,WAAW,EAAE,2BAA2B;QACxC,IAAI,EAAE,OAAO;QACb,WAAW,EAAE,MAAM;KACpB;CACF,CAAC","sourcesContent":["import {Parameters} from '../types/parameters';\n\nexport const PARAMETERS: Parameters = {\n  carbon: {\n    description: 'an amount of carbon emitted into the atmosphere',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  'cpu/number-cores': {\n    description: 'number of cores available',\n    unit: 'cores',\n    aggregation: 'none',\n  },\n  'cpu/utilization': {\n    description: 'refers to CPU utilization.',\n    unit: 'percentage',\n    aggregation: 'avg',\n  },\n  'disk-io': {\n    description: 'refers to GB of data written/read from disk',\n    unit: 'GB',\n    aggregation: 'sum',\n  },\n  duration: {\n    description: 'refers to the duration of the input',\n    unit: 'seconds',\n    aggregation: 'sum',\n  },\n  energy: {\n    description: 'amount of energy utilised by the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'cpu/energy': {\n    description: 'Energy consumed by the CPU of the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'device/expected-lifespan': {\n    description: 'Total Expected Lifespan of the Component in Seconds',\n    unit: 'seconds',\n    aggregation: 'sum',\n  },\n  'memory/energy': {\n    description: 'Energy consumed by the Memory of the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'carbon-embodied': {\n    description: 'Embodied Emissions of the component',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  'network/energy': {\n    description: 'Energy consumed by the Network of the component',\n    unit: 'kWh',\n    aggregation: 'sum',\n  },\n  'functional-unit': {\n    description:\n      'the name of the functional unit in which the final SCI value should be expressed, e.g. requests, users',\n    unit: 'none',\n    aggregation: 'sum',\n  },\n  'functional-unit-time': {\n    description:\n      'string describing the unit of time in which the final SCI calculation should be expressed, e.g. \"1-min\"',\n    unit: 'none',\n    aggregation: 'none',\n  },\n  'gpu-util': {\n    description: 'refers to CPU utilization.',\n    unit: 'percentage',\n    aggregation: 'avg',\n  },\n  'grid/carbon-intensity': {\n    description: 'Carbon intensity for the grid',\n    unit: 'gCO2eq/kWh',\n    aggregation: 'avg',\n  },\n  'cloud/instance-type': {\n    description: 'Type of Cloud Instance name used in the cloud provider APIs',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  geolocation: {\n    description:\n      'Geographic location of provider as string (for watt-time model it is provided as latitude and longitude, comma separated, in decimal degrees)',\n    unit: 'None (decimal degrees for watt-time model)',\n    aggregation: 'none',\n  },\n  'carbon-operational': {\n    description: 'Operational Emissions of the component',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  'cpu/name': {\n    description: 'Name of the physical processor',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'cloud/vendor': {\n    description:\n      'Name of the cloud service provider in the ccf model. Can be aws, gcp or azure',\n    unit: 'None',\n    aggregation: 'none',\n  },\n  'ram-alloc': {\n    description: 'refers to GB of memory allocated.',\n    unit: 'GB',\n    aggregation: 'avg',\n  },\n  'ram-util': {\n    description: 'refers to percentage of memory utilized.',\n    unit: 'percentage',\n    aggregation: 'avg',\n  },\n  'resources-reserved': {\n    description: 'resources reserved for an application',\n    unit: 'count',\n    aggregation: 'none',\n  },\n  'cpu/thermal-design-power': {\n    description: 'thermal design power for a processor',\n    unit: 'kwh',\n    aggregation: 'avg',\n  },\n  'device/emissions-embodied': {\n    description: 'total embodied emissions of some component',\n    unit: 'gCO2e',\n    aggregation: 'sum',\n  },\n  timestamp: {\n    description: 'refers to the time of occurrence of the input',\n    unit: 'RFC3339',\n    aggregation: 'none',\n  },\n  'time-reserved': {\n    description: 'time reserved for a component',\n    unit: 'seconds',\n    aggregation: 'avg',\n  },\n  'resources-total': {\n    description: 'total resources available',\n    unit: 'count',\n    aggregation: 'none',\n  },\n};\n"]}

package/build/config/strings.d.ts

@@ -1,19 +1,25 @@
-import { ClassContainerParams } from '../types/models-universe';
+import { ManifestParameter } from '../types/parameters';
 export declare const STRINGS: {
     FILE_IS_NOT_YAML: string;
-    IMPL_IS_MISSING: string;
-    MISSING_CLASSNAME: string;
+    MANIFEST_IS_MISSING: string;
+    MISSING_METHOD: string;
     MISSING_PATH: string;
-    NOT_MODEL_PLUGIN_EXTENSION: string;
-    STRUCTURE_MALFORMED: (childName: string) => string;
-    NOT_INITIALIZED_MODEL: (className: string) => string;
+    UNSUPPORTED_PLUGIN: string;
+    OVERRIDE_WARNING: string;
     DISCLAIMER_MESSAGE: string;
-    NOT_NATIVE_MODEL: string;
+    NOT_NATIVE_PLUGIN: string;
     SOMETHING_WRONG: string;
     ISSUE_TEMPLATE: string;
-    NOT_CONSTRUCTABLE_MODEL: (params: ClassContainerParams) => string;
     INVALID_MODULE_PATH: (path: string) => string;
     INVALID_TIME_NORMALIZATION: string;
+    UNEXPECTED_TIME_CONFIG: string;
     INVALID_TIME_INTERVAL: string;
+    AVOIDING_PADDING: (description: string) => string;
+    AVOIDING_PADDING_BY_EDGES: (start: boolean, end: boolean) => string;
     INVALID_OBSERVATION_OVERLAP: string;
+    INVALID_AGGREGATION_METHOD: (metric: string) => string;
+    METRIC_MISSING: (metric: string, index: number) => string;
+    INVALID_GROUP_BY: (type: string) => string;
+    REJECTING_OVERRIDE: (param: ManifestParameter) => string;
+    INVALID_EXHAUST_PLUGIN: (pluginName: string) => string;
 };

package/build/config/strings.js

@@ -2,33 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STRINGS = void 0;
 exports.STRINGS = {
-    FILE_IS_NOT_YAML: 'Provided impl file is not in yaml format.',
-    IMPL_IS_MISSING: 'Impl file is missing.',
-    MISSING_CLASSNAME: "Initalization param 'model' is missing.",
+    FILE_IS_NOT_YAML: 'Provided manifest is not in yaml format.',
+    MANIFEST_IS_MISSING: 'Manifest is missing.',
+    MISSING_METHOD: "Initalization param 'method' is missing.",
     MISSING_PATH: "Initalization param 'path' is missing.",
-    NOT_MODEL_PLUGIN_EXTENSION: "Provided model does not extend 'ModelPluginInterface'.",
-    STRUCTURE_MALFORMED: (childName) => `Graph is malformed: graph.children.${childName} is not valid.`,
-    NOT_INITIALIZED_MODEL: (className) => `You're trying to use not initalized model: ${className}.`,
+    UNSUPPORTED_PLUGIN: "Plugin interface doesn't implement 'execute' or 'metadata' methods.",
+    OVERRIDE_WARNING: '\n**WARNING**: You are overriding the IF default parameters file. Please be extremely careful of unintended side-effects in your plugin pipeline!\n',
     DISCLAIMER_MESSAGE: `
 [!important] Incubation Project
 
-This project is an incubation project being run inside the Green Software Foundation; as such, we *DON’T recommend using it in any critical use case. 
+This project is an incubation project being run inside the Green Software Foundation; as such, we DON’T recommend using it in any critical use case. 
 Incubation projects are experimental, offer no support guarantee, have minimal governance and process, and may be retired at any moment. This project may one day graduate, in which case this disclaimer will be removed.
 `,
-    NOT_NATIVE_MODEL: `
+    NOT_NATIVE_PLUGIN: `
 [!important]
 
-You are using models that are not part of the Impact Framework standard library. You should do your own research to ensure the models are up to date and accurate. They may not be actively maintained.  
+You are using plugins that are not part of the Impact Framework standard library. You should do your own research to ensure the plugins are up to date and accurate. They may not be actively maintained.  
 `,
     SOMETHING_WRONG: 'Something wrong with cli arguments. Please check docs.',
     ISSUE_TEMPLATE: `
 Impact Framework is an alpha release from the Green Software Foundation and is released to capture early feedback. If you'd like to offer some feedback, please use this issue template: 
 https://github.com/Green-Software-Foundation/if/issues/new?assignees=&labels=feedback&projects=&template=feedback.md&title=Feedback+-+
 `,
-    NOT_CONSTRUCTABLE_MODEL: (params) => `Provided model '${params.model}' is not constructable or does not belong to given plugin '${params.path}'.`,
-    INVALID_MODULE_PATH: (path) => `Provided module path: '${path}' is invalid.`,
+    INVALID_MODULE_PATH: (path) => `Provided module path: '${path}' is invalid or not found.`,
     INVALID_TIME_NORMALIZATION: 'Start time or end time is missing.',
+    UNEXPECTED_TIME_CONFIG: 'Unexpected node-level config provided for time-sync plugin.',
     INVALID_TIME_INTERVAL: 'Interval is missing.',
+    AVOIDING_PADDING: (description) => `Avoiding padding at ${description}`,
+    AVOIDING_PADDING_BY_EDGES: (start, end) => `Avoiding padding at ${start && end ? 'start and end' : start ? 'start' : 'end'}`,
     INVALID_OBSERVATION_OVERLAP: 'Observation timestamps overlap.',
+    INVALID_AGGREGATION_METHOD: (metric) => `Aggregation is not possible for given ${metric} since method is 'none'.`,
+    METRIC_MISSING: (metric, index) => `Aggregation metric ${metric} is not found in inputs[${index}].`,
+    INVALID_GROUP_BY: (type) => `Invalid group ${type}.`,
+    REJECTING_OVERRIDE: (param) => `Rejecting overriding of canonical parameter: ${param.name}.`,
+    INVALID_EXHAUST_PLUGIN: (pluginName) => `Invalid exhaust plugin: ${pluginName}.`,
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/index.js

@@ -1,53 +1,33 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const models_universe_1 = require("./lib/models-universe");
-const supercomputer_1 = require("./lib/supercomputer");
+const aggregate_1 = require("./lib/aggregate");
+const compute_1 = require("./lib/compute");
+const exhaust_1 = require("./lib/exhaust");
+const initialize_1 = require("./lib/initialize");
+const load_1 = require("./lib/load");
+const parameterize_1 = require("./lib/parameterize");
 const args_1 = require("./util/args");
 const errors_1 = require("./util/errors");
 const helpers_1 = require("./util/helpers");
-const validations_1 = require("./util/validations");
-const yaml_1 = require("./util/yaml");
+const logger_1 = require("./util/logger");
 const config_1 = require("./config");
 const { CliInputError } = errors_1.ERRORS;
 const { DISCLAIMER_MESSAGE, SOMETHING_WRONG } = config_1.STRINGS;
-/**
- * 1. Parses yml input/output process arguments.
- * 2. Opens yaml file as an object.
- * 3. Validates given impl to match basic structure.
- * 4. Initializes requested models.
- * 5. Initializes graph, does computing.
- * 6. Saves processed object as a yaml file.
- * @example run `npm run impact-engine -- --impl ./test.yml --ompl ./result.yml`
- */
 const impactEngine = async () => {
-    console.log(DISCLAIMER_MESSAGE);
-    const processParams = (0, args_1.parseProcessArgument)();
-    if (processParams) {
-        const { inputPath, outputPath } = processParams;
-        const rawImpl = await (0, yaml_1.openYamlFileAsObject)(inputPath);
-        // Lifecycle Validation
-        const impl = (0, validations_1.validateImpl)(rawImpl);
-        // Lifecycle Initialize Models
-        const modelsHandbook = new models_universe_1.ModelsUniverse();
-        for (const model of impl.initialize.models) {
-            await modelsHandbook.writeDown(model);
-        }
-        // Lifecycle Computing
-        const engine = new supercomputer_1.Supercomputer(impl, modelsHandbook);
-        const ompl = await engine.compute();
-        if (impl.aggregation) {
-            const aggregations = engine.calculateAggregation();
-            ompl['aggregated-outputs'] = aggregations;
-        }
-        if (!outputPath) {
-            console.log(JSON.stringify(ompl));
-            return;
-        }
-        await (0, yaml_1.saveYamlFileAs)(ompl, outputPath);
+    logger_1.logger.info(DISCLAIMER_MESSAGE);
+    const options = (0, args_1.parseArgs)();
+    if (options) {
+        const { inputPath, outputPath, paramPath } = options;
+        const { tree, context, parameters } = await (0, load_1.load)(inputPath, paramPath);
+        parameterize_1.parameterize.combine(context.params, parameters);
+        const plugins = await (0, initialize_1.initalize)(context.initialize.plugins);
+        const computedTree = await (0, compute_1.compute)(tree, { context, plugins });
+        const aggregatedTree = (0, aggregate_1.aggregate)(computedTree, context.aggregation);
+        (0, exhaust_1.exhaust)(aggregatedTree, context, outputPath);
         return;
     }
     return Promise.reject(new CliInputError(SOMETHING_WRONG));
 };
 impactEngine().catch(helpers_1.andHandle);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/aggregate.d.ts

@@ -0,0 +1,6 @@
+import { AggregationParams } from '../types/manifest';
+/**
+ * If aggregation is disabled, then returns given `tree`.
+ * Otherwise creates copy of the tree, then applies aggregation to it.
+ */
+export declare const aggregate: (tree: any, aggregationParams?: AggregationParams) => any;

package/build/lib/aggregate.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregate = void 0;
+const aggregation_helper_1 = require("../util/aggregation-helper");
+/**
+ * Gets `i`th element from all children outputs and collects them in single array.
+ */
+const getIthElementsFromChildren = (children, i) => {
+    const values = Object.values(children);
+    return values.map((value) => {
+        const output = value.outputs;
+        return output[i];
+    });
+};
+/**
+ * 1. Gets the i'th element from each childrens outputs (treating children as rows and we are after a column of data).
+ * 2. Now we just aggregate over the `ithSliceOfOutputs` the same as we did for the normal outputs.
+ */
+const temporalAggregation = (node, metrics) => {
+    const outputs = [];
+    const values = Object.values(node.children);
+    for (let i = 0; i < values[0].outputs.length; i++) {
+        const ithSliceOfOutputs = getIthElementsFromChildren(node.children, i);
+        outputs.push((0, aggregation_helper_1.aggregateInputsIntoOne)(ithSliceOfOutputs, metrics));
+    }
+    return outputs;
+};
+/**
+ * Navigates the tree depth first, bottom up,
+ *  left to right aggregating the component nodes and then the grouping nodes will be aggregated
+ *  only when all their child nodes have been aggregated.
+ * 1. Aggregates all the children.
+ * 2. At this point you can be positive all your children have been aggregated and so you can now work on aggregating yourself.
+ * 3. It's component node, аggregates just the outputs of THIS component node (horizontal/component aggregation).
+ * 4. Else it's grouping node, first does temporal aggregation. This assumes everything is on the same time-grid.
+ *    The outputs of the grouping node are the aggregated time bucketed outputs of it's children.
+ * 5. Now a grouping node has it's own outputs, it can horizotnally aggregate them.
+ */
+const aggregateNode = (node, aggregationParams) => {
+    const { metrics, type } = aggregationParams;
+    if (node.children) {
+        for (const child in node.children) {
+            aggregateNode(node.children[child], aggregationParams);
+        }
+    }
+    if (!node.children) {
+        if (type === 'horizontal' || type === 'both') {
+            node.aggregated = (0, aggregation_helper_1.aggregateInputsIntoOne)(node.outputs, metrics);
+        }
+    }
+    else {
+        if (type === 'vertical' || type === 'both') {
+            const outputs = temporalAggregation(node, metrics);
+            node.outputs = outputs;
+            node.aggregated = (0, aggregation_helper_1.aggregateInputsIntoOne)(outputs, metrics);
+        }
+    }
+};
+/**
+ * If aggregation is disabled, then returns given `tree`.
+ * Otherwise creates copy of the tree, then applies aggregation to it.
+ */
+const aggregate = (tree, aggregationParams) => {
+    if (!aggregationParams || !aggregationParams.type) {
+        return tree;
+    }
+    const copyOfTree = structuredClone(tree);
+    aggregateNode(copyOfTree, aggregationParams);
+    return copyOfTree;
+};
+exports.aggregate = aggregate;
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/compute.d.ts

@@ -0,0 +1,5 @@
+import { ComputeParams } from '../types/compute';
+/**
+ * Creates copy of existing tree, then applies computing strategy.
+ */
+export declare const compute: (tree: any, params: ComputeParams) => Promise<any>;

package/build/lib/compute.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compute = void 0;
+const helpers_1 = require("../util/helpers");
+/**
+ * Traverses all child nodes based on children grouping.
+ */
+const traverse = async (children, params) => {
+    for (const child in children) {
+        await computeNode(children[child], params);
+    }
+};
+/**
+ * Appends `default` values to `inputs`.
+ */
+const mergeDefaults = (inputs, defaults) => {
+    if (inputs) {
+        const response = defaults
+            ? inputs.map(input => (0, helpers_1.mergeObjects)(input, defaults))
+            : inputs;
+        return response;
+    }
+    return [];
+};
+/**
+ * 1. If the node has it's own pipeline, defaults or config then use that,
+ *    otherwise use whatever has been passed down from further up the tree.
+ * 2. If it's a grouping node, then first of all computes all it's children.
+ *    This is doing a depth first traversal.
+ * 3. Otherwise merges the defaults into the inputs.
+ * 4. Goes through the pipeline plugins, by checking if it's `execute` plugin. If so sets outputs.
+ *    If is a `groupby` plugin, it will return child components rather than outputs.
+ * 5. Since after `groupby`, there are new child components, then computes them.
+ *    Note: `pipeline` now equals the remaining plu.gins to apply to each child
+ */
+const computeNode = async (node, params) => {
+    const pipeline = (node.pipeline || params.pipeline);
+    const config = node.config || params.config;
+    const defaults = node.defaults || params.defaults;
+    if (node.children) {
+        return traverse(node.children, {
+            ...params,
+            pipeline,
+            defaults,
+            config,
+        });
+    }
+    let storage = node.inputs;
+    storage = mergeDefaults(storage, defaults);
+    const pipelineCopy = structuredClone(pipeline);
+    while (pipelineCopy.length !== 0) {
+        const pluginName = pipelineCopy.shift();
+        const plugin = params.plugins[pluginName];
+        const { execute, metadata } = plugin;
+        const nodeConfig = config && config[pluginName];
+        if (metadata.kind === 'execute') {
+            storage = await execute(storage, nodeConfig);
+            node.outputs = storage;
+        }
+        if (metadata.kind === 'groupby') {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            node.children = await execute(storage, nodeConfig);
+            delete node.inputs;
+            delete node.outputs;
+            await traverse(node.children, {
+                ...params,
+                pipeline: pipelineCopy,
+                defaults,
+                config,
+            });
+        }
+    }
+};
+/**
+ * Creates copy of existing tree, then applies computing strategy.
+ */
+const compute = async (tree, params) => {
+    const copyOfTree = structuredClone(tree);
+    await computeNode(copyOfTree, params);
+    return copyOfTree;
+};
+exports.compute = compute;
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/exhaust.d.ts

@@ -0,0 +1,6 @@
+import { Context } from '../types/manifest';
+/**
+ * Output manager - Exhaust.
+ * Grabs output plugins from context, executes every.
+ */
+export declare const exhaust: (tree: any, context: Context, outputPath?: string) => void;

package/build/lib/exhaust.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exhaust = void 0;
+/**
+ * @todo This is temporary solution, will be refactored to support dynamic plugins.
+ */
+const export_csv_1 = require("../models/export-csv");
+const export_log_1 = require("../models/export-log");
+const export_yaml_1 = require("../models/export-yaml");
+const errors_1 = require("../util/errors");
+const config_1 = require("../config");
+const { ModuleInitializationError } = errors_1.ERRORS;
+const { INVALID_EXHAUST_PLUGIN } = config_1.STRINGS;
+/**
+ * Initialize exhaust plugins based on the provided config
+ */
+const initializeExhaustPlugins = (plugins) => plugins.map(initializeExhaustPlugin);
+/**
+ * factory method for exhaust plugins
+ */
+const initializeExhaustPlugin = (name) => {
+    switch (name) {
+        case 'yaml':
+            return (0, export_yaml_1.ExportYaml)();
+        case 'csv':
+            return (0, export_csv_1.ExportCsv)();
+        case 'log':
+            return (0, export_log_1.ExportLog)();
+        default:
+            throw new ModuleInitializationError(INVALID_EXHAUST_PLUGIN(name));
+    }
+};
+/**
+ * Output manager - Exhaust.
+ * Grabs output plugins from context, executes every.
+ */
+const exhaust = (tree, context, outputPath) => {
+    const outputPlugins = context.initialize.outputs;
+    if (!outputPlugins) {
+        (0, export_log_1.ExportLog)().execute(tree, context);
+        return;
+    }
+    const exhaustPlugins = initializeExhaustPlugins(outputPlugins);
+    exhaustPlugins.forEach(plugin => plugin.execute(tree, context, outputPath));
+};
+exports.exhaust = exhaust;
+//# sourceMappingURL=data:application/json;base64,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

package/build/lib/initialize.d.ts

@@ -0,0 +1,6 @@
+import { PluginsStorage } from '../types/initialize';
+import { GlobalPlugins } from '../types/manifest';
+/**
+ * Registers all plugins from `manifest`.`initalize` property.
+ */
+export declare const initalize: (plugins: GlobalPlugins) => Promise<PluginsStorage>;