@grnsft/if 0.7.0 → 0.7.2

package/build/if-env/util/npm.js

@@ -0,0 +1,126 @@
+#!/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 });
+exports.updatePackageJsonProperties = exports.extractPathsWithVersion = exports.updatePackageJsonDependencies = exports.installDependencies = exports.initPackageJsonIfNotExists = void 0;
+/* eslint-disable no-process-exit */
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const helpers_1 = require("../../common/util/helpers");
+const fs_1 = require("../../common/util/fs");
+const logger_1 = require("../../common/util/logger");
+const config_1 = require("../config");
+const packageJson = require('../../../package.json');
+const { INITIALIZING_PACKAGE_JSON, INSTALLING_NPM_PACKAGES } = config_1.STRINGS;
+/**
+ * Checks if the package.json is exists, if not, initializes it.
+ */
+const initPackageJsonIfNotExists = async (folderPath) => {
+    const packageJsonPath = path.resolve(folderPath, 'package.json');
+    const isPackageJsonExists = await (0, fs_1.isFileExists)(packageJsonPath);
+    if (!isPackageJsonExists) {
+        logger_1.logger.info(INITIALIZING_PACKAGE_JSON);
+        const nodeModulesPath = path.resolve(folderPath, 'node_modules');
+        const isNodeModulesExists = await (0, fs_1.isDirectoryExists)(nodeModulesPath);
+        if (isNodeModulesExists) {
+            await fs.rm(nodeModulesPath, { recursive: true });
+        }
+        await (0, helpers_1.execPromise)('npm init -y', { cwd: folderPath });
+    }
+    return packageJsonPath;
+};
+exports.initPackageJsonIfNotExists = initPackageJsonIfNotExists;
+/**
+ * Installs packages from the specified dependencies in the specified folder.
+ */
+const installDependencies = async (folderPath, dependencies) => {
+    const packages = Object.entries(dependencies).map(([dependency, version]) => `${dependency}@${version.replace('^', '')}`);
+    logger_1.logger.info(INSTALLING_NPM_PACKAGES);
+    await (0, helpers_1.execPromise)(`npm install ${packages.join(' ')}`, {
+        cwd: folderPath,
+    });
+};
+exports.installDependencies = installDependencies;
+/**
+ * Updates package.json dependencies.
+ */
+const updatePackageJsonDependencies = async (packageJsonPath, dependencies, cwd) => {
+    const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');
+    const parsedPackageJson = JSON.parse(packageJsonContent);
+    if (cwd) {
+        parsedPackageJson.dependencies = {
+            ...parsedPackageJson.dependencies,
+            ...dependencies,
+        };
+    }
+    else {
+        parsedPackageJson.dependencies = { ...dependencies };
+    }
+    await fs.writeFile(packageJsonPath, JSON.stringify(parsedPackageJson, null, 2));
+    await fs.appendFile(packageJsonPath, '\n');
+};
+exports.updatePackageJsonDependencies = updatePackageJsonDependencies;
+/**
+ * Gets depencecies with versions.
+ */
+const extractPathsWithVersion = (plugins, dependencies) => {
+    const paths = Object.keys(plugins).map(plugin => plugins[plugin].path);
+    const uniquePaths = [...new Set(paths)].filter(path => path !== 'builtin');
+    const pathsWithVersion = {};
+    uniquePaths.forEach(pluginPath => {
+        const dependency = dependencies.find((dependency) => dependency.startsWith(pluginPath));
+        if (dependency) {
+            const splittedDependency = dependency.split('@');
+            const version = splittedDependency.length > 2
+                ? splittedDependency[2].split(' ')[0]
+                : splittedDependency[1];
+            pathsWithVersion[pluginPath] = `^${version}`;
+        }
+    });
+    return pathsWithVersion;
+};
+exports.extractPathsWithVersion = extractPathsWithVersion;
+/**
+ * Update the package.json properties.
+ */
+const updatePackageJsonProperties = async (newPackageJsonPath, appendDependencies) => {
+    const packageJsonContent = await fs.readFile(newPackageJsonPath, 'utf8');
+    const parsedPackageJsonContent = JSON.parse(packageJsonContent);
+    const properties = {
+        name: packageJson.name || 'if-environment',
+        description: packageJson.description,
+        author: packageJson.author,
+        bugs: packageJson.bugs,
+        engines: packageJson.engines,
+        homepage: packageJson.homepage,
+        dependencies: appendDependencies
+            ? parsedPackageJsonContent.dependencies
+            : {},
+    };
+    const newPackageJson = Object.assign({}, parsedPackageJsonContent, properties);
+    await fs.writeFile(newPackageJsonPath, JSON.stringify(newPackageJson, null, 2));
+};
+exports.updatePackageJsonProperties = updatePackageJsonProperties;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"npm.js","sourceRoot":"","sources":["../../../src/if-env/util/npm.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n/* eslint-disable no-process-exit */\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\nimport {execPromise} from '../../common/util/helpers';\nimport {isDirectoryExists, isFileExists} from '../../common/util/fs';\nimport {logger} from '../../common/util/logger';\n\nimport {STRINGS} from '../config';\nimport {ManifestPlugin, PathWithVersion} from '../types/npm';\n\nconst packageJson = require('../../../package.json');\n\nconst {INITIALIZING_PACKAGE_JSON, INSTALLING_NPM_PACKAGES} = STRINGS;\n\n/**\n * Checks if the package.json is exists, if not, initializes it.\n */\nexport const initPackageJsonIfNotExists = async (folderPath: string) => {\n  const packageJsonPath = path.resolve(folderPath, 'package.json');\n  const isPackageJsonExists = await isFileExists(packageJsonPath);\n\n  if (!isPackageJsonExists) {\n    logger.info(INITIALIZING_PACKAGE_JSON);\n\n    const nodeModulesPath = path.resolve(folderPath, 'node_modules');\n    const isNodeModulesExists = await isDirectoryExists(nodeModulesPath);\n\n    if (isNodeModulesExists) {\n      await fs.rm(nodeModulesPath, {recursive: true});\n    }\n\n    await execPromise('npm init -y', {cwd: folderPath});\n  }\n\n  return packageJsonPath;\n};\n\n/**\n * Installs packages from the specified dependencies in the specified folder.\n */\nexport const installDependencies = async (\n  folderPath: string,\n  dependencies: {[path: string]: string}\n) => {\n  const packages = Object.entries(dependencies).map(\n    ([dependency, version]) => `${dependency}@${version.replace('^', '')}`\n  );\n\n  logger.info(INSTALLING_NPM_PACKAGES);\n  await execPromise(`npm install ${packages.join(' ')}`, {\n    cwd: folderPath,\n  });\n};\n\n/**\n * Updates package.json dependencies.\n */\nexport const updatePackageJsonDependencies = async (\n  packageJsonPath: string,\n  dependencies: PathWithVersion,\n  cwd: boolean\n) => {\n  const packageJsonContent = await fs.readFile(packageJsonPath, 'utf8');\n\n  const parsedPackageJson = JSON.parse(packageJsonContent);\n\n  if (cwd) {\n    parsedPackageJson.dependencies = {\n      ...parsedPackageJson.dependencies,\n      ...dependencies,\n    };\n  } else {\n    parsedPackageJson.dependencies = {...dependencies};\n  }\n\n  await fs.writeFile(\n    packageJsonPath,\n    JSON.stringify(parsedPackageJson, null, 2)\n  );\n  await fs.appendFile(packageJsonPath, '\\n');\n};\n\n/**\n * Gets depencecies with versions.\n */\nexport const extractPathsWithVersion = (\n  plugins: ManifestPlugin,\n  dependencies: string[]\n) => {\n  const paths = Object.keys(plugins).map(plugin => plugins[plugin].path);\n  const uniquePaths = [...new Set(paths)].filter(path => path !== 'builtin');\n  const pathsWithVersion: PathWithVersion = {};\n\n  uniquePaths.forEach(pluginPath => {\n    const dependency = dependencies.find((dependency: string) =>\n      dependency.startsWith(pluginPath)\n    );\n\n    if (dependency) {\n      const splittedDependency = dependency.split('@');\n      const version =\n        splittedDependency.length > 2\n          ? splittedDependency[2].split(' ')[0]\n          : splittedDependency[1];\n\n      pathsWithVersion[pluginPath] = `^${version}`;\n    }\n  });\n\n  return pathsWithVersion;\n};\n\n/**\n * Update the package.json properties.\n */\nexport const updatePackageJsonProperties = async (\n  newPackageJsonPath: string,\n  appendDependencies: boolean\n) => {\n  const packageJsonContent = await fs.readFile(newPackageJsonPath, 'utf8');\n  const parsedPackageJsonContent = JSON.parse(packageJsonContent);\n\n  const properties = {\n    name: packageJson.name || 'if-environment',\n    description: packageJson.description,\n    author: packageJson.author,\n    bugs: packageJson.bugs,\n    engines: packageJson.engines,\n    homepage: packageJson.homepage,\n    dependencies: appendDependencies\n      ? parsedPackageJsonContent.dependencies\n      : {},\n  };\n\n  const newPackageJson = Object.assign(\n    {},\n    parsedPackageJsonContent,\n    properties\n  );\n\n  await fs.writeFile(\n    newPackageJsonPath,\n    JSON.stringify(newPackageJson, null, 2)\n  );\n};\n"]}

