@grnsft/if 0.1.9 → 0.2.1

package/build/config/strings.d.ts

@@ -1,24 +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;
+    UNSUPPORTED_PLUGIN: string;
     OVERRIDE_WARNING: string;
-    NOT_MODEL_PLUGIN_EXTENSION: string;
-    STRUCTURE_MALFORMED: (childName: string) => string;
-    NOT_INITIALIZED_MODEL: (className: string) => 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,38 +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.",
+    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',
-    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}.`,
     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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5ncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb25maWcvc3RyaW5ncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFYSxRQUFBLE9BQU8sR0FBRztJQUNyQixnQkFBZ0IsRUFBRSwyQ0FBMkM7SUFDN0QsZUFBZSxFQUFFLHVCQUF1QjtJQUN4QyxpQkFBaUIsRUFBRSx5Q0FBeUM7SUFDNUQsWUFBWSxFQUFFLHdDQUF3QztJQUN0RCxnQkFBZ0IsRUFDZCxxSkFBcUo7SUFDdkosMEJBQTBCLEVBQ3hCLHdEQUF3RDtJQUMxRCxtQkFBbUIsRUFBRSxDQUFDLFNBQWlCLEVBQUUsRUFBRSxDQUN6QyxzQ0FBc0MsU0FBUyxnQkFBZ0I7SUFDakUscUJBQXFCLEVBQUUsQ0FBQyxTQUFpQixFQUFFLEVBQUUsQ0FDM0MsOENBQThDLFNBQVMsR0FBRztJQUM1RCxrQkFBa0IsRUFBRTs7Ozs7Q0FLckI7SUFDQyxnQkFBZ0IsRUFBRTs7OztDQUluQjtJQUNDLGVBQWUsRUFBRSx3REFBd0Q7SUFDekUsY0FBYyxFQUFFOzs7Q0FHakI7SUFDQyx1QkFBdUIsRUFBRSxDQUFDLE1BQTRCLEVBQUUsRUFBRSxDQUN4RCxtQkFBbUIsTUFBTSxDQUFDLEtBQUssOERBQThELE1BQU0sQ0FBQyxJQUFJLElBQUk7SUFDOUcsbUJBQW1CLEVBQUUsQ0FBQyxJQUFZLEVBQUUsRUFBRSxDQUNwQywwQkFBMEIsSUFBSSxlQUFlO0lBQy9DLDBCQUEwQixFQUFFLG9DQUFvQztJQUNoRSxxQkFBcUIsRUFBRSxzQkFBc0I7SUFDN0MsZ0JBQWdCLEVBQUUsQ0FBQyxXQUFtQixFQUFFLEVBQUUsQ0FDeEMsdUJBQXVCLFdBQVcsRUFBRTtJQUN0Qyx5QkFBeUIsRUFBRSxDQUFDLEtBQWMsRUFBRSxHQUFZLEVBQUUsRUFBRSxDQUMxRCx1QkFDRSxLQUFLLElBQUksR0FBRyxDQUFDLENBQUMsQ0FBQyxlQUFlLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxLQUNyRCxFQUFFO0lBQ0osMkJBQTJCLEVBQUUsaUNBQWlDO0lBQzlELDBCQUEwQixFQUFFLENBQUMsTUFBYyxFQUFFLEVBQUUsQ0FDN0MseUNBQXlDLE1BQU0sMEJBQTBCO0lBQzNFLGNBQWMsRUFBRSxDQUFDLE1BQWMsRUFBRSxLQUFhLEVBQUUsRUFBRSxDQUNoRCxzQkFBc0IsTUFBTSwyQkFBMkIsS0FBSyxJQUFJO0NBQ25FLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NsYXNzQ29udGFpbmVyUGFyYW1zfSBmcm9tICcuLi90eXBlcy9tb2RlbHMtdW5pdmVyc2UnO1xuXG5leHBvcnQgY29uc3QgU1RSSU5HUyA9IHtcbiAgRklMRV9JU19OT1RfWUFNTDogJ1Byb3ZpZGVkIGltcGwgZmlsZSBpcyBub3QgaW4geWFtbCBmb3JtYXQuJyxcbiAgSU1QTF9JU19NSVNTSU5HOiAnSW1wbCBmaWxlIGlzIG1pc3NpbmcuJyxcbiAgTUlTU0lOR19DTEFTU05BTUU6IFwiSW5pdGFsaXphdGlvbiBwYXJhbSAnbW9kZWwnIGlzIG1pc3NpbmcuXCIsXG4gIE1JU1NJTkdfUEFUSDogXCJJbml0YWxpemF0aW9uIHBhcmFtICdwYXRoJyBpcyBtaXNzaW5nLlwiLFxuICBPVkVSUklERV9XQVJOSU5HOlxuICAgICdcXG4qKldBUk5JTkcqKjogWW91IGFyZSBvdmVycmlkaW5nIHRoZSBJRiBkZWZhdWx0IHBhcmFtZXRlcnMgZmlsZS4gUGxlYXNlIGJlIGV4dHJlbWVseSBjYXJlZnVsIG9mIHVuaW50ZW5kZWQgc2lkZS1lZmZlY3RzIGluIHlvdXIgcGx1Z2luIHBpcGVsaW5lIVxcbicsXG4gIE5PVF9NT0RFTF9QTFVHSU5fRVhURU5TSU9OOlxuICAgIFwiUHJvdmlkZWQgbW9kZWwgZG9lcyBub3QgZXh0ZW5kICdNb2RlbFBsdWdpbkludGVyZmFjZScuXCIsXG4gIFNUUlVDVFVSRV9NQUxGT1JNRUQ6IChjaGlsZE5hbWU6IHN0cmluZykgPT5cbiAgICBgR3JhcGggaXMgbWFsZm9ybWVkOiBncmFwaC5jaGlsZHJlbi4ke2NoaWxkTmFtZX0gaXMgbm90IHZhbGlkLmAsXG4gIE5PVF9JTklUSUFMSVpFRF9NT0RFTDogKGNsYXNzTmFtZTogc3RyaW5nKSA9PlxuICAgIGBZb3UncmUgdHJ5aW5nIHRvIHVzZSBub3QgaW5pdGFsaXplZCBtb2RlbDogJHtjbGFzc05hbWV9LmAsXG4gIERJU0NMQUlNRVJfTUVTU0FHRTogYFxuWyFpbXBvcnRhbnRdIEluY3ViYXRpb24gUHJvamVjdFxuXG5UaGlzIHByb2plY3QgaXMgYW4gaW5jdWJhdGlvbiBwcm9qZWN0IGJlaW5nIHJ1biBpbnNpZGUgdGhlIEdyZWVuIFNvZnR3YXJlIEZvdW5kYXRpb247IGFzIHN1Y2gsIHdlICpET07igJlUIHJlY29tbWVuZCB1c2luZyBpdCBpbiBhbnkgY3JpdGljYWwgdXNlIGNhc2UuIFxuSW5jdWJhdGlvbiBwcm9qZWN0cyBhcmUgZXhwZXJpbWVudGFsLCBvZmZlciBubyBzdXBwb3J0IGd1YXJhbnRlZSwgaGF2ZSBtaW5pbWFsIGdvdmVybmFuY2UgYW5kIHByb2Nlc3MsIGFuZCBtYXkgYmUgcmV0aXJlZCBhdCBhbnkgbW9tZW50LiBUaGlzIHByb2plY3QgbWF5IG9uZSBkYXkgZ3JhZHVhdGUsIGluIHdoaWNoIGNhc2UgdGhpcyBkaXNjbGFpbWVyIHdpbGwgYmUgcmVtb3ZlZC5cbmAsXG4gIE5PVF9OQVRJVkVfTU9ERUw6IGBcblshaW1wb3J0YW50XVxuXG5Zb3UgYXJlIHVzaW5nIG1vZGVscyB0aGF0IGFyZSBub3QgcGFydCBvZiB0aGUgSW1wYWN0IEZyYW1ld29yayBzdGFuZGFyZCBsaWJyYXJ5LiBZb3Ugc2hvdWxkIGRvIHlvdXIgb3duIHJlc2VhcmNoIHRvIGVuc3VyZSB0aGUgbW9kZWxzIGFyZSB1cCB0byBkYXRlIGFuZCBhY2N1cmF0ZS4gVGhleSBtYXkgbm90IGJlIGFjdGl2ZWx5IG1haW50YWluZWQuICBcbmAsXG4gIFNPTUVUSElOR19XUk9ORzogJ1NvbWV0aGluZyB3cm9uZyB3aXRoIGNsaSBhcmd1bWVudHMuIFBsZWFzZSBjaGVjayBkb2NzLicsXG4gIElTU1VFX1RFTVBMQVRFOiBgXG5JbXBhY3QgRnJhbWV3b3JrIGlzIGFuIGFscGhhIHJlbGVhc2UgZnJvbSB0aGUgR3JlZW4gU29mdHdhcmUgRm91bmRhdGlvbiBhbmQgaXMgcmVsZWFzZWQgdG8gY2FwdHVyZSBlYXJseSBmZWVkYmFjay4gSWYgeW91J2QgbGlrZSB0byBvZmZlciBzb21lIGZlZWRiYWNrLCBwbGVhc2UgdXNlIHRoaXMgaXNzdWUgdGVtcGxhdGU6IFxuaHR0cHM6Ly9naXRodWIuY29tL0dyZWVuLVNvZnR3YXJlLUZvdW5kYXRpb24vaWYvaXNzdWVzL25ldz9hc3NpZ25lZXM9JmxhYmVscz1mZWVkYmFjayZwcm9qZWN0cz0mdGVtcGxhdGU9ZmVlZGJhY2subWQmdGl0bGU9RmVlZGJhY2srLStcbmAsXG4gIE5PVF9DT05TVFJVQ1RBQkxFX01PREVMOiAocGFyYW1zOiBDbGFzc0NvbnRhaW5lclBhcmFtcykgPT5cbiAgICBgUHJvdmlkZWQgbW9kZWwgJyR7cGFyYW1zLm1vZGVsfScgaXMgbm90IGNvbnN0cnVjdGFibGUgb3IgZG9lcyBub3QgYmVsb25nIHRvIGdpdmVuIHBsdWdpbiAnJHtwYXJhbXMucGF0aH0nLmAsXG4gIElOVkFMSURfTU9EVUxFX1BBVEg6IChwYXRoOiBzdHJpbmcpID0+XG4gICAgYFByb3ZpZGVkIG1vZHVsZSBwYXRoOiAnJHtwYXRofScgaXMgaW52YWxpZC5gLFxuICBJTlZBTElEX1RJTUVfTk9STUFMSVpBVElPTjogJ1N0YXJ0IHRpbWUgb3IgZW5kIHRpbWUgaXMgbWlzc2luZy4nLFxuICBJTlZBTElEX1RJTUVfSU5URVJWQUw6ICdJbnRlcnZhbCBpcyBtaXNzaW5nLicsXG4gIEFWT0lESU5HX1BBRERJTkc6IChkZXNjcmlwdGlvbjogc3RyaW5nKSA9PlxuICAgIGBBdm9pZGluZyBwYWRkaW5nIGF0ICR7ZGVzY3JpcHRpb259YCxcbiAgQVZPSURJTkdfUEFERElOR19CWV9FREdFUzogKHN0YXJ0OiBib29sZWFuLCBlbmQ6IGJvb2xlYW4pID0+XG4gICAgYEF2b2lkaW5nIHBhZGRpbmcgYXQgJHtcbiAgICAgIHN0YXJ0ICYmIGVuZCA/ICdzdGFydCBhbmQgZW5kJyA6IHN0YXJ0ID8gJ3N0YXJ0JyA6ICdlbmQnXG4gICAgfWAsXG4gIElOVkFMSURfT0JTRVJWQVRJT05fT1ZFUkxBUDogJ09ic2VydmF0aW9uIHRpbWVzdGFtcHMgb3ZlcmxhcC4nLFxuICBJTlZBTElEX0FHR1JFR0FUSU9OX01FVEhPRDogKG1ldHJpYzogc3RyaW5nKSA9PlxuICAgIGBBZ2dyZWdhdGlvbiBpcyBub3QgcG9zc2libGUgZm9yIGdpdmVuICR7bWV0cmljfSBzaW5jZSBtZXRob2QgaXMgJ25vbmUnLmAsXG4gIE1FVFJJQ19NSVNTSU5HOiAobWV0cmljOiBzdHJpbmcsIGluZGV4OiBudW1iZXIpID0+XG4gICAgYEFnZ3JlZ2F0aW9uIG1ldHJpYyAke21ldHJpY30gaXMgbm90IGZvdW5kIGluIGlucHV0c1ske2luZGV4fV0uYCxcbn07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/build/index.js

@@ -1,83 +1,33 @@
 #!/usr/bin/env node
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs = __importStar(require("node:fs"));
-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 packageJson = require('../package.json');
 const { CliInputError } = errors_1.ERRORS;
-const { DISCLAIMER_MESSAGE, OVERRIDE_WARNING, 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 { DISCLAIMER_MESSAGE, SOMETHING_WRONG } = config_1.STRINGS;
 const impactEngine = async () => {
-    console.log(DISCLAIMER_MESSAGE);
-    const processParams = (0, args_1.parseProcessArgument)();
-    if (processParams) {
-        const { paramPath, inputPath, outputPath } = processParams;
-        const rawImpl = await (0, yaml_1.openYamlFileAsObject)(inputPath);
-        if (paramPath) {
-            console.warn(OVERRIDE_WARNING);
-        }
-        /** Lifecycle Validation */
-        const impl = (0, validations_1.validateImpl)(rawImpl);
-        /**
-         * Checks if override params path is passed, then reads that file.
-         * Then checks if param is new, then appends it to existing parameters.
-         * Otherwise warns user about rejected overriding.
-         */
-        const overridingParams = paramPath && JSON.parse(fs.readFileSync(paramPath, 'utf-8'));
-        const parameters = overridingParams || config_1.PARAMETERS;
-        /** Lifecycle Initialize Models */
-        const modelsHandbook = await new models_universe_1.ModelsUniverse().bulkWriteDown(impl.initialize.models);
-        /** Lifecycle Computing */
-        const computer = await new supercomputer_1.Supercomputer(impl, modelsHandbook, parameters);
-        computer.overrideOrAppendParams(parameters);
-        const outputData = await computer.compute();
-        outputData['if-version'] = packageJson.version;
-        if (!outputPath) {
-            console.log(JSON.stringify(outputData, null, 4));
-            return;
-        }
-        await (0, yaml_1.saveYamlFileAs)(outputData, 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>;

package/build/lib/initialize.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initalize = void 0;
+const pathLib = require("path");
+const errors_1 = require("../util/errors");
+const logger_1 = require("../util/logger");
+const config_1 = require("../config");
+const { ModuleInitializationError, PluginCredentialError } = errors_1.ERRORS;
+const { GITHUB_PATH, NATIVE_PLUGIN } = config_1.CONFIG;
+const { MISSING_METHOD, MISSING_PATH, NOT_NATIVE_PLUGIN, INVALID_MODULE_PATH } = config_1.STRINGS;
+/**
+ * Imports module by given `path`.
+ */
+const importModuleFrom = async (path) => {
+    try {
+        const module = await Promise.resolve(`${path}`).then(s => __importStar(require(s)));
+        return module;
+    }
+    catch (error) {
+        throw new ModuleInitializationError(INVALID_MODULE_PATH(path));
+    }
+};
+/**
+ * Imports `module` from given `path`, then checks if it's `ModelPluginInterface` extension.
+ */
+const importAndVerifyModule = async (method, path) => {
+    const pluginModule = await importModuleFrom(path);
+    return pluginModule[method];
+};
+/**
+ * Checks if plugin is missing then rejects with error.
+ * Then checks if `path` is starting with github, then grabs the repository name.
+ * Imports module, then checks if it's a valid plugin.
+ */
+const handModule = (method, path) => {
+    if (path === 'builtin') {
+        path = pathLib.normalize(`${__dirname}/../models`);
+    }
+    else {
+        if (path?.startsWith(GITHUB_PATH)) {
+            const parts = path.split('/');
+            path = parts[parts.length - 1];
+        }
+        if (!path.includes(NATIVE_PLUGIN)) {
+            logger_1.logger.warn(NOT_NATIVE_PLUGIN);
+        }
+    }
+    return importAndVerifyModule(method, path);
+};
+/**
+ * Initializes plugin with global config.
+ */
+const initPlugin = async (initPluginParams) => {
+    const { method, path, 'global-config': globalConfig } = initPluginParams;
+    if (!method) {
+        throw new PluginCredentialError(MISSING_METHOD);
+    }
+    if (!path) {
+        throw new PluginCredentialError(MISSING_PATH);
+    }
+    const plugin = await handModule(method, path);
+    return plugin(globalConfig);
+};
+/**
+ * Registers all plugins from `manifest`.`initalize` property.
+ */
+const initalize = async (plugins) => {
+    const storage = {};
+    for await (const pluginName of Object.keys(plugins)) {
+        storage[pluginName] = await initPlugin(plugins[pluginName]);
+    }
+    return storage;
+};
+exports.initalize = initalize;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5pdGlhbGl6ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saWIvaW5pdGlhbGl6ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGdDQUFpQztBQUVqQywyQ0FBc0M7QUFDdEMsMkNBQXNDO0FBRXRDLHNDQUEwQztBQU0xQyxNQUFNLEVBQUMseUJBQXlCLEVBQUUscUJBQXFCLEVBQUMsR0FBRyxlQUFNLENBQUM7QUFFbEUsTUFBTSxFQUFDLFdBQVcsRUFBRSxhQUFhLEVBQUMsR0FBRyxlQUFNLENBQUM7QUFDNUMsTUFBTSxFQUFDLGNBQWMsRUFBRSxZQUFZLEVBQUUsaUJBQWlCLEVBQUUsbUJBQW1CLEVBQUMsR0FDMUUsZ0JBQU8sQ0FBQztBQUVWOztHQUVHO0FBQ0gsTUFBTSxnQkFBZ0IsR0FBRyxLQUFLLEVBQUUsSUFBWSxFQUFFLEVBQUU7SUFDOUMsSUFBSTtRQUNGLE1BQU0sTUFBTSxHQUFHLHlCQUFhLElBQUksdUNBQUMsQ0FBQztRQUVsQyxPQUFPLE1BQU0sQ0FBQztLQUNmO0lBQUMsT0FBTyxLQUFLLEVBQUU7UUFDZCxNQUFNLElBQUkseUJBQXlCLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztLQUNoRTtBQUNILENBQUMsQ0FBQztBQUVGOztHQUVHO0FBQ0gsTUFBTSxxQkFBcUIsR0FBRyxLQUFLLEVBQUUsTUFBYyxFQUFFLElBQVksRUFBRSxFQUFFO0lBQ25FLE1BQU0sWUFBWSxHQUFHLE1BQU0sZ0JBQWdCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFFbEQsT0FBTyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDOUIsQ0FBQyxDQUFDO0FBRUY7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxHQUFHLENBQUMsTUFBYyxFQUFFLElBQVksRUFBRSxFQUFFO0lBQ2xELElBQUksSUFBSSxLQUFLLFNBQVMsRUFBRTtRQUN0QixJQUFJLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxHQUFHLFNBQVMsWUFBWSxDQUFDLENBQUM7S0FDcEQ7U0FBTTtRQUNMLElBQUksSUFBSSxFQUFFLFVBQVUsQ0FBQyxXQUFXLENBQUMsRUFBRTtZQUNqQyxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQzlCLElBQUksR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQztTQUNoQztRQUVELElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FBQyxFQUFFO1lBQ2pDLGVBQU0sQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsQ0FBQztTQUNoQztLQUNGO0lBRUQsT0FBTyxxQkFBcUIsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDN0MsQ0FBQyxDQUFDO0FBRUY7O0dBRUc7QUFDSCxNQUFNLFVBQVUsR0FBRyxLQUFLLEVBQ3RCLGdCQUErQixFQUNMLEVBQUU7SUFDNUIsTUFBTSxFQUFDLE1BQU0sRUFBRSxJQUFJLEVBQUUsZUFBZSxFQUFFLFlBQVksRUFBQyxHQUFHLGdCQUFnQixDQUFDO0lBRXZFLElBQUksQ0FBQyxNQUFNLEVBQUU7UUFDWCxNQUFNLElBQUkscUJBQXFCLENBQUMsY0FBYyxDQUFDLENBQUM7S0FDakQ7SUFFRCxJQUFJLENBQUMsSUFBSSxFQUFFO1FBQ1QsTUFBTSxJQUFJLHFCQUFxQixDQUFDLFlBQVksQ0FBQyxDQUFDO0tBQy9DO0lBRUQsTUFBTSxNQUFNLEdBQUcsTUFBTSxVQUFVLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBRTlDLE9BQU8sTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFDO0FBQzlCLENBQUMsQ0FBQztBQUVGOztHQUVHO0FBQ0ksTUFBTSxTQUFTLEdBQUcsS0FBSyxFQUM1QixPQUFzQixFQUNHLEVBQUU7SUFDM0IsTUFBTSxPQUFPLEdBQW1CLEVBQUUsQ0FBQztJQUVuQyxJQUFJLEtBQUssRUFBRSxNQUFNLFVBQVUsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxFQUFFO1FBQ25ELE9BQU8sQ0FBQyxVQUFVLENBQUMsR0FBRyxNQUFNLFVBQVUsQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztLQUM3RDtJQUVELE9BQU8sT0FBTyxDQUFDO0FBQ2pCLENBQUMsQ0FBQztBQVZXLFFBQUEsU0FBUyxhQVVwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBwYXRoTGliID0gcmVxdWlyZSgncGF0aCcpO1xuXG5pbXBvcnQge0VSUk9SU30gZnJvbSAnLi4vdXRpbC9lcnJvcnMnO1xuaW1wb3J0IHtsb2dnZXJ9IGZyb20gJy4uL3V0aWwvbG9nZ2VyJztcblxuaW1wb3J0IHtDT05GSUcsIFNUUklOR1N9IGZyb20gJy4uL2NvbmZpZyc7XG5cbmltcG9ydCB7UGx1Z2luSW50ZXJmYWNlfSBmcm9tICcuLi90eXBlcy9pbnRlcmZhY2UnO1xuaW1wb3J0IHtQbHVnaW5zU3RvcmFnZX0gZnJvbSAnLi4vdHlwZXMvaW5pdGlhbGl6ZSc7XG5pbXBvcnQge0dsb2JhbFBsdWdpbnMsIFBsdWdpbk9wdGlvbnN9IGZyb20gJy4uL3R5cGVzL21hbmlmZXN0JztcblxuY29uc3Qge01vZHVsZUluaXRpYWxpemF0aW9uRXJyb3IsIFBsdWdpbkNyZWRlbnRpYWxFcnJvcn0gPSBFUlJPUlM7XG5cbmNvbnN0IHtHSVRIVUJfUEFUSCwgTkFUSVZFX1BMVUdJTn0gPSBDT05GSUc7XG5jb25zdCB7TUlTU0lOR19NRVRIT0QsIE1JU1NJTkdfUEFUSCwgTk9UX05BVElWRV9QTFVHSU4sIElOVkFMSURfTU9EVUxFX1BBVEh9ID1cbiAgU1RSSU5HUztcblxuLyoqXG4gKiBJbXBvcnRzIG1vZHVsZSBieSBnaXZlbiBgcGF0aGAuXG4gKi9cbmNvbnN0IGltcG9ydE1vZHVsZUZyb20gPSBhc3luYyAocGF0aDogc3RyaW5nKSA9PiB7XG4gIHRyeSB7XG4gICAgY29uc3QgbW9kdWxlID0gYXdhaXQgaW1wb3J0KHBhdGgpO1xuXG4gICAgcmV0dXJuIG1vZHVsZTtcbiAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICB0aHJvdyBuZXcgTW9kdWxlSW5pdGlhbGl6YXRpb25FcnJvcihJTlZBTElEX01PRFVMRV9QQVRIKHBhdGgpKTtcbiAgfVxufTtcblxuLyoqXG4gKiBJbXBvcnRzIGBtb2R1bGVgIGZyb20gZ2l2ZW4gYHBhdGhgLCB0aGVuIGNoZWNrcyBpZiBpdCdzIGBNb2RlbFBsdWdpbkludGVyZmFjZWAgZXh0ZW5zaW9uLlxuICovXG5jb25zdCBpbXBvcnRBbmRWZXJpZnlNb2R1bGUgPSBhc3luYyAobWV0aG9kOiBzdHJpbmcsIHBhdGg6IHN0cmluZykgPT4ge1xuICBjb25zdCBwbHVnaW5Nb2R1bGUgPSBhd2FpdCBpbXBvcnRNb2R1bGVGcm9tKHBhdGgpO1xuXG4gIHJldHVybiBwbHVnaW5Nb2R1bGVbbWV0aG9kXTtcbn07XG5cbi8qKlxuICogQ2hlY2tzIGlmIHBsdWdpbiBpcyBtaXNzaW5nIHRoZW4gcmVqZWN0cyB3aXRoIGVycm9yLlxuICogVGhlbiBjaGVja3MgaWYgYHBhdGhgIGlzIHN0YXJ0aW5nIHdpdGggZ2l0aHViLCB0aGVuIGdyYWJzIHRoZSByZXBvc2l0b3J5IG5hbWUuXG4gKiBJbXBvcnRzIG1vZHVsZSwgdGhlbiBjaGVja3MgaWYgaXQncyBhIHZhbGlkIHBsdWdpbi5cbiAqL1xuY29uc3QgaGFuZE1vZHVsZSA9IChtZXRob2Q6IHN0cmluZywgcGF0aDogc3RyaW5nKSA9PiB7XG4gIGlmIChwYXRoID09PSAnYnVpbHRpbicpIHtcbiAgICBwYXRoID0gcGF0aExpYi5ub3JtYWxpemUoYCR7X19kaXJuYW1lfS8uLi9tb2RlbHNgKTtcbiAgfSBlbHNlIHtcbiAgICBpZiAocGF0aD8uc3RhcnRzV2l0aChHSVRIVUJfUEFUSCkpIHtcbiAgICAgIGNvbnN0IHBhcnRzID0gcGF0aC5zcGxpdCgnLycpO1xuICAgICAgcGF0aCA9IHBhcnRzW3BhcnRzLmxlbmd0aCAtIDFdO1xuICAgIH1cblxuICAgIGlmICghcGF0aC5pbmNsdWRlcyhOQVRJVkVfUExVR0lOKSkge1xuICAgICAgbG9nZ2VyLndhcm4oTk9UX05BVElWRV9QTFVHSU4pO1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiBpbXBvcnRBbmRWZXJpZnlNb2R1bGUobWV0aG9kLCBwYXRoKTtcbn07XG5cbi8qKlxuICogSW5pdGlhbGl6ZXMgcGx1Z2luIHdpdGggZ2xvYmFsIGNvbmZpZy5cbiAqL1xuY29uc3QgaW5pdFBsdWdpbiA9IGFzeW5jIChcbiAgaW5pdFBsdWdpblBhcmFtczogUGx1Z2luT3B0aW9uc1xuKTogUHJvbWlzZTxQbHVnaW5JbnRlcmZhY2U+ID0+IHtcbiAgY29uc3Qge21ldGhvZCwgcGF0aCwgJ2dsb2JhbC1jb25maWcnOiBnbG9iYWxDb25maWd9ID0gaW5pdFBsdWdpblBhcmFtcztcblxuICBpZiAoIW1ldGhvZCkge1xuICAgIHRocm93IG5ldyBQbHVnaW5DcmVkZW50aWFsRXJyb3IoTUlTU0lOR19NRVRIT0QpO1xuICB9XG5cbiAgaWYgKCFwYXRoKSB7XG4gICAgdGhyb3cgbmV3IFBsdWdpbkNyZWRlbnRpYWxFcnJvcihNSVNTSU5HX1BBVEgpO1xuICB9XG5cbiAgY29uc3QgcGx1Z2luID0gYXdhaXQgaGFuZE1vZHVsZShtZXRob2QsIHBhdGgpO1xuXG4gIHJldHVybiBwbHVnaW4oZ2xvYmFsQ29uZmlnKTtcbn07XG5cbi8qKlxuICogUmVnaXN0ZXJzIGFsbCBwbHVnaW5zIGZyb20gYG1hbmlmZXN0YC5gaW5pdGFsaXplYCBwcm9wZXJ0eS5cbiAqL1xuZXhwb3J0IGNvbnN0IGluaXRhbGl6ZSA9IGFzeW5jIChcbiAgcGx1Z2luczogR2xvYmFsUGx1Z2luc1xuKTogUHJvbWlzZTxQbHVnaW5zU3RvcmFnZT4gPT4ge1xuICBjb25zdCBzdG9yYWdlOiBQbHVnaW5zU3RvcmFnZSA9IHt9O1xuXG4gIGZvciBhd2FpdCAoY29uc3QgcGx1Z2luTmFtZSBvZiBPYmplY3Qua2V5cyhwbHVnaW5zKSkge1xuICAgIHN0b3JhZ2VbcGx1Z2luTmFtZV0gPSBhd2FpdCBpbml0UGx1Z2luKHBsdWdpbnNbcGx1Z2luTmFtZV0pO1xuICB9XG5cbiAgcmV0dXJuIHN0b3JhZ2U7XG59O1xuIl19

package/build/lib/load.d.ts

@@ -0,0 +1,6 @@
+import { ContextTreeParams } from '../types/load';
+/**
+ * Parses manifest file as an object. Checks if parameter file is passed via CLI, then loads it too.
+ * Returns context, tree and parameters (either the default one, or from CLI).
+ */
+export declare const load: (inputPath: string, paramPath?: string) => Promise<ContextTreeParams>;