@grnsft/if 1.0.1 → 1.1.0-beta.0

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

@@ -30,89 +30,46 @@ const fs_1 = require("../../common/util/fs");
 const config_1 = require("../config");
 const { IF_CHECK_VERIFIED } = config_1.STRINGS;
 /**
- * Escapes shell characters that could be dangerous in a command.
+ * Executes a single Impact Framework command.
  */
-const escapeShellArg = (str) => str.replace(/([`$\\&;|*?<>])/g, '\\$1');
+const executeCommand = (command, args, executionOptions) => {
+    const commandPath = process.argv[1].replace(/(?<=[/\\])if-check(?:[/\\]index(?:\.[jt]s)?)?$/, command);
+    return (0, child_process_1.execFileSync)(process.execPath, [...process.execArgv, commandPath, ...args], executionOptions);
+};
 /**
- * Executes a series of npm commands based on the provided manifest file.
+ * Executes a series of Impact Framework commands based on the provided manifest file.
  */
 const executeCommands = async (manifest) => {
-    // Determine if the npm command should be run globally
-    const isGlobal = !!process.env.npm_config_global;
+    // Get fullpath of the manifest
+    if (!path.isAbsolute(manifest)) {
+        manifest = path.resolve(process.env.CURRENT_DIR || process.cwd(), manifest);
+    }
     // Get the directory path and file name of the manifest
     const manifestDirPath = path.dirname(manifest);
     const manifestFileName = (0, fs_1.getFileName)(manifest);
     // Create a path for the executed manifest file
     const executedManifest = path.join(manifestDirPath, `re-${manifestFileName}`);
-    // Determine the prefix flag if the CURRENT_DIR environment variable is set and different from the current working directory
-    const prefixFlag = process.env.CURRENT_DIR && process.env.CURRENT_DIR !== process.cwd()
-        ? `--prefix=${path.relative(process.env.CURRENT_DIR, process.cwd())}`
-        : '';
-    // Escape shell characters in the manifest paths
-    const sanitizedManifest = escapeShellArg(manifest);
-    const sanitizedExecutedManifest = escapeShellArg(executedManifest);
-    // Construct the if-env command
-    const ifEnvCommand = [
-        isGlobal ? 'if-env' : 'npm',
-        ...(isGlobal ? [] : ['run', 'if-env']),
-        isGlobal ? '' : '--',
-        ...(prefixFlag === '' ? [] : [prefixFlag]),
-        '-m',
-        sanitizedManifest,
-    ];
-    // Construct the if-run command
-    const ifRunCommand = [
-        isGlobal ? 'if-run' : 'npm',
-        ...(isGlobal ? [] : ['run', 'if-run']),
-        isGlobal ? '' : '--',
-        ...(prefixFlag === '' ? [] : [prefixFlag]),
-        '-m',
-        sanitizedManifest,
-        '-o',
-        sanitizedExecutedManifest,
-    ];
-    // Construct the tty command to check if the process is running in a TTY context
-    const ttyCommand = ['node', '-p', 'Boolean(process.stdout.isTTY)'];
-    // Construct the if-diff command
-    const ifDiffCommand = [
-        isGlobal ? 'if-diff' : 'npm',
-        ...(isGlobal ? [] : ['run', 'if-diff']),
-        isGlobal ? '' : '--',
-        ...(prefixFlag === '' ? [] : [prefixFlag]),
-        '-s',
-        `${sanitizedExecutedManifest}.yaml`,
-        '-t',
-        sanitizedManifest,
-    ];
-    const executionOptions = {
-        cwd: process.env.CURRENT_DIR || process.cwd(),
-    };
-    // Execute the if-env command
-    (0, child_process_1.execFileSync)(ifEnvCommand[0], ifEnvCommand.slice(1), {
-        ...executionOptions,
-        shell: true,
-    });
-    // Execute the if-run command
-    (0, child_process_1.execFileSync)(ifRunCommand[0], ifRunCommand.slice(1), executionOptions);
-    // Execute the tty command to check if the process is running in a TTY context
-    (0, child_process_1.execFileSync)(ttyCommand[0], ttyCommand.slice(1), executionOptions);
-    // Get the result of the tty command
-    const ttyResult = (0, child_process_1.execFileSync)(ttyCommand[0], ttyCommand.slice(1), executionOptions);
-    // Determine if the process is running in a TTY context
-    const tty = ttyResult && ttyResult.toString().trim();
-    // Construct the full command to execute if-diff, optionally piping through tty
-    const fullCommand = `${tty === 'true' ? 'tty |' : ''} ${ifDiffCommand.join(' ')}`;
-    // Execute the full command
-    (0, child_process_1.execFileSync)(fullCommand, {
-        ...executionOptions,
-        stdio: 'inherit',
-        shell: true,
-    });
-    // Remove the package.json file if it exists
-    await (0, fs_1.removeFileIfExists)(`${manifestDirPath}/package.json`);
-    // Remove the executed manifest file if it exists
-    await (0, fs_1.removeFileIfExists)(`${executedManifest}.yaml`);
+    try {
+        // Execute the if-env command
+        executeCommand('if-env', ['-m', manifest], {
+            stdio: 'ignore',
+        });
+        // Execute the if-run command
+        executeCommand('if-run', ['-m', manifest, '-o', executedManifest], {
+            stdio: 'ignore',
+        });
+        // Execute the if-diff command
+        executeCommand('if-diff', ['-s', `${executedManifest}.yaml`, '-t', manifest], {
+            stdio: 'inherit',
+        });
+    }
+    finally {
+        // Remove the package.json file if it exists
+        await (0, fs_1.removeFileIfExists)(`${manifestDirPath}/package.json`);
+        // Remove the executed manifest file if it exists
+        await (0, fs_1.removeFileIfExists)(`${executedManifest}.yaml`);
+    }
     console.log(IF_CHECK_VERIFIED(path.basename(manifest)));
 };
 exports.executeCommands = executeCommands;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"npm.js","sourceRoot":"","sources":["../../../src/if-check/util/npm.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'node:path';\nimport {execFileSync} from 'child_process';\nimport {getFileName, removeFileIfExists} from '../../common/util/fs';\nimport {STRINGS} from '../config';\n\nconst {IF_CHECK_VERIFIED} = STRINGS;\n\n/**\n * Escapes shell characters that could be dangerous in a command.\n */\nconst escapeShellArg = (str: string) => str.replace(/([`$\\\\&;|*?<>])/g, '\\\\$1');\n\n/**\n * Executes a series of npm commands based on the provided manifest file.\n */\nexport const executeCommands = async (manifest: string) => {\n  // Determine if the npm command should be run globally\n  const isGlobal = !!process.env.npm_config_global;\n  // Get the directory path and file name of the manifest\n  const manifestDirPath = path.dirname(manifest);\n  const manifestFileName = getFileName(manifest);\n  // Create a path for the executed manifest file\n  const executedManifest = path.join(manifestDirPath, `re-${manifestFileName}`);\n\n  // Determine the prefix flag if the CURRENT_DIR environment variable is set and different from the current working directory\n  const prefixFlag =\n    process.env.CURRENT_DIR && process.env.CURRENT_DIR !== process.cwd()\n      ? `--prefix=${path.relative(process.env.CURRENT_DIR!, process.cwd())}`\n      : '';\n\n  // Escape shell characters in the manifest paths\n  const sanitizedManifest = escapeShellArg(manifest);\n  const sanitizedExecutedManifest = escapeShellArg(executedManifest);\n\n  // Construct the if-env command\n  const ifEnvCommand = [\n    isGlobal ? 'if-env' : 'npm',\n    ...(isGlobal ? [] : ['run', 'if-env']),\n    isGlobal ? '' : '--',\n    ...(prefixFlag === '' ? [] : [prefixFlag]),\n    '-m',\n    sanitizedManifest,\n  ];\n\n  // Construct the if-run command\n  const ifRunCommand = [\n    isGlobal ? 'if-run' : 'npm',\n    ...(isGlobal ? [] : ['run', 'if-run']),\n    isGlobal ? '' : '--',\n    ...(prefixFlag === '' ? [] : [prefixFlag]),\n    '-m',\n    sanitizedManifest,\n    '-o',\n    sanitizedExecutedManifest,\n  ];\n\n  // Construct the tty command to check if the process is running in a TTY context\n  const ttyCommand = ['node', '-p', 'Boolean(process.stdout.isTTY)'];\n\n  // Construct the if-diff command\n  const ifDiffCommand = [\n    isGlobal ? 'if-diff' : 'npm',\n    ...(isGlobal ? [] : ['run', 'if-diff']),\n    isGlobal ? '' : '--',\n    ...(prefixFlag === '' ? [] : [prefixFlag]),\n    '-s',\n    `${sanitizedExecutedManifest}.yaml`,\n    '-t',\n    sanitizedManifest,\n  ];\n\n  const executionOptions = {\n    cwd: process.env.CURRENT_DIR || process.cwd(),\n  };\n\n  // Execute the if-env command\n  execFileSync(ifEnvCommand[0], ifEnvCommand.slice(1), {\n    ...executionOptions,\n    shell: true,\n  });\n\n  // Execute the if-run command\n  execFileSync(ifRunCommand[0], ifRunCommand.slice(1), executionOptions);\n\n  // Execute the tty command to check if the process is running in a TTY context\n  execFileSync(ttyCommand[0], ttyCommand.slice(1), executionOptions);\n\n  // Get the result of the tty command\n  const ttyResult = execFileSync(\n    ttyCommand[0],\n    ttyCommand.slice(1),\n    executionOptions\n  );\n\n  // Determine if the process is running in a TTY context\n  const tty = ttyResult && ttyResult.toString().trim();\n  // Construct the full command to execute if-diff, optionally piping through tty\n  const fullCommand = `${tty === 'true' ? 'tty |' : ''} ${ifDiffCommand.join(\n    ' '\n  )}`;\n\n  // Execute the full command\n  execFileSync(fullCommand, {\n    ...executionOptions,\n    stdio: 'inherit',\n    shell: true,\n  });\n\n  // Remove the package.json file if it exists\n  await removeFileIfExists(`${manifestDirPath}/package.json`);\n  // Remove the executed manifest file if it exists\n  await removeFileIfExists(`${executedManifest}.yaml`);\n\n  console.log(IF_CHECK_VERIFIED(path.basename(manifest)));\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnBtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2lmLWNoZWNrL3V0aWwvbnBtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0RBQWtDO0FBQ2xDLGlEQUFxRTtBQUNyRSw2Q0FBcUU7QUFDckUsc0NBQWtDO0FBRWxDLE1BQU0sRUFBQyxpQkFBaUIsRUFBQyxHQUFHLGdCQUFPLENBQUM7QUFFcEM7O0dBRUc7QUFDSCxNQUFNLGNBQWMsR0FBRyxDQUNyQixPQUFlLEVBQ2YsSUFBdUIsRUFDdkIsZ0JBQXFDLEVBQ3JDLEVBQUU7SUFDRixNQUFNLFdBQVcsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FDekMsZ0RBQWdELEVBQ2hELE9BQU8sQ0FDUixDQUFDO0lBRUYsT0FBTyxJQUFBLDRCQUFZLEVBQ2pCLE9BQU8sQ0FBQyxRQUFRLEVBQ2hCLENBQUMsR0FBRyxPQUFPLENBQUMsUUFBUSxFQUFFLFdBQVcsRUFBRSxHQUFHLElBQUksQ0FBQyxFQUMzQyxnQkFBZ0IsQ0FDakIsQ0FBQztBQUNKLENBQUMsQ0FBQztBQUVGOztHQUVHO0FBQ0ksTUFBTSxlQUFlLEdBQUcsS0FBSyxFQUFFLFFBQWdCLEVBQUUsRUFBRTtJQUN4RCwrQkFBK0I7SUFDL0IsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsUUFBUSxDQUFDLEVBQUU7UUFDOUIsUUFBUSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxXQUFXLElBQUksT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0tBQzdFO0lBQ0QsdURBQXVEO0lBQ3ZELE1BQU0sZUFBZSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDL0MsTUFBTSxnQkFBZ0IsR0FBRyxJQUFBLGdCQUFXLEVBQUMsUUFBUSxDQUFDLENBQUM7SUFDL0MsK0NBQStDO0lBQy9DLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxlQUFlLEVBQUUsTUFBTSxnQkFBZ0IsRUFBRSxDQUFDLENBQUM7SUFFOUUsSUFBSTtRQUNGLDZCQUE2QjtRQUM3QixjQUFjLENBQUMsUUFBUSxFQUFFLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxFQUFFO1lBQ3pDLEtBQUssRUFBRSxRQUFRO1NBQ2hCLENBQUMsQ0FBQztRQUVILDZCQUE2QjtRQUM3QixjQUFjLENBQUMsUUFBUSxFQUFFLENBQUMsSUFBSSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsZ0JBQWdCLENBQUMsRUFBRTtZQUNqRSxLQUFLLEVBQUUsUUFBUTtTQUNoQixDQUFDLENBQUM7UUFFSCw4QkFBOEI7UUFDOUIsY0FBYyxDQUNaLFNBQVMsRUFDVCxDQUFDLElBQUksRUFBRSxHQUFHLGdCQUFnQixPQUFPLEVBQUUsSUFBSSxFQUFFLFFBQVEsQ0FBQyxFQUNsRDtZQUNFLEtBQUssRUFBRSxTQUFTO1NBQ2pCLENBQ0YsQ0FBQztLQUNIO1lBQVM7UUFDUiw0Q0FBNEM7UUFDNUMsTUFBTSxJQUFBLHVCQUFrQixFQUFDLEdBQUcsZUFBZSxlQUFlLENBQUMsQ0FBQztRQUM1RCxpREFBaUQ7UUFDakQsTUFBTSxJQUFBLHVCQUFrQixFQUFDLEdBQUcsZ0JBQWdCLE9BQU8sQ0FBQyxDQUFDO0tBQ3REO0lBRUQsT0FBTyxDQUFDLEdBQUcsQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUMxRCxDQUFDLENBQUM7QUF0Q1csUUFBQSxlQUFlLG1CQXNDMUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBwYXRoIGZyb20gJ25vZGU6cGF0aCc7XG5pbXBvcnQge2V4ZWNGaWxlU3luYywgdHlwZSBFeGVjRmlsZVN5bmNPcHRpb25zfSBmcm9tICdjaGlsZF9wcm9jZXNzJztcbmltcG9ydCB7Z2V0RmlsZU5hbWUsIHJlbW92ZUZpbGVJZkV4aXN0c30gZnJvbSAnLi4vLi4vY29tbW9uL3V0aWwvZnMnO1xuaW1wb3J0IHtTVFJJTkdTfSBmcm9tICcuLi9jb25maWcnO1xuXG5jb25zdCB7SUZfQ0hFQ0tfVkVSSUZJRUR9ID0gU1RSSU5HUztcblxuLyoqXG4gKiBFeGVjdXRlcyBhIHNpbmdsZSBJbXBhY3QgRnJhbWV3b3JrIGNvbW1hbmQuXG4gKi9cbmNvbnN0IGV4ZWN1dGVDb21tYW5kID0gKFxuICBjb21tYW5kOiBzdHJpbmcsXG4gIGFyZ3M6IHJlYWRvbmx5IHN0cmluZ1tdLFxuICBleGVjdXRpb25PcHRpb25zOiBFeGVjRmlsZVN5bmNPcHRpb25zXG4pID0+IHtcbiAgY29uc3QgY29tbWFuZFBhdGggPSBwcm9jZXNzLmFyZ3ZbMV0ucmVwbGFjZShcbiAgICAvKD88PVsvXFxcXF0paWYtY2hlY2soPzpbL1xcXFxdaW5kZXgoPzpcXC5banRdcyk/KT8kLyxcbiAgICBjb21tYW5kXG4gICk7XG5cbiAgcmV0dXJuIGV4ZWNGaWxlU3luYyhcbiAgICBwcm9jZXNzLmV4ZWNQYXRoLFxuICAgIFsuLi5wcm9jZXNzLmV4ZWNBcmd2LCBjb21tYW5kUGF0aCwgLi4uYXJnc10sXG4gICAgZXhlY3V0aW9uT3B0aW9uc1xuICApO1xufTtcblxuLyoqXG4gKiBFeGVjdXRlcyBhIHNlcmllcyBvZiBJbXBhY3QgRnJhbWV3b3JrIGNvbW1hbmRzIGJhc2VkIG9uIHRoZSBwcm92aWRlZCBtYW5pZmVzdCBmaWxlLlxuICovXG5leHBvcnQgY29uc3QgZXhlY3V0ZUNvbW1hbmRzID0gYXN5bmMgKG1hbmlmZXN0OiBzdHJpbmcpID0+IHtcbiAgLy8gR2V0IGZ1bGxwYXRoIG9mIHRoZSBtYW5pZmVzdFxuICBpZiAoIXBhdGguaXNBYnNvbHV0ZShtYW5pZmVzdCkpIHtcbiAgICBtYW5pZmVzdCA9IHBhdGgucmVzb2x2ZShwcm9jZXNzLmVudi5DVVJSRU5UX0RJUiB8fCBwcm9jZXNzLmN3ZCgpLCBtYW5pZmVzdCk7XG4gIH1cbiAgLy8gR2V0IHRoZSBkaXJlY3RvcnkgcGF0aCBhbmQgZmlsZSBuYW1lIG9mIHRoZSBtYW5pZmVzdFxuICBjb25zdCBtYW5pZmVzdERpclBhdGggPSBwYXRoLmRpcm5hbWUobWFuaWZlc3QpO1xuICBjb25zdCBtYW5pZmVzdEZpbGVOYW1lID0gZ2V0RmlsZU5hbWUobWFuaWZlc3QpO1xuICAvLyBDcmVhdGUgYSBwYXRoIGZvciB0aGUgZXhlY3V0ZWQgbWFuaWZlc3QgZmlsZVxuICBjb25zdCBleGVjdXRlZE1hbmlmZXN0ID0gcGF0aC5qb2luKG1hbmlmZXN0RGlyUGF0aCwgYHJlLSR7bWFuaWZlc3RGaWxlTmFtZX1gKTtcblxuICB0cnkge1xuICAgIC8vIEV4ZWN1dGUgdGhlIGlmLWVudiBjb21tYW5kXG4gICAgZXhlY3V0ZUNvbW1hbmQoJ2lmLWVudicsIFsnLW0nLCBtYW5pZmVzdF0sIHtcbiAgICAgIHN0ZGlvOiAnaWdub3JlJyxcbiAgICB9KTtcblxuICAgIC8vIEV4ZWN1dGUgdGhlIGlmLXJ1biBjb21tYW5kXG4gICAgZXhlY3V0ZUNvbW1hbmQoJ2lmLXJ1bicsIFsnLW0nLCBtYW5pZmVzdCwgJy1vJywgZXhlY3V0ZWRNYW5pZmVzdF0sIHtcbiAgICAgIHN0ZGlvOiAnaWdub3JlJyxcbiAgICB9KTtcblxuICAgIC8vIEV4ZWN1dGUgdGhlIGlmLWRpZmYgY29tbWFuZFxuICAgIGV4ZWN1dGVDb21tYW5kKFxuICAgICAgJ2lmLWRpZmYnLFxuICAgICAgWyctcycsIGAke2V4ZWN1dGVkTWFuaWZlc3R9LnlhbWxgLCAnLXQnLCBtYW5pZmVzdF0sXG4gICAgICB7XG4gICAgICAgIHN0ZGlvOiAnaW5oZXJpdCcsXG4gICAgICB9XG4gICAgKTtcbiAgfSBmaW5hbGx5IHtcbiAgICAvLyBSZW1vdmUgdGhlIHBhY2thZ2UuanNvbiBmaWxlIGlmIGl0IGV4aXN0c1xuICAgIGF3YWl0IHJlbW92ZUZpbGVJZkV4aXN0cyhgJHttYW5pZmVzdERpclBhdGh9L3BhY2thZ2UuanNvbmApO1xuICAgIC8vIFJlbW92ZSB0aGUgZXhlY3V0ZWQgbWFuaWZlc3QgZmlsZSBpZiBpdCBleGlzdHNcbiAgICBhd2FpdCByZW1vdmVGaWxlSWZFeGlzdHMoYCR7ZXhlY3V0ZWRNYW5pZmVzdH0ueWFtbGApO1xuICB9XG5cbiAgY29uc29sZS5sb2coSUZfQ0hFQ0tfVkVSSUZJRUQocGF0aC5iYXNlbmFtZShtYW5pZmVzdCkpKTtcbn07XG4iXX0=

package/build/if-metadata-check/config/config.d.ts

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

package/build/if-metadata-check/config/config.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+exports.CONFIG = {
+    ARGS: {
+        manifest: {
+            type: String,
+            alias: 'm',
+            description: 'Path of the manifest file',
+        },
+        parameters: {
+            type: String,
+            alias: 'p',
+            description: 'List of parameters to check',
+            multiple: true,
+            defaultValue: [],
+        },
+        help: {
+            type: Boolean,
+            alias: 'h',
+            description: 'Prints out the help instruction',
+            optional: true,
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2lmLW1ldGFkYXRhLWNoZWNrL2NvbmZpZy9jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBR2EsUUFBQSxNQUFNLEdBQUc7SUFDcEIsSUFBSSxFQUFFO1FBQ0osUUFBUSxFQUFFO1lBQ1IsSUFBSSxFQUFFLE1BQU07WUFDWixLQUFLLEVBQUUsR0FBRztZQUNWLFdBQVcsRUFBRSwyQkFBMkI7U0FDekM7UUFDRCxVQUFVLEVBQUU7WUFDVixJQUFJLEVBQUUsTUFBTTtZQUNaLEtBQUssRUFBRSxHQUFHO1lBQ1YsV0FBVyxFQUFFLDZCQUE2QjtZQUMxQyxRQUFRLEVBQUUsSUFBSTtZQUNkLFlBQVksRUFBRSxFQUFFO1NBQ2pCO1FBQ0QsSUFBSSxFQUFFO1lBQ0osSUFBSSxFQUFFLE9BQU87WUFDYixLQUFLLEVBQUUsR0FBRztZQUNWLFdBQVcsRUFBRSxpQ0FBaUM7WUFDOUMsUUFBUSxFQUFFLElBQUk7U0FDZjtLQUNxQztDQUN6QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtBcmd1bWVudENvbmZpZ30gZnJvbSAndHMtY29tbWFuZC1saW5lLWFyZ3MnO1xuaW1wb3J0IHtJRkNoZWNrTWV0YWRhdGFBcmdzfSBmcm9tICcuLi90eXBlcy9wcm9jZXNzLWFyZ3MnO1xuXG5leHBvcnQgY29uc3QgQ09ORklHID0ge1xuICBBUkdTOiB7XG4gICAgbWFuaWZlc3Q6IHtcbiAgICAgIHR5cGU6IFN0cmluZyxcbiAgICAgIGFsaWFzOiAnbScsXG4gICAgICBkZXNjcmlwdGlvbjogJ1BhdGggb2YgdGhlIG1hbmlmZXN0IGZpbGUnLFxuICAgIH0sXG4gICAgcGFyYW1ldGVyczoge1xuICAgICAgdHlwZTogU3RyaW5nLFxuICAgICAgYWxpYXM6ICdwJyxcbiAgICAgIGRlc2NyaXB0aW9uOiAnTGlzdCBvZiBwYXJhbWV0ZXJzIHRvIGNoZWNrJyxcbiAgICAgIG11bHRpcGxlOiB0cnVlLFxuICAgICAgZGVmYXVsdFZhbHVlOiBbXSxcbiAgICB9LFxuICAgIGhlbHA6IHtcbiAgICAgIHR5cGU6IEJvb2xlYW4sXG4gICAgICBhbGlhczogJ2gnLFxuICAgICAgZGVzY3JpcHRpb246ICdQcmludHMgb3V0IHRoZSBoZWxwIGluc3RydWN0aW9uJyxcbiAgICAgIG9wdGlvbmFsOiB0cnVlLFxuICAgIH0sXG4gIH0gYXMgQXJndW1lbnRDb25maWc8SUZDaGVja01ldGFkYXRhQXJncz4sXG59O1xuIl19

package/build/if-metadata-check/config/strings.d.ts

@@ -0,0 +1,5 @@
+export declare const STRINGS: {
+    PARAMETERS_MISSING_METADATA: string;
+    ALL_PARAMETERS_HAVE_METADATA: string;
+    PERCENTAGE_COVERAGE: string;
+};

package/build/if-metadata-check/config/strings.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRINGS = void 0;
+exports.STRINGS = {
+    PARAMETERS_MISSING_METADATA: 'The following parameters are missing metadata: ',
+    ALL_PARAMETERS_HAVE_METADATA: 'All parameters have associated metadata.',
+    PERCENTAGE_COVERAGE: 'Metadata coverage percentage: ',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5ncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pZi1tZXRhZGF0YS1jaGVjay9jb25maWcvc3RyaW5ncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLE9BQU8sR0FBRztJQUNyQiwyQkFBMkIsRUFDekIsaURBQWlEO0lBQ25ELDRCQUE0QixFQUFFLDBDQUEwQztJQUN4RSxtQkFBbUIsRUFBRSxnQ0FBZ0M7Q0FDdEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBTVFJJTkdTID0ge1xuICBQQVJBTUVURVJTX01JU1NJTkdfTUVUQURBVEE6XG4gICAgJ1RoZSBmb2xsb3dpbmcgcGFyYW1ldGVycyBhcmUgbWlzc2luZyBtZXRhZGF0YTogJyxcbiAgQUxMX1BBUkFNRVRFUlNfSEFWRV9NRVRBREFUQTogJ0FsbCBwYXJhbWV0ZXJzIGhhdmUgYXNzb2NpYXRlZCBtZXRhZGF0YS4nLFxuICBQRVJDRU5UQUdFX0NPVkVSQUdFOiAnTWV0YWRhdGEgY292ZXJhZ2UgcGVyY2VudGFnZTogJyxcbn07XG4iXX0=

package/build/if-metadata-check/index.d.ts

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

package/build/if-metadata-check/index.js

@@ -0,0 +1,30 @@
+#!/user/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const args_1 = require("./util/args");
+const metadata_checker_1 = require("./util/metadata-checker");
+const debug_logger_1 = require("../common/util/debug-logger");
+const logger_1 = require("../common/util/logger");
+const strings_1 = require("./config/strings");
+const { PERCENTAGE_COVERAGE, ALL_PARAMETERS_HAVE_METADATA, PARAMETERS_MISSING_METADATA, } = strings_1.STRINGS;
+const IfCheckMetadata = async () => {
+    debug_logger_1.debugLogger.overrideConsoleMethods(false);
+    const { parameters, ...manifestData } = await (0, args_1.parseIFCheckMetadataArgs)();
+    const parameterSet = (0, metadata_checker_1.getParameters)(Object.values(manifestData.initialize.plugins), parameters);
+    const parameterWithMetadataSet = (0, metadata_checker_1.getParametersWithMetadata)(Object.values(manifestData.initialize.plugins));
+    const { percentage, missingParameters } = (0, metadata_checker_1.calculateMetadataCoverage)(parameterSet, parameterWithMetadataSet);
+    console.log(`${PERCENTAGE_COVERAGE} ${percentage.toFixed(2)}%`);
+    if (missingParameters.length > 0) {
+        console.log(PARAMETERS_MISSING_METADATA);
+        missingParameters.forEach(parameter => console.log(`  - ${parameter}`));
+    }
+    else {
+        console.log(ALL_PARAMETERS_HAVE_METADATA);
+    }
+};
+IfCheckMetadata().catch(error => {
+    if (error instanceof Error)
+        logger_1.logger.error(`${error.message}`);
+    throw error;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-metadata-check/types/plugin.d.ts

@@ -0,0 +1,7 @@
+import { PluginParametersMetadata } from '@grnsft/if-core/types';
+export interface IFPlugin {
+    path: string;
+    method: string;
+    config?: Record<string, any>;
+    'parameter-metadata'?: PluginParametersMetadata;
+}

package/build/if-metadata-check/types/plugin.js

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

package/build/if-metadata-check/types/process-args.d.ts

@@ -0,0 +1,5 @@
+export interface IFCheckMetadataArgs {
+    manifest: string;
+    parameters: string[];
+    help?: boolean;
+}

package/build/if-metadata-check/types/process-args.js

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

package/build/if-metadata-check/util/args.d.ts

@@ -0,0 +1,57 @@
+export declare const parseIFCheckMetadataArgs: () => Promise<{
+    parameters: string[];
+    name: string;
+    initialize: {
+        plugins: Record<string, {
+            path: string;
+            method: string;
+            mapping?: Record<string, string> | undefined;
+            config?: Record<string, any> | undefined;
+            'parameter-metadata'?: {
+                inputs?: Record<string, {
+                    unit: string;
+                    description: string;
+                    'aggregation-method': {
+                        time: "sum" | "avg" | "none" | "copy";
+                        component: "sum" | "avg" | "none" | "copy";
+                    };
+                }> | null | undefined;
+                outputs?: Record<string, {
+                    unit: string;
+                    description: string;
+                    'aggregation-method': {
+                        time: "sum" | "avg" | "none" | "copy";
+                        component: "sum" | "avg" | "none" | "copy";
+                    };
+                }> | null | undefined;
+            } | undefined;
+        } | undefined>;
+    };
+    tree: Record<string, any>;
+    description?: string | null | undefined;
+    tags?: {
+        kind?: string | null | undefined;
+        complexity?: string | null | undefined;
+        category?: string | null | undefined;
+    } | null | undefined;
+    explainer?: boolean | undefined;
+    explain?: Record<string, any> | undefined;
+    aggregation?: {
+        type: "horizontal" | "time" | "vertical" | "component" | "both";
+        metrics: string[];
+        'skip-components'?: string[] | undefined;
+    } | null | undefined;
+    execution?: {
+        status: string;
+        command?: string | undefined;
+        environment?: {
+            'if-version': string;
+            os: string;
+            'os-version': string;
+            'node-version': string;
+            'date-time': string;
+            dependencies: string[];
+        } | undefined;
+        error?: string | undefined;
+    } | undefined;
+}>;

package/build/if-metadata-check/util/args.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIFCheckMetadataArgs = void 0;
+const ts_command_line_args_1 = require("ts-command-line-args");
+const config_1 = require("../config/config");
+const helpers_1 = require("../../common/util/helpers");
+const load_1 = require("../../common/lib/load");
+const validations_1 = require("../../common/util/validations");
+const { ARGS } = config_1.CONFIG;
+const validateAndParseIFCheckMetadataArgs = () => {
+    try {
+        return (0, ts_command_line_args_1.parse)(ARGS);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.log(error.message);
+            (0, helpers_1.runHelpCommand)('if-check-metadata');
+        }
+        throw error;
+    }
+};
+const parseIFCheckMetadataArgs = async () => {
+    const { manifest, parameters } = validateAndParseIFCheckMetadataArgs();
+    const { rawManifest } = await (0, load_1.load)(manifest);
+    const validatedManifest = (0, validations_1.validateManifest)(rawManifest);
+    return { ...validatedManifest, parameters };
+};
+exports.parseIFCheckMetadataArgs = parseIFCheckMetadataArgs;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-metadata-check/util/metadata-checker.d.ts

@@ -0,0 +1,44 @@
+import { IFPlugin } from '../types/plugin';
+/**
+ * Extracts a set of parameter values from the configurations of the provided plugins.
+ *
+ * @param plugins - An array of plugins, each containing configuration data.
+ * @param parameters - Additional parameter keys to extract from the plugin configurations.
+ * @returns A set of parameter values extracted from the plugin configurations.
+ */
+export declare const getParameters: (plugins: IFPlugin[], parameters: string[]) => Set<string>;
+/**
+ * Extracts a set of parameters that have defined metadata from the provided plugins.
+ *
+ * @param plugins - An array of plugins, each containing metadata information.
+ * @returns A set of parameter names that have associated metadata.
+ */
+export declare const getParametersWithMetadata: (plugins: IFPlugin[]) => Set<string>;
+/**
+ * Extracts parameters with metadata from a single plugin.
+ *
+ * @param plugin - A plugin object containing metadata information.
+ * @returns An array of parameter names that have associated metadata, including inputs and outputs.
+ */
+export declare const extractParametersWithMetadata: (plugin: IFPlugin) => string[];
+/**
+ * Extracts parameter values from a plugin's configuration based on specified keys.
+ *
+ * @param config - The configuration object of a plugin.
+ * @param keys - An array of keys to look for in the configuration object.
+ * @returns An array of parameter values corresponding to the specified keys.
+ */
+export declare const extractParameters: (config: Record<string, any> | undefined, keys: string[]) => any[];
+/**
+ * Calculates the coverage of metadata for a given set of parameters.
+ *
+ * @param parameterSet - A set of all parameters extracted from plugin configurations.
+ * @param parameterWithMetadataSet - A set of parameters that have associated metadata.
+ * @returns An object containing:
+ *   - `percentage`: The percentage of parameters with metadata coverage.
+ *   - `missingParameters`: An array of parameters that lack metadata coverage.
+ */
+export declare const calculateMetadataCoverage: (parameterSet: Set<string>, parameterWithMetadataSet: Set<string>) => {
+    percentage: number;
+    missingParameters: string[];
+};

package/build/if-metadata-check/util/metadata-checker.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateMetadataCoverage = exports.extractParameters = exports.extractParametersWithMetadata = exports.getParametersWithMetadata = exports.getParameters = void 0;
+/**
+ * Extracts a set of parameter values from the configurations of the provided plugins.
+ *
+ * @param plugins - An array of plugins, each containing configuration data.
+ * @param parameters - Additional parameter keys to extract from the plugin configurations.
+ * @returns A set of parameter values extracted from the plugin configurations.
+ */
+const getParameters = (plugins, parameters) => {
+    return new Set(plugins.flatMap(plugin => (0, exports.extractParameters)(plugin.config, [
+        'input-parameter',
+        'output-parameter',
+        'input-parameters',
+        'output',
+        ...parameters,
+    ])));
+};
+exports.getParameters = getParameters;
+/**
+ * Extracts a set of parameters that have defined metadata from the provided plugins.
+ *
+ * @param plugins - An array of plugins, each containing metadata information.
+ * @returns A set of parameter names that have associated metadata.
+ */
+const getParametersWithMetadata = (plugins) => {
+    return new Set(plugins.flatMap(plugin => (0, exports.extractParametersWithMetadata)(plugin)));
+};
+exports.getParametersWithMetadata = getParametersWithMetadata;
+/**
+ * Extracts parameters with metadata from a single plugin.
+ *
+ * @param plugin - A plugin object containing metadata information.
+ * @returns An array of parameter names that have associated metadata, including inputs and outputs.
+ */
+const extractParametersWithMetadata = (plugin) => {
+    if (!plugin['parameter-metadata'])
+        return [];
+    const { inputs, outputs } = plugin['parameter-metadata'];
+    return [
+        ...(inputs ? Object.keys(inputs) : []),
+        ...(outputs ? Object.keys(outputs) : []),
+    ];
+};
+exports.extractParametersWithMetadata = extractParametersWithMetadata;
+/**
+ * Extracts parameter values from a plugin's configuration based on specified keys.
+ *
+ * @param config - The configuration object of a plugin.
+ * @param keys - An array of keys to look for in the configuration object.
+ * @returns An array of parameter values corresponding to the specified keys.
+ */
+const extractParameters = (config, keys) => {
+    if (!config)
+        return [];
+    return keys.flatMap(key => {
+        if (key in config && isStringOrStringArray(config[key])) {
+            return config[key];
+        }
+        return [];
+    });
+};
+exports.extractParameters = extractParameters;
+/**
+ * Calculates the coverage of metadata for a given set of parameters.
+ *
+ * @param parameterSet - A set of all parameters extracted from plugin configurations.
+ * @param parameterWithMetadataSet - A set of parameters that have associated metadata.
+ * @returns An object containing:
+ *   - `percentage`: The percentage of parameters with metadata coverage.
+ *   - `missingParameters`: An array of parameters that lack metadata coverage.
+ */
+const calculateMetadataCoverage = (parameterSet, parameterWithMetadataSet) => {
+    const totalParameters = parameterSet.size;
+    const parametersWithMetadata = [...parameterSet].filter(param => parameterWithMetadataSet.has(param)).length;
+    const percentage = totalParameters === 0
+        ? 100
+        : (parametersWithMetadata / totalParameters) * 100;
+    const missingParameters = [...parameterSet].filter(parameter => !parameterWithMetadataSet.has(parameter));
+    return { percentage, missingParameters };
+};
+exports.calculateMetadataCoverage = calculateMetadataCoverage;
+/**
+ * Checks if the given parameter is a string or an array of strings.
+ *
+ * @param parameter - The parameter to validate.
+ * @returns `true` if the parameter is a string or an array of strings, otherwise `false`.
+ */
+const isStringOrStringArray = (parameter) => {
+    if (typeof parameter === 'string') {
+        return true;
+    }
+    if (Array.isArray(parameter)) {
+        return parameter.every(item => typeof item === 'string');
+    }
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metadata-checker.js","sourceRoot":"","sources":["../../../src/if-metadata-check/util/metadata-checker.ts"],"names":[],"mappings":"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","sourcesContent":["import {IFPlugin} from '../types/plugin';\n\n/**\n * Extracts a set of parameter values from the configurations of the provided plugins.\n *\n * @param plugins - An array of plugins, each containing configuration data.\n * @param parameters - Additional parameter keys to extract from the plugin configurations.\n * @returns A set of parameter values extracted from the plugin configurations.\n */\nexport const getParameters = (plugins: IFPlugin[], parameters: string[]) => {\n  return new Set<string>(\n    plugins.flatMap(plugin =>\n      extractParameters(plugin.config, [\n        'input-parameter',\n        'output-parameter',\n        'input-parameters',\n        'output',\n        ...parameters,\n      ])\n    )\n  );\n};\n\n/**\n * Extracts a set of parameters that have defined metadata from the provided plugins.\n *\n * @param plugins - An array of plugins, each containing metadata information.\n * @returns A set of parameter names that have associated metadata.\n */\nexport const getParametersWithMetadata = (plugins: IFPlugin[]) => {\n  return new Set<string>(\n    plugins.flatMap(plugin => extractParametersWithMetadata(plugin))\n  );\n};\n\n/**\n * Extracts parameters with metadata from a single plugin.\n *\n * @param plugin - A plugin object containing metadata information.\n * @returns An array of parameter names that have associated metadata, including inputs and outputs.\n */\nexport const extractParametersWithMetadata = (plugin: IFPlugin) => {\n  if (!plugin['parameter-metadata']) return [];\n  const {inputs, outputs} = plugin['parameter-metadata'];\n  return [\n    ...(inputs ? Object.keys(inputs) : []),\n    ...(outputs ? Object.keys(outputs) : []),\n  ];\n};\n\n/**\n * Extracts parameter values from a plugin's configuration based on specified keys.\n *\n * @param config - The configuration object of a plugin.\n * @param keys - An array of keys to look for in the configuration object.\n * @returns An array of parameter values corresponding to the specified keys.\n */\nexport const extractParameters = (\n  config: Record<string, any> | undefined,\n  keys: string[]\n) => {\n  if (!config) return [];\n  return keys.flatMap(key => {\n    if (key in config && isStringOrStringArray(config[key])) {\n      return config[key];\n    }\n    return [];\n  });\n};\n\n/**\n * Calculates the coverage of metadata for a given set of parameters.\n *\n * @param parameterSet - A set of all parameters extracted from plugin configurations.\n * @param parameterWithMetadataSet - A set of parameters that have associated metadata.\n * @returns An object containing:\n *   - `percentage`: The percentage of parameters with metadata coverage.\n *   - `missingParameters`: An array of parameters that lack metadata coverage.\n */\nexport const calculateMetadataCoverage = (\n  parameterSet: Set<string>,\n  parameterWithMetadataSet: Set<string>\n) => {\n  const totalParameters = parameterSet.size;\n  const parametersWithMetadata = [...parameterSet].filter(param =>\n    parameterWithMetadataSet.has(param)\n  ).length;\n  const percentage =\n    totalParameters === 0\n      ? 100\n      : (parametersWithMetadata / totalParameters) * 100;\n\n  const missingParameters = [...parameterSet].filter(\n    parameter => !parameterWithMetadataSet.has(parameter)\n  );\n\n  return {percentage, missingParameters};\n};\n\n/**\n * Checks if the given parameter is a string or an array of strings.\n *\n * @param parameter - The parameter to validate.\n * @returns `true` if the parameter is a string or an array of strings, otherwise `false`.\n */\nconst isStringOrStringArray = (parameter: unknown): boolean => {\n  if (typeof parameter === 'string') {\n    return true;\n  }\n  if (Array.isArray(parameter)) {\n    return parameter.every(item => typeof item === 'string');\n  }\n  return false;\n};\n"]}

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

@@ -58,9 +58,9 @@ const calculateDivide = (input, index, params) => {
     const finalDenominator = typeof denominator === 'number' ? denominator : input[denominator];
     const finalNumerator = typeof numerator === 'number' ? numerator : input[numerator];
     if (finalDenominator === 0) {
-        console.warn(ZERO_DIVISION(exports.Divide.name, index));
+        console.warn(ZERO_DIVISION('Divide', index));
         return finalNumerator;
     }
     return finalNumerator / finalDenominator;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -74,7 +74,7 @@ exports.Sci = (0, interfaces_1.PluginFactory)({
                 ? input[config['functional-unit']]
                 : config['functional-unit'];
             if (functionalUnit === 0) {
-                console.warn(ZERO_DIVISION(exports.Sci.name, index));
+                console.warn(ZERO_DIVISION('Sci', index));
                 return {
                     ...input,
                     sci: input['carbon'],
@@ -89,4 +89,4 @@ exports.Sci = (0, interfaces_1.PluginFactory)({
     },
     allowArithmeticExpressions: ['functional-unit'],
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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