package/build/if-merge/config/config.d.ts

@@ -0,0 +1,6 @@
+import { ArgumentConfig, ParseOptions } from 'ts-command-line-args';
+import { IFMergeArgs } from '../types/process-args';
+export declare const CONFIG: {
+    ARGS: ArgumentConfig<IFMergeArgs>;
+    HELP: ParseOptions<any>;
+};

package/build/if-merge/config/config.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+const config_1 = require("../../common/config");
+const { DISCLAIMER_MESSAGE } = config_1.STRINGS;
+exports.CONFIG = {
+    ARGS: {
+        manifests: {
+            type: String,
+            multiple: true,
+            alias: 'm',
+            description: '[path to the manifests files]',
+        },
+        output: {
+            type: String,
+            optional: true,
+            alias: 'o',
+            description: '[path to the merged output file]',
+        },
+        name: {
+            type: String,
+            optional: true,
+            alias: 'n',
+            description: '[name of the merged manifest]',
+        },
+        description: {
+            type: String,
+            optional: true,
+            alias: 'd',
+            description: '[decription of the merged manifest]',
+        },
+    },
+    HELP: {
+        helpArg: 'help',
+        headerContentSections: [
+            { header: 'Impact Framework', content: 'IF-Merge Helpful keywords:' },
+        ],
+        footerContentSections: [
+            { header: 'Green Software Foundation', content: DISCLAIMER_MESSAGE },
+        ],
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-merge/config/index.d.ts

@@ -0,0 +1,2 @@
+export { CONFIG } from './config';
+export { STRINGS } from './strings';

package/build/if-merge/config/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRINGS = exports.CONFIG = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "CONFIG", { enumerable: true, get: function () { return config_1.CONFIG; } });
+var strings_1 = require("./strings");
+Object.defineProperty(exports, "STRINGS", { enumerable: true, get: function () { return strings_1.STRINGS; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaWYtbWVyZ2UvY29uZmlnL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1DQUFnQztBQUF4QixnR0FBQSxNQUFNLE9BQUE7QUFDZCxxQ0FBa0M7QUFBMUIsa0dBQUEsT0FBTyxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtDT05GSUd9IGZyb20gJy4vY29uZmlnJztcbmV4cG9ydCB7U1RSSU5HU30gZnJvbSAnLi9zdHJpbmdzJztcbiJdfQ==

package/build/if-merge/config/strings.d.ts

@@ -0,0 +1,5 @@
+export declare const STRINGS: {
+    MERGING: string;
+    SUCCESS_MESSAGE: string;
+    MANIFEST_IS_NOT_YAML: (path: string) => string;
+};

package/build/if-merge/config/strings.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRINGS = void 0;
+exports.STRINGS = {
+    MERGING: 'Merging...',
+    SUCCESS_MESSAGE: '\nManifests are merged successfully!',
+    MANIFEST_IS_NOT_YAML: (path) => `The \`${path}\` is not in yaml format.`,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5ncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pZi1tZXJnZS9jb25maWcvc3RyaW5ncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLE9BQU8sR0FBRztJQUNyQixPQUFPLEVBQUUsWUFBWTtJQUNyQixlQUFlLEVBQUUsc0NBQXNDO0lBQ3ZELG9CQUFvQixFQUFFLENBQUMsSUFBWSxFQUFFLEVBQUUsQ0FDckMsU0FBUyxJQUFJLDJCQUEyQjtDQUMzQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IFNUUklOR1MgPSB7XG4gIE1FUkdJTkc6ICdNZXJnaW5nLi4uJyxcbiAgU1VDQ0VTU19NRVNTQUdFOiAnXFxuTWFuaWZlc3RzIGFyZSBtZXJnZWQgc3VjY2Vzc2Z1bGx5IScsXG4gIE1BTklGRVNUX0lTX05PVF9ZQU1MOiAocGF0aDogc3RyaW5nKSA9PlxuICAgIGBUaGUgXFxgJHtwYXRofVxcYCBpcyBub3QgaW4geWFtbCBmb3JtYXQuYCxcbn07XG4iXX0=

package/build/if-merge/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/if-merge/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-process-exit */
+const debug_logger_1 = require("../common/util/debug-logger");
+const logger_1 = require("../common/util/logger");
+const args_1 = require("./util/args");
+const helpers_1 = require("./util/helpers");
+const config_1 = require("./config");
+const { MERGING, SUCCESS_MESSAGE } = config_1.STRINGS;
+const IfMerge = async () => {
+    // Call this function with false parameter to prevent log debug messages.
+    debug_logger_1.debugLogger.overrideConsoleMethods(false);
+    const commandArgs = await (0, args_1.parseIfMergeArgs)();
+    console.log(`${MERGING}\n`);
+    await (0, helpers_1.mergeManifests)(commandArgs);
+    console.log(SUCCESS_MESSAGE);
+    process.exit(0);
+};
+IfMerge().catch(error => {
+    if (error instanceof Error) {
+        logger_1.logger.error(error);
+        process.exit(2);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-merge/types/process-args.d.ts

@@ -0,0 +1,6 @@
+export interface IFMergeArgs {
+    manifests: string[];
+    output?: string;
+    name?: string;
+    description?: string;
+}

package/build/if-merge/types/process-args.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1hcmdzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2lmLW1lcmdlL3R5cGVzL3Byb2Nlc3MtYXJncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBJRk1lcmdlQXJncyB7XG4gIG1hbmlmZXN0czogc3RyaW5nW107XG4gIG91dHB1dD86IHN0cmluZztcbiAgbmFtZT86IHN0cmluZztcbiAgZGVzY3JpcHRpb24/OiBzdHJpbmc7XG59XG4iXX0=

package/build/if-merge/util/args.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if the `manifests` command is provided and they are valid manifests files or a folder.
+ */
+export declare const parseIfMergeArgs: () => Promise<{
+    manifests: string[];
+    output: string | undefined;
+    name: string | undefined;
+    description: string | undefined;
+}>;

package/build/if-merge/util/args.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIfMergeArgs = void 0;
+const ts_command_line_args_1 = require("ts-command-line-args");
+const utils_1 = require("@grnsft/if-core/utils");
+const fs_1 = require("../../common/util/fs");
+const helpers_1 = require("../../common/util/helpers");
+const yaml_1 = require("../../common/util/yaml");
+const config_1 = require("../../common/config");
+const config_2 = require("../config");
+const { ParseCliParamsError, InvalidDirectoryError, CliSourceFileError } = utils_1.ERRORS;
+const { ARGS, HELP } = config_2.CONFIG;
+const { MANIFEST_IS_NOT_YAML } = config_2.STRINGS;
+const { MANIFEST_NOT_FOUND, DIRECTORY_NOT_FOUND } = config_1.STRINGS;
+/**
+ * Parses `if-merge` process arguments.
+ */
+const validateAndParseIfMergeArgs = () => {
+    try {
+        return (0, ts_command_line_args_1.parse)(ARGS, HELP);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new ParseCliParamsError(error.message);
+        }
+        throw error;
+    }
+};
+/**
+ * Checks if the `manifests` command is provided and they are valid manifests files or a folder.
+ */
+const parseIfMergeArgs = async () => {
+    const { manifests, output, name, description } = validateAndParseIfMergeArgs();
+    const manifestsWithFullPath = [];
+    if (manifests.length === 1) {
+        const isDirectory = await (0, fs_1.isDirectoryExists)(manifests[0]);
+        if (!isDirectory) {
+            throw new InvalidDirectoryError(DIRECTORY_NOT_FOUND);
+        }
+        return { manifests, output, name, description };
+    }
+    for await (const manifest of manifests) {
+        const response = (0, helpers_1.prependFullFilePath)(manifest);
+        const isManifestFileExists = await (0, fs_1.isFileExists)(response);
+        const isYamlFile = (0, yaml_1.checkIfFileIsYaml)(response);
+        if (!isManifestFileExists) {
+            throw new ParseCliParamsError(`${manifest} ${MANIFEST_NOT_FOUND}`);
+        }
+        if (!isYamlFile) {
+            throw new CliSourceFileError(MANIFEST_IS_NOT_YAML(manifest));
+        }
+        if ((0, yaml_1.checkIfFileIsYaml)(manifest)) {
+            manifestsWithFullPath.push(response);
+        }
+    }
+    return { manifests: manifestsWithFullPath, output, name, description };
+};
+exports.parseIfMergeArgs = parseIfMergeArgs;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-merge/util/helpers.d.ts

@@ -0,0 +1,5 @@
+import { IFMergeArgs } from '../types/process-args';
+/**
+ * Merges the given manifests in the one file.
+ */
+export declare const mergeManifests: (mergeArgs: IFMergeArgs) => Promise<void>;

package/build/if-merge/util/helpers.js

@@ -0,0 +1,83 @@
+"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.mergeManifests = void 0;
+const path = __importStar(require("path"));
+const fs_1 = require("../../common/util/fs");
+const load_1 = require("../../common/lib/load");
+const exhaust_1 = require("../../if-run/lib/exhaust");
+/**
+ * Merges the given manifests in the one file.
+ */
+const mergeManifests = async (mergeArgs) => {
+    const { manifests: commandManifests, output, name, description } = mergeArgs;
+    let manifests = commandManifests;
+    if (commandManifests.length === 1) {
+        manifests = await (0, fs_1.getYamlFiles)(commandManifests[0]);
+    }
+    const context = {
+        name: name || 'if-merge',
+        description: description || 'merged manifest',
+        tags: null,
+        initialize: { plugins: {} },
+    };
+    const tree = await mergeManifestsData(manifests, context);
+    await saveMergedManifest(tree, context, output);
+};
+exports.mergeManifests = mergeManifests;
+/**
+ * Merges manifests data.
+ */
+const mergeManifestsData = async (manifests, context) => {
+    const tree = { children: {} };
+    for await (const manifest of manifests) {
+        const manifestName = (0, fs_1.getFileName)(manifest);
+        const { rawManifest } = await (0, load_1.load)(manifest);
+        const parentDir = path.basename(path.dirname(manifest));
+        const uniqueName = `${parentDir}-${manifestName}`;
+        context.tags = Object.assign({}, context.tags, rawManifest.tags);
+        context.initialize.plugins = {
+            ...context.initialize.plugins,
+            ...rawManifest.initialize.plugins,
+        };
+        Object.keys(rawManifest.tree.children).forEach(child => {
+            tree.children[`${child}-${uniqueName}`] = {
+                ...rawManifest.tree.children[child],
+            };
+        });
+    }
+    return tree;
+};
+/**
+ * Saves the merged manifest in the `merged-manifest.yaml` file.
+ */
+const saveMergedManifest = async (tree, context, outputPath) => {
+    const output = {
+        outputPath,
+        noOutput: false,
+    };
+    await (0, exhaust_1.exhaust)(tree, context, output);
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,16 @@
+import { ConfigParams, PluginParams } from '@grnsft/if-core/types';
+export declare const Coefficient: (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/coefficient/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Coefficient = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@grnsft/if-core/utils");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { ConfigError } = utils_1.ERRORS;
+const { MISSING_CONFIG } = config_1.STRINGS;
+exports.Coefficient = (0, interfaces_1.PluginFactory)({
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const configSchema = zod_1.z.object({
+            coefficient: zod_1.z.preprocess(value => (0, utils_1.validateArithmeticExpression)('coefficient', value, 'number'), zod_1.z.number()),
+            'input-parameter': zod_1.z.string().min(1),
+            'output-parameter': zod_1.z.string().min(1),
+        });
+        return (0, validations_1.validate)(configSchema, config);
+    },
+    inputValidation: (input, config) => {
+        const inputData = {
+            'input-parameter': input[config['input-parameter']],
+        };
+        const validationSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.number());
+        (0, validations_1.validate)(validationSchema, inputData);
+        return input;
+    },
+    implementation: async (inputs, config) => {
+        const { 'input-parameter': inputParameter, 'output-parameter': outputParameter, coefficient, } = config;
+        return inputs.map(input => ({
+            ...input,
+            [outputParameter]: calculateProduct(input, inputParameter, coefficient),
+        }));
+    },
+    allowArithmeticExpressions: ['input-parameter', 'coefficient'],
+});
+/**
+ * Calculates the product of the energy components.
+ */
+const calculateProduct = (input, inputParameter, coefficient) => (isNaN(Number(inputParameter)) ? input[inputParameter] : inputParameter) *
+    coefficient;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/copy-param/index.d.ts

@@ -0,0 +1,21 @@
+import { ConfigParams, PluginParams } from '@grnsft/if-core/types';
+/**
+ * keep-existing: true/false (whether to remove the parameter you are copying from)
+ * from-param: the parameter you are copying from (e.g. cpu/name)
+ * to-field: the parameter you are copying to (e.g. cpu/processor-name)
+ */
+export declare const Copy: (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/copy-param/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Copy = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@grnsft/if-core/utils");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { ConfigError } = utils_1.ERRORS;
+const { MISSING_CONFIG } = config_1.STRINGS;
+/**
+ * keep-existing: true/false (whether to remove the parameter you are copying from)
+ * from-param: the parameter you are copying from (e.g. cpu/name)
+ * to-field: the parameter you are copying to (e.g. cpu/processor-name)
+ */
+exports.Copy = (0, interfaces_1.PluginFactory)({
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const configSchema = zod_1.z.object({
+            'keep-existing': zod_1.z.boolean(),
+            from: zod_1.z.string().min(1),
+            to: zod_1.z.string().min(1),
+        });
+        const extractedFrom = (0, utils_1.getParameterFromArithmeticExpression)(config.from);
+        const updatedConfig = config['keep-existing']
+            ? config
+            : { ...config, 'pure-from': extractedFrom };
+        (0, validations_1.validate)(configSchema, updatedConfig);
+        return updatedConfig;
+    },
+    inputValidation: (input, config) => {
+        const from = config.from;
+        const inputData = {
+            [from]: input[from],
+        };
+        const validationSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.string().or(zod_1.z.number()));
+        return (0, validations_1.validate)(validationSchema, inputData);
+    },
+    implementation: async (inputs, config) => {
+        const keepExisting = config['keep-existing'] === true;
+        const from = config['from'];
+        const to = config['to'];
+        return inputs.map(input => {
+            const outputValue = !isNaN(from) ? from : input[from];
+            if (input[from] || (!isNaN(from) && !keepExisting)) {
+                delete input[config['pure-from']];
+            }
+            return {
+                ...input,
+                [to]: outputValue,
+            };
+        });
+    },
+    allowArithmeticExpressions: ['from'],
+});
+//# sourceMappingURL=data:application/json;base64,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