@decaf-ts/fabric-weaver/dist/fabric-weaver.cjs

template for ts projects

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@decaf-ts/utils'), require('fs'), require('path'), require('js-yaml'), require('@decaf-ts/logging'), require('child_process')) :
    typeof define === 'function' && define.amd ? define(['exports', '@decaf-ts/utils', 'fs', 'path', 'js-yaml', '@decaf-ts/logging', 'child_process'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["fabric-weaver"] = {}, global.utils, global.fs, global.path, global.yaml, global.logging, global.child_process));
})(this, (function (exports, utils, fs, path, yaml, logging, child_process) { 'use strict';

    /**
     * @module build-scripts
     * @description Custom build scripts for the fabric-weaver project.
     * @summary This module extends the BuildScripts class from @decaf-ts/utils to provide custom build functionality for the fabric-weaver project. It includes utilities for building command-line interfaces and handling different module formats (CommonJS and ES Modules).
     */
    /**
     * @description Enumeration of module modes.
     * @summary Defines the different module formats supported in the build process.
     * @enum {string}
     * @readonly
     * @memberOf module:build-scripts
     */
    var Modes;
    (function (Modes) {
        /** CommonJS module format */
        Modes["CJS"] = "commonjs";
        /** ECMAScript module format (ES2022) */
        Modes["ESM"] = "es2022";
    })(Modes || (Modes = {}));
    /**
     * @description Custom build scripts for the fabric-weaver project.
     * @summary Extends the BuildScripts class to provide project-specific build functionality, including command bundling and file manipulation.
     * @class BuildScriptsCustom
     * @extends BuildScripts
     */
    class BuildScriptsCustom extends utils.BuildScripts {
        /**
         * @description Builds command-line interfaces for the project.
         * @summary Processes each command in the Commands array, bundling the TypeScript files, adding a shebang line, and setting appropriate permissions.
         * @return {Promise<void>}
         * @mermaid
         * sequenceDiagram
         *   participant BuildScriptsCustom
         *   participant FileSystem
         *   loop For each command
         *     BuildScriptsCustom->>BuildScriptsCustom: bundle(Modes.CJS, true, true, `src/bin/${cmd}.ts`, cmd)
         *     BuildScriptsCustom->>FileSystem: readFile(`bin/${cmd}.cjs`)
         *     FileSystem-->>BuildScriptsCustom: file content
         *     BuildScriptsCustom->>BuildScriptsCustom: Add shebang to file content
         *     BuildScriptsCustom->>FileSystem: writeFile(`bin/${cmd}.cjs`, modified content)
         *     BuildScriptsCustom->>FileSystem: chmodSync(`bin/${cmd}.cjs`, "755")
         *   end
         */
        async buildCommands() {
            const commands = fs.readdirSync(path.join(process.cwd() + "/src/bin"));
            for (const cmd of commands) {
                if (!cmd.endsWith(".ts"))
                    continue;
                await this.bundle(Modes.CJS, true, true, `src/bin/${cmd}`, cmd);
                let data = utils.readFile(`bin/${cmd}.cjs`);
                data = "#!/usr/bin/env node\n" + data;
                utils.writeFile(`bin/${cmd}.cjs`, data);
                fs.chmodSync(`bin/${cmd}.cjs`, "755");
            }
        }
    }

    const COMMA_SEPARATOR = ",";
    const SLASH_SEPARATOR = "/";

    function safeParseJSON(v) {
        try {
            return JSON.parse(v);
        }
        catch (e) {
            throw new Error(`Invalid JSON: ${e.message}`);
        }
    }
    function safeParseInt(v) {
        if (typeof v === "number")
            return Math.floor(v);
        const value = Number(v);
        if (!Number.isInteger(value)) {
            throw new Error(`Invalid integer value: ${v}`);
        }
        return value;
    }
    function safeParseCSV(csv) {
        if (!csv.trim())
            return [];
        return csv.split(COMMA_SEPARATOR).map((item) => item.trim());
    }
    function safeParseSSV(csv) {
        console.log(csv);
        if (!csv.trim())
            return [];
        return csv.split(SLASH_SEPARATOR).map((item) => `"${item.trim()}"`);
    }
    function mapParser(map) {
        const argz = Array.from(map, ([key, value]) => {
            if (typeof value === "boolean") {
                return value ? [`--${key}`] : [];
            }
            if (Array.isArray(value)) {
                return [`--${key}`, value.join(",")];
            }
            return [`--${key}`, value.toString()];
        });
        return argz.map((el) => el.join(" "));
    }

    const logger = logging.Logging.for("yaml");
    /**
     * @description Reads and parses a YAML file, optionally retrieving a specific property.
     * @summary This function reads a YAML file from the given path, parses its content, and returns either the entire parsed YAML object or a specific property value based on the provided path.
     *
     * @function readFileYaml
     * @template T - The type of the returned value when a specific property is requested.
     * @param {string} yamlFilePath - The path to the YAML file to be read.
     * @param {string} [variable] - Optional. A dot-notated path string that specifies the property to retrieve from the parsed YAML.
     * @return {Record<string, any> | T} Returns the entire parsed YAML object if no `variable` is provided, or the value of the specified property if `variable` is provided.
     *
     * @memberOf module:fabric-weaver.Utils
     *
     * @example
     * // Example 1: Read the entire YAML file
     * const config = readFileYaml("config/settings.yaml");
     * console.log(config);
     *
     * @example
     * // Example 2: Retrieve a specific property from the YAML file
     * const dbHost = readFileYaml("config/settings.yaml", "database.host");
     * console.log(dbHost);
     *
     * @example
     * // Example 3: Handle an error if the property does not exist
     * const invalidProperty = readFileYaml("config/settings.yaml", "server.port");
     *
     * @mermaid
     * sequenceDiagram
     *   participant Caller
     *   participant readFileYaml
     *   participant logger
     *   participant fs
     *   participant yaml
     *
     *   Caller->>readFileYaml: Call with yamlFilePath and optional variable
     *   readFileYaml->>logger: Log verbose message (Reading YAML file)
     *   readFileYaml->>fs: Read file content
     *   readFileYaml->>logger: Log verbose message (Parsed YAML content)
     *   readFileYaml->>yaml: Parse YAML content
     *   readFileYaml->>logger: Log verbose message (Parsed YAML object)
     *   alt variable is provided
     *     readFileYaml->>readFileYaml: Navigate through parsed YAML using variable path
     *     alt Property exists
     *       readFileYaml-->>Caller: Return specific property value
     *     else Property doesn't exist
     *       readFileYaml->>logger: Log error message
     *       readFileYaml-->>Caller: Return error
     *     end
     *   else variable is not provided
     *     readFileYaml-->>Caller: Return entire parsed YAML object
     *   end
     */
    function readFileYaml(yamlFilePath, variable) {
        const log = logger.for(readFileYaml);
        log.debug(`Reading YAML file: ${yamlFilePath}`);
        const content = fs.readFileSync(yamlFilePath, "utf8");
        log.debug(`Parsed YAML content: ${content}`);
        const parsedYAML = yaml.load(content);
        log.debug(`Parsed YAML object: ${JSON.stringify(parsedYAML, null, 2)}`);
        log.info(`Returning ${variable ? `property '${variable}'` : "the entire parsed YAML object"}`);
        if (!variable)
            return parsedYAML;
        const variablePath = variable.split(".");
        return variablePath.reduce((acc, key) => {
            // eslint-disable-next-line no-prototype-builtins
            if (!acc.hasOwnProperty(key)) {
                throw new Error(`Unable to locate a property named '${key}' from path '${variable}' in file: \n> ${yamlFilePath}`);
            }
            return typeof acc[key] === "string" ? acc[key].trim() : acc[key];
        }, parsedYAML);
    }
    /**
     * @description Writes a JSON object to a YAML file.
     * @summary This function takes a JSON object and writes it to a specified file path in YAML format.
     * It uses js-yaml to convert the JSON to YAML, and then writes the content to the file.
     *
     * @function writeFileYaml
     * @template T - The type of the JSON object to be written.
     * @param {string} path - The file path where the YAML content will be written.
     * @param {T} json - The JSON object to be converted to YAML and written to the file.
     * @return {void}
     *
     * @memberOf module:fabric-weaver.Utils
     *
     * @example
     * const config = { database: { host: 'localhost', port: 5432 } };
     * writeFileYaml('config/settings.yaml', config);
     *
     * @mermaid
     * sequenceDiagram
     *   participant Caller
     *   participant writeFileYaml
     *   participant logger
     *   participant yaml
     *   participant fs
     *
     *   Caller->>writeFileYaml: Call with path and JSON
     *   writeFileYaml->>logger: Log verbose message (Writing YAML file)
     *   writeFileYaml->>logger: Log verbose message (Writing YAML content)
     *   writeFileYaml->>yaml: Convert JSON to YAML
     *   writeFileYaml->>logger: Log verbose message (Writing YAML content to file)
     *   writeFileYaml->>fs: Write YAML content to file
     *   writeFileYaml-->>Caller: Return (void)
     */
    function writeFileYaml(path, json) {
        const log = logger.for(writeFileYaml);
        log.debug(`Writing YAML file: ${path}`);
        log.debug(`Writing YAML content: ${JSON.stringify(json, null, 2)}`);
        const content = yaml.dump(json, { indent: 2, lineWidth: -1 });
        log.debug(`Writing YAML content to file: ${content}`);
        fs.writeFileSync(path, content.replace(/ null$/gm, ""), "utf8");
    }

    async function runCommand(command, args = [], options = { stdio: "inherit" }, logMatch) {
        const log = logging.Logging.for(runCommand);
        log.info(`Running command: ${command} ${args.join(" ")}`);
        if (!logMatch)
            return child_process.execSync([command, ...args].join(" "), options);
        return new Promise((resolve, reject) => {
            const child = child_process.spawn(command, args, options);
            let stdoutData = "";
            let stderrData = "";
            const checkMatch = (data) => {
                if (logMatch && logMatch.test(data)) {
                    resolve(child);
                }
            };
            child.stdout.on("data", (data) => {
                const strData = data.toString();
                console.log(strData);
                stdoutData += strData;
                checkMatch(strData);
            });
            child.stderr.on("data", (data) => {
                const strData = data.toString();
                console.error(strData);
                stderrData += strData;
                checkMatch(strData);
            });
            child.on("error", (err) => {
                reject(err);
            });
            child.on("close", (code) => {
                if (code === 0) {
                    resolve(child);
                }
                else {
                    reject(new Error(`Process exited with code ${code}\nStdout: ${stdoutData}\nStderr: ${stderrData}`));
                }
            });
        });
    }

    /**
     * @module fabric-weaver
     * @description This module serves as the main entry point for the fabric-weaver library, providing TypeScript integration with Hyperledger Fabric.
     * @summary Aggregates and exports functionality for managing Hyperledger Fabric infrastructures.
     *
     * The module includes:
     * 1. Utility functions and types from the "./utils" directory:
     *    - Helper functions for interacting with Fabric binaries.
     *    - Utilities for generating and managing Docker Compose files.
     *    - Functions to assist in creating, maintaining, and updating Hyperledger Fabric networks.
     *
     * 2. Core functionality from the "./core" directory:
     *    - TypeScript interfaces and classes representing Fabric concepts.
     *    - Implementation of Fabric operations and interactions.
     *
     * 3. A VERSION constant:
     *    - Represents the current version of the fabric-weaver module.
     *    - Useful for version checking and compatibility purposes.
     *
     * This structure provides a comprehensive toolkit for working with Hyperledger Fabric in TypeScript,
     * allowing developers to easily set up, manage, and interact with Fabric networks and components.
     */
    /**
     * @const VERSION
     * @name VERSION
     * @description Represents the current version of the fabric-weaver module.
     * @summary The actual version number is replaced during the build process.
     * @type {string}
     */
    const VERSION = "0.0.14";

    exports.BuildScriptsCustom = BuildScriptsCustom;
    exports.VERSION = VERSION;
    exports.mapParser = mapParser;
    exports.readFileYaml = readFileYaml;
    exports.runCommand = runCommand;
    exports.safeParseCSV = safeParseCSV;
    exports.safeParseInt = safeParseInt;
    exports.safeParseJSON = safeParseJSON;
    exports.safeParseSSV = safeParseSSV;
    exports.writeFileYaml = writeFileYaml;

}));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fabric-weaver.cjs","sources":["../src/utils-old/build-scripts.ts","../src/core/constants/constants.ts","../src/utils/parsers.ts","../src/utils/yaml.ts","../src/utils/child-process.ts","../src/index.ts"],"sourcesContent":["/**\n * @module build-scripts\n * @description Custom build scripts for the fabric-weaver project.\n * @summary This module extends the BuildScripts class from @decaf-ts/utils to provide custom build functionality for the fabric-weaver project. It includes utilities for building command-line interfaces and handling different module formats (CommonJS and ES Modules).\n */\n\nimport { BuildScripts, readFile, writeFile } from \"@decaf-ts/utils\";\nimport fs from \"fs\";\nimport path from \"path\";\n\n/**\n * @description Enumeration of module modes.\n * @summary Defines the different module formats supported in the build process.\n * @enum {string}\n * @readonly\n * @memberOf module:build-scripts\n */\nenum Modes {\n  /** CommonJS module format */\n  CJS = \"commonjs\",\n  /** ECMAScript module format (ES2022) */\n  ESM = \"es2022\",\n}\n\n/**\n * @description Custom build scripts for the fabric-weaver project.\n * @summary Extends the BuildScripts class to provide project-specific build functionality, including command bundling and file manipulation.\n * @class BuildScriptsCustom\n * @extends BuildScripts\n */\nexport class BuildScriptsCustom extends BuildScripts {\n  /**\n   * @description Builds command-line interfaces for the project.\n   * @summary Processes each command in the Commands array, bundling the TypeScript files, adding a shebang line, and setting appropriate permissions.\n   * @return {Promise<void>}\n   * @mermaid\n   * sequenceDiagram\n   *   participant BuildScriptsCustom\n   *   participant FileSystem\n   *   loop For each command\n   *     BuildScriptsCustom->>BuildScriptsCustom: bundle(Modes.CJS, true, true, `src/bin/${cmd}.ts`, cmd)\n   *     BuildScriptsCustom->>FileSystem: readFile(`bin/${cmd}.cjs`)\n   *     FileSystem-->>BuildScriptsCustom: file content\n   *     BuildScriptsCustom->>BuildScriptsCustom: Add shebang to file content\n   *     BuildScriptsCustom->>FileSystem: writeFile(`bin/${cmd}.cjs`, modified content)\n   *     BuildScriptsCustom->>FileSystem: chmodSync(`bin/${cmd}.cjs`, \"755\")\n   *   end\n   */\n  async buildCommands() {\n    const commands = fs.readdirSync(path.join(process.cwd() + \"/src/bin\"));\n    for (const cmd of commands) {\n      if (!cmd.endsWith(\".ts\")) continue;\n\n      await this.bundle(Modes.CJS, true, true, `src/bin/${cmd}`, cmd);\n      let data = readFile(`bin/${cmd}.cjs`);\n      data = \"#!/usr/bin/env node\\n\" + data;\n      writeFile(`bin/${cmd}.cjs`, data);\n      fs.chmodSync(`bin/${cmd}.cjs`, \"755\");\n    }\n  }\n}\n","export const COMMA_SEPARATOR = \",\";\nexport const COLON_SEPARATOR = \":\";\nexport const PIPE_SEPARATOR = \"|\";\nexport const SLASH_SEPARATOR = \"/\";\n\nexport const NAME_PLACEHOLDER = \"##NAME##\";\nexport const VERSION_PLACEHOLDER = \"##VER##\";\nexport const ENTRY_PLACEHOLDER = \"##ENTRY##\";\n","import { COMMA_SEPARATOR, SLASH_SEPARATOR } from \"../core/constants/constants\";\n\nexport function safeParseJSON(v: string): unknown {\n  try {\n    return JSON.parse(v);\n  } catch (e) {\n    throw new Error(`Invalid JSON: ${(e as Error).message}`);\n  }\n}\n\nexport function safeParseInt(v: string | number): number {\n  if (typeof v === \"number\") return Math.floor(v);\n\n  const value = Number(v);\n\n  if (!Number.isInteger(value)) {\n    throw new Error(`Invalid integer value: ${v}`);\n  }\n\n  return value;\n}\n\nexport function safeParseCSV(csv: string): string[] {\n  if (!csv.trim()) return [];\n\n  return csv.split(COMMA_SEPARATOR).map((item) => item.trim());\n}\n\nexport function safeParseSSV(csv: string): string[] {\n  console.log(csv);\n  if (!csv.trim()) return [];\n\n  return csv.split(SLASH_SEPARATOR).map((item) => `\"${item.trim()}\"`);\n}\n\nexport function mapParser(\n  map: Map<string, string | number | boolean | string[]>\n): string[] {\n  const argz = Array.from(map, ([key, value]) => {\n    if (typeof value === \"boolean\") {\n      return value ? [`--${key}`] : [];\n    }\n    if (Array.isArray(value)) {\n      return [`--${key}`, value.join(\",\")];\n    }\n    return [`--${key}`, value.toString()];\n  });\n\n  return argz.map((el) => el.join(\" \"));\n}\n","import fs from \"fs\";\nimport yaml from \"js-yaml\";\nimport { Logging } from \"@decaf-ts/logging\";\n\nconst logger = Logging.for(\"yaml\");\n\n/**\n * @description Reads and parses a YAML file, optionally retrieving a specific property.\n * @summary This function reads a YAML file from the given path, parses its content, and returns either the entire parsed YAML object or a specific property value based on the provided path.\n *\n * @function readFileYaml\n * @template T - The type of the returned value when a specific property is requested.\n * @param {string} yamlFilePath - The path to the YAML file to be read.\n * @param {string} [variable] - Optional. A dot-notated path string that specifies the property to retrieve from the parsed YAML.\n * @return {Record<string, any> | T} Returns the entire parsed YAML object if no `variable` is provided, or the value of the specified property if `variable` is provided.\n *\n * @memberOf module:fabric-weaver.Utils\n *\n * @example\n * // Example 1: Read the entire YAML file\n * const config = readFileYaml(\"config/settings.yaml\");\n * console.log(config);\n *\n * @example\n * // Example 2: Retrieve a specific property from the YAML file\n * const dbHost = readFileYaml(\"config/settings.yaml\", \"database.host\");\n * console.log(dbHost);\n *\n * @example\n * // Example 3: Handle an error if the property does not exist\n * const invalidProperty = readFileYaml(\"config/settings.yaml\", \"server.port\");\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant readFileYaml\n *   participant logger\n *   participant fs\n *   participant yaml\n *\n *   Caller->>readFileYaml: Call with yamlFilePath and optional variable\n *   readFileYaml->>logger: Log verbose message (Reading YAML file)\n *   readFileYaml->>fs: Read file content\n *   readFileYaml->>logger: Log verbose message (Parsed YAML content)\n *   readFileYaml->>yaml: Parse YAML content\n *   readFileYaml->>logger: Log verbose message (Parsed YAML object)\n *   alt variable is provided\n *     readFileYaml->>readFileYaml: Navigate through parsed YAML using variable path\n *     alt Property exists\n *       readFileYaml-->>Caller: Return specific property value\n *     else Property doesn't exist\n *       readFileYaml->>logger: Log error message\n *       readFileYaml-->>Caller: Return error\n *     end\n *   else variable is not provided\n *     readFileYaml-->>Caller: Return entire parsed YAML object\n *   end\n */\nexport function readFileYaml<T>(\n  yamlFilePath: string,\n  variable?: string\n): Record<string, any> | T {\n  const log = logger.for(readFileYaml);\n\n  log.debug(`Reading YAML file: ${yamlFilePath}`);\n  const content = fs.readFileSync(yamlFilePath, \"utf8\");\n\n  log.debug(`Parsed YAML content: ${content}`);\n  const parsedYAML = yaml.load(content) as Record<string, any>;\n\n  log.debug(`Parsed YAML object: ${JSON.stringify(parsedYAML, null, 2)}`);\n\n  log.info(\n    `Returning ${variable ? `property '${variable}'` : \"the entire parsed YAML object\"}`\n  );\n  if (!variable) return parsedYAML;\n\n  const variablePath = variable.split(\".\");\n\n  return variablePath.reduce((acc, key) => {\n    // eslint-disable-next-line no-prototype-builtins\n    if (!acc.hasOwnProperty(key)) {\n      throw new Error(\n        `Unable to locate a property named '${key}' from path '${variable}' in file: \\n> ${yamlFilePath}`\n      );\n    }\n    return typeof acc[key] === \"string\" ? acc[key].trim() : acc[key];\n  }, parsedYAML);\n}\n\n/**\n * @description Writes a JSON object to a YAML file.\n * @summary This function takes a JSON object and writes it to a specified file path in YAML format.\n * It uses js-yaml to convert the JSON to YAML, and then writes the content to the file.\n *\n * @function writeFileYaml\n * @template T - The type of the JSON object to be written.\n * @param {string} path - The file path where the YAML content will be written.\n * @param {T} json - The JSON object to be converted to YAML and written to the file.\n * @return {void}\n *\n * @memberOf module:fabric-weaver.Utils\n *\n * @example\n * const config = { database: { host: 'localhost', port: 5432 } };\n * writeFileYaml('config/settings.yaml', config);\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant writeFileYaml\n *   participant logger\n *   participant yaml\n *   participant fs\n *\n *   Caller->>writeFileYaml: Call with path and JSON\n *   writeFileYaml->>logger: Log verbose message (Writing YAML file)\n *   writeFileYaml->>logger: Log verbose message (Writing YAML content)\n *   writeFileYaml->>yaml: Convert JSON to YAML\n *   writeFileYaml->>logger: Log verbose message (Writing YAML content to file)\n *   writeFileYaml->>fs: Write YAML content to file\n *   writeFileYaml-->>Caller: Return (void)\n */\nexport function writeFileYaml<T>(path: string, json: T) {\n  const log = logger.for(writeFileYaml);\n\n  log.debug(`Writing YAML file: ${path}`);\n  log.debug(`Writing YAML content: ${JSON.stringify(json, null, 2)}`);\n  const content = yaml.dump(json, { indent: 2, lineWidth: -1 });\n\n  log.debug(`Writing YAML content to file: ${content}`);\n  fs.writeFileSync(path, content.replace(/ null$/gm, \"\"), \"utf8\");\n}\n","import { spawn, ChildProcess, execSync } from \"child_process\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\n\nexport async function runCommand(\n  command: string,\n  args: string[] = [],\n  options: { [indexer: string]: string } = { stdio: \"inherit\" },\n  logMatch?: RegExp\n): Promise<ChildProcess | void | Buffer> {\n  const log: Logger = Logging.for(runCommand);\n  log.info(`Running command: ${command} ${args.join(\" \")}`);\n\n  if (!logMatch) return execSync([command, ...args].join(\" \"), options);\n\n  return new Promise((resolve, reject) => {\n    const child = spawn(command, args, options);\n    let stdoutData = \"\";\n    let stderrData = \"\";\n\n    const checkMatch = (data: string) => {\n      if (logMatch && logMatch.test(data)) {\n        resolve(child);\n      }\n    };\n\n    child.stdout.on(\"data\", (data: Buffer) => {\n      const strData = data.toString();\n      console.log(strData);\n      stdoutData += strData;\n      checkMatch(strData);\n    });\n\n    child.stderr.on(\"data\", (data: Buffer) => {\n      const strData = data.toString();\n      console.error(strData);\n      stderrData += strData;\n      checkMatch(strData);\n    });\n\n    child.on(\"error\", (err: Error) => {\n      reject(err);\n    });\n\n    child.on(\"close\", (code: number) => {\n      if (code === 0) {\n        resolve(child);\n      } else {\n        reject(\n          new Error(\n            `Process exited with code ${code}\\nStdout: ${stdoutData}\\nStderr: ${stderrData}`\n          )\n        );\n      }\n    });\n  });\n}\n","/**\n * @module fabric-weaver\n * @description This module serves as the main entry point for the fabric-weaver library, providing TypeScript integration with Hyperledger Fabric.\n * @summary Aggregates and exports functionality for managing Hyperledger Fabric infrastructures.\n *\n * The module includes:\n * 1. Utility functions and types from the \"./utils\" directory:\n *    - Helper functions for interacting with Fabric binaries.\n *    - Utilities for generating and managing Docker Compose files.\n *    - Functions to assist in creating, maintaining, and updating Hyperledger Fabric networks.\n *\n * 2. Core functionality from the \"./core\" directory:\n *    - TypeScript interfaces and classes representing Fabric concepts.\n *    - Implementation of Fabric operations and interactions.\n *\n * 3. A VERSION constant:\n *    - Represents the current version of the fabric-weaver module.\n *    - Useful for version checking and compatibility purposes.\n *\n * This structure provides a comprehensive toolkit for working with Hyperledger Fabric in TypeScript,\n * allowing developers to easily set up, manage, and interact with Fabric networks and components.\n */\n\nexport * from \"./utils-old\";\nexport * from \"./utils\";\n\n/**\n * @const VERSION\n * @name VERSION\n * @description Represents the current version of the fabric-weaver module.\n * @summary The actual version number is replaced during the build process.\n * @type {string}\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["BuildScripts","readFile","writeFile","Logging","execSync","spawn"],"mappings":"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"}