@decaf-ts/utils 0.1.6

package/lib/esm/bin/tag-release.js

@@ -0,0 +1,10 @@
+import { ReleaseScript } from "../cli/commands";
+new ReleaseScript()
+    .execute()
+    .then(() => ReleaseScript.log.info("Release pushed successfully"))
+    .catch((e) => {
+    ReleaseScript.log.error(`Error preparing release: ${e}`);
+    process.exit(1);
+});
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9iaW4vdGFnLXJlbGVhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRWhELElBQUksYUFBYSxFQUFFO0tBQ2hCLE9BQU8sRUFBRTtLQUNULElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyw2QkFBNkIsQ0FBQyxDQUFDO0tBQ2pFLEtBQUssQ0FBQyxDQUFDLENBQVUsRUFBRSxFQUFFO0lBQ3BCLGFBQWEsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLDRCQUE0QixDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3pELE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbEIsQ0FBQyxDQUFDLENBQUMiLCJmaWxlIjoiYmluL3RhZy1yZWxlYXNlLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVsZWFzZVNjcmlwdCB9IGZyb20gXCIuLi9jbGkvY29tbWFuZHNcIjtcblxubmV3IFJlbGVhc2VTY3JpcHQoKVxuICAuZXhlY3V0ZSgpXG4gIC50aGVuKCgpID0+IFJlbGVhc2VTY3JpcHQubG9nLmluZm8oXCJSZWxlYXNlIHB1c2hlZCBzdWNjZXNzZnVsbHlcIikpXG4gIC5jYXRjaCgoZTogdW5rbm93bikgPT4ge1xuICAgIFJlbGVhc2VTY3JpcHQubG9nLmVycm9yKGBFcnJvciBwcmVwYXJpbmcgcmVsZWFzZTogJHtlfWApO1xuICAgIHByb2Nlc3MuZXhpdCgxKTtcbiAgfSk7XG4iXX0=

package/lib/esm/bin/update-scripts.js

@@ -0,0 +1,10 @@
+import { TemplateSync } from "../cli/commands";
+new TemplateSync()
+    .execute()
+    .then(() => TemplateSync.log.info("Template updated successfully. Please confirm all changes before commiting"))
+    .catch((e) => {
+    TemplateSync.log.error(`Error preparing template: ${e}`);
+    process.exit(1);
+});
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9iaW4vdXBkYXRlLXNjcmlwdHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRS9DLElBQUksWUFBWSxFQUFFO0tBQ2YsT0FBTyxFQUFFO0tBQ1QsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUNULFlBQVksQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUNuQiw0RUFBNEUsQ0FDN0UsQ0FDRjtLQUNBLEtBQUssQ0FBQyxDQUFDLENBQVUsRUFBRSxFQUFFO0lBQ3BCLFlBQVksQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLDZCQUE2QixDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3pELE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFDbEIsQ0FBQyxDQUFDLENBQUMiLCJmaWxlIjoiYmluL3VwZGF0ZS1zY3JpcHRzLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVGVtcGxhdGVTeW5jIH0gZnJvbSBcIi4uL2NsaS9jb21tYW5kc1wiO1xuXG5uZXcgVGVtcGxhdGVTeW5jKClcbiAgLmV4ZWN1dGUoKVxuICAudGhlbigoKSA9PlxuICAgIFRlbXBsYXRlU3luYy5sb2cuaW5mbyhcbiAgICAgIFwiVGVtcGxhdGUgdXBkYXRlZCBzdWNjZXNzZnVsbHkuIFBsZWFzZSBjb25maXJtIGFsbCBjaGFuZ2VzIGJlZm9yZSBjb21taXRpbmdcIlxuICAgIClcbiAgKVxuICAuY2F0Y2goKGU6IHVua25vd24pID0+IHtcbiAgICBUZW1wbGF0ZVN5bmMubG9nLmVycm9yKGBFcnJvciBwcmVwYXJpbmcgdGVtcGxhdGU6ICR7ZX1gKTtcbiAgICBwcm9jZXNzLmV4aXQoMSk7XG4gIH0pO1xuIl19

package/lib/esm/cli/command.js

@@ -0,0 +1,149 @@
+import { Logging } from "../output/logging";
+import { DefaultLoggingConfig } from "../utils/constants";
+import { UserInput } from "../input/input";
+import { DefaultCommandOptions, DefaultCommandValues } from "./constants";
+import { getDependencies, getPackageVersion } from "../utils/fs";
+import { printBanner } from "../output/common";
+import { Environment } from "../utils/environment";
+/**
+ * @class Command
+ * @abstract
+ * @template I - The type of input options for the command.
+ * @template R - The return type of the command execution.
+ * @memberOf utils/cli
+ * @description Abstract base class for command implementation.
+ * @summary Provides a structure for creating command-line interface commands with input handling, logging, and execution flow.
+ *
+ * @param {string} name - The name of the command.
+ * @param {CommandOptions<I>} [inputs] - The input options for the command.
+ * @param {string[]} [requirements] - The list of required dependencies for the command.
+ */
+export class Command {
+    constructor(name, inputs = {}, requirements = []) {
+        this.name = name;
+        this.inputs = inputs;
+        this.requirements = requirements;
+        if (!Command.log) {
+            Object.defineProperty(Command, "log", {
+                writable: false,
+                value: Logging.for(Command.name),
+            });
+            this.log = Command.log;
+        }
+        this.log = Command.log.for(this.name);
+        this.inputs = Object.assign({}, DefaultCommandOptions, inputs);
+    }
+    /**
+     * @protected
+     * @async
+     * @description Checks if all required dependencies are present.
+     * @summary Retrieves the list of dependencies and compares it against the required dependencies for the command.
+     * @returns {Promise<void>} A promise that resolves when the check is complete.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant Command
+     *   participant getDependencies
+     *   participant Set
+     *   Command->>getDependencies: Call
+     *   getDependencies-->>Command: Return {prod, dev, peer}
+     *   Command->>Set: Create Set from prod, dev, peer
+     *   Set-->>Command: Return unique dependencies
+     *   Command->>Command: Compare against requirements
+     *   alt Missing dependencies
+     *     Command->>Command: Add to missing list
+     *   end
+     *   Note over Command: If missing.length > 0, handle missing dependencies
+     */
+    async checkRequirements() {
+        const { prod, dev, peer } = await getDependencies();
+        const missing = [];
+        const fullList = Array.from(new Set([...prod, ...dev, ...peer]).values()).map((d) => d.name);
+        for (const dep of this.requirements)
+            if (!fullList.includes(dep))
+                missing.push(dep);
+        if (!missing.length)
+            return;
+    }
+    /**
+     * @protected
+     * @description Provides help information for the command.
+     * @summary This method should be overridden in derived classes to provide specific help information.
+     * @param {ParseArgsResult} args - The parsed command-line arguments.
+     * @returns {void}
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    help(args) {
+        return this.log.info(`This is help. I'm no use because I should have been overridden.`);
+    }
+    /**
+     * @async
+     * @description Executes the command.
+     * @summary This method handles the overall execution flow of the command, including parsing arguments,
+     * setting up logging, checking for version or help requests, and running the command.
+     * @returns {Promise<R | string | void>} A promise that resolves with the command's result.
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant Command
+     *   participant UserInput
+     *   participant Logging
+     *   participant getPackageVersion
+     *   participant printBanner
+     *   Command->>UserInput: parseArgs(inputs)
+     *   UserInput-->>Command: Return ParseArgsResult
+     *   Command->>Command: Process options
+     *   Command->>Logging: setConfig(options)
+     *   alt version requested
+     *     Command->>getPackageVersion: Call
+     *     getPackageVersion-->>Command: Return version
+     *   else help requested
+     *     Command->>Command: help(args)
+     *   else banner requested
+     *     Command->>printBanner: Call
+     *   end
+     *   Command->>Command: run(args)
+     *   alt error occurs
+     *     Command->>Command: Log error
+     *   end
+     *   Command-->>Command: Return result
+     */
+    async execute() {
+        const args = UserInput.parseArgs(this.inputs);
+        const env = Environment.accumulate(DefaultLoggingConfig)
+            .accumulate(DefaultCommandValues)
+            .accumulate(args.values);
+        const { timestamp, verbose, version, help, logLevel, logStyle, banner } = env;
+        this.log.setConfig({
+            ...env,
+            timestamp: !!timestamp,
+            level: logLevel,
+            style: !!logStyle,
+            verbose: verbose || 0,
+        });
+        if (version) {
+            return getPackageVersion();
+        }
+        if (help) {
+            return this.help(args);
+        }
+        if (banner)
+            printBanner(this.log.for(printBanner, {
+                timestamp: false,
+                style: false,
+                context: false,
+                logLevel: false,
+            }));
+        let result;
+        try {
+            result = await this.run(env);
+        }
+        catch (e) {
+            this.log.error(`Error while running provided cli function: ${e}`);
+            throw e;
+        }
+        return result;
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/cli/command.ts"],"names":[],"mappings":"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","file":"cli/command.js","sourcesContent":["import { ParseArgsResult } from \"../input/types\";\nimport { LoggingConfig, VerbosityLogger } from \"../output/types\";\nimport { CommandOptions } from \"./types\";\nimport { Logging } from \"../output/logging\";\nimport { DefaultLoggingConfig, LogLevel } from \"../utils/constants\";\nimport { UserInput } from \"../input/input\";\nimport { DefaultCommandOptions, DefaultCommandValues } from \"./constants\";\nimport { getDependencies, getPackageVersion } from \"../utils/fs\";\nimport { printBanner } from \"../output/common\";\nimport { Environment } from \"../utils/environment\";\n\n/**\n * @class Command\n * @abstract\n * @template I - The type of input options for the command.\n * @template R - The return type of the command execution.\n * @memberOf utils/cli\n * @description Abstract base class for command implementation.\n * @summary Provides a structure for creating command-line interface commands with input handling, logging, and execution flow.\n *\n * @param {string} name - The name of the command.\n * @param {CommandOptions<I>} [inputs] - The input options for the command.\n * @param {string[]} [requirements] - The list of required dependencies for the command.\n */\nexport abstract class Command<I, R> {\n  /**\n   * @static\n   * @description Static logger for the Command class.\n   * @type {VerbosityLogger}\n   */\n  static log: VerbosityLogger;\n\n  /**\n   * @protected\n   * @description Instance logger for the command.\n   * @type {VerbosityLogger}\n   */\n  protected log: VerbosityLogger;\n\n  protected constructor(\n    protected name: string,\n    protected inputs: CommandOptions<I> = {} as unknown as CommandOptions<I>,\n    protected requirements: string[] = []\n  ) {\n    if (!Command.log) {\n      Object.defineProperty(Command, \"log\", {\n        writable: false,\n        value: Logging.for(Command.name),\n      });\n      this.log = Command.log;\n    }\n    this.log = Command.log.for(this.name);\n    this.inputs = Object.assign({}, DefaultCommandOptions, inputs);\n  }\n\n  /**\n   * @protected\n   * @async\n   * @description Checks if all required dependencies are present.\n   * @summary Retrieves the list of dependencies and compares it against the required dependencies for the command.\n   * @returns {Promise<void>} A promise that resolves when the check is complete.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant Command\n   *   participant getDependencies\n   *   participant Set\n   *   Command->>getDependencies: Call\n   *   getDependencies-->>Command: Return {prod, dev, peer}\n   *   Command->>Set: Create Set from prod, dev, peer\n   *   Set-->>Command: Return unique dependencies\n   *   Command->>Command: Compare against requirements\n   *   alt Missing dependencies\n   *     Command->>Command: Add to missing list\n   *   end\n   *   Note over Command: If missing.length > 0, handle missing dependencies\n   */\n  protected async checkRequirements(): Promise<void> {\n    const { prod, dev, peer } = await getDependencies();\n    const missing = [];\n    const fullList = Array.from(\n      new Set([...prod, ...dev, ...peer]).values()\n    ).map((d) => d.name);\n    for (const dep of this.requirements)\n      if (!fullList.includes(dep)) missing.push(dep);\n\n    if (!missing.length) return;\n  }\n\n  /**\n   * @protected\n   * @description Provides help information for the command.\n   * @summary This method should be overridden in derived classes to provide specific help information.\n   * @param {ParseArgsResult} args - The parsed command-line arguments.\n   * @returns {void}\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  protected help(args: ParseArgsResult): void {\n    return this.log.info(\n      `This is help. I'm no use because I should have been overridden.`\n    );\n  }\n\n  /**\n   * @protected\n   * @abstract\n   * @description Runs the command with the provided arguments.\n   * @summary This method should be implemented in derived classes to define the command's behavior.\n   * @param {ParseArgsResult} answers - The parsed command-line arguments.\n   * @returns {Promise<R | string | void>} A promise that resolves with the command's result.\n   */\n  protected abstract run<R>(\n    answers: LoggingConfig &\n      typeof DefaultCommandValues & { [k in keyof I]: unknown }\n  ): Promise<R | string | void>;\n\n  /**\n   * @async\n   * @description Executes the command.\n   * @summary This method handles the overall execution flow of the command, including parsing arguments,\n   * setting up logging, checking for version or help requests, and running the command.\n   * @returns {Promise<R | string | void>} A promise that resolves with the command's result.\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant Command\n   *   participant UserInput\n   *   participant Logging\n   *   participant getPackageVersion\n   *   participant printBanner\n   *   Command->>UserInput: parseArgs(inputs)\n   *   UserInput-->>Command: Return ParseArgsResult\n   *   Command->>Command: Process options\n   *   Command->>Logging: setConfig(options)\n   *   alt version requested\n   *     Command->>getPackageVersion: Call\n   *     getPackageVersion-->>Command: Return version\n   *   else help requested\n   *     Command->>Command: help(args)\n   *   else banner requested\n   *     Command->>printBanner: Call\n   *   end\n   *   Command->>Command: run(args)\n   *   alt error occurs\n   *     Command->>Command: Log error\n   *   end\n   *   Command-->>Command: Return result\n   */\n  async execute(): Promise<R | string | void> {\n    const args: ParseArgsResult = UserInput.parseArgs(this.inputs);\n    const env = Environment.accumulate(DefaultLoggingConfig)\n      .accumulate(DefaultCommandValues)\n      .accumulate(args.values);\n    const { timestamp, verbose, version, help, logLevel, logStyle, banner } =\n      env;\n\n    this.log.setConfig({\n      ...env,\n      timestamp: !!timestamp,\n      level: logLevel as LogLevel,\n      style: !!logStyle,\n      verbose: (verbose as number) || 0,\n    });\n\n    if (version) {\n      return getPackageVersion();\n    }\n\n    if (help) {\n      return this.help(args);\n    }\n\n    if (banner)\n      printBanner(\n        this.log.for(printBanner, {\n          timestamp: false,\n          style: false,\n          context: false,\n          logLevel: false,\n        })\n      );\n\n    let result;\n    try {\n      result = await this.run(env);\n    } catch (e: unknown) {\n      this.log.error(`Error while running provided cli function: ${e}`);\n      throw e;\n    }\n\n    return result as R;\n  }\n}\n"]}

package/lib/esm/cli/commands/index.js

@@ -0,0 +1,4 @@
+export * from "./tag-release";
+export * from "./update-scripts";
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInNyYy9jbGkvY29tbWFuZHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxrQkFBa0IsQ0FBQyIsImZpbGUiOiJjbGkvY29tbWFuZHMvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi90YWctcmVsZWFzZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXBkYXRlLXNjcmlwdHNcIjtcbiJdfQ==

package/lib/esm/cli/commands/tag-release.js

@@ -0,0 +1,164 @@
+import { runCommand } from "../../utils/utils";
+import { NoCIFLag, SemVersion, SemVersionRegex } from "../../utils/constants";
+import { UserInput } from "../../input/input";
+import { Command } from "../command";
+const options = {
+    ci: {
+        type: "boolean",
+        default: true,
+    },
+    message: {
+        type: "string",
+        short: "m",
+    },
+    tag: {
+        type: "string",
+        short: "t",
+        default: undefined,
+    },
+};
+/**
+ * @class ReleaseScript
+ * @extends {Command}
+ * @cavegory scripts
+ * @description A command-line script for managing releases and version updates.
+ * @summary This script automates the process of creating and pushing new releases. It handles version updates,
+ * commit messages, and optionally publishes to NPM. The script supports semantic versioning and can work in both CI and non-CI environments.
+ *
+ * @param {Object} options - Configuration options for the script
+ * @param {boolean} options.ci - Whether the script is running in a CI environment (default: true)
+ * @param {string} options.message - The release message (short: 'm')
+ * @param {string} options.tag - The version tag to use (short: 't', default: undefined)
+ */
+export class ReleaseScript extends Command {
+    constructor() {
+        super("ReleaseScript", options);
+    }
+    /**
+     * @description Prepares the version for the release.
+     * @summary This method validates the provided tag or prompts the user for a new one if not provided or invalid.
+     * It also displays the latest git tags for reference.
+     * @param {string} tag - The version tag to prepare
+     * @returns {Promise<string>} The prepared version tag
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant R as ReleaseScript
+     *   participant T as TestVersion
+     *   participant U as UserInput
+     *   participant G as Git
+     *   R->>T: testVersion(tag)
+     *   alt tag is valid
+     *     T-->>R: return tag
+     *   else tag is invalid or not provided
+     *     R->>G: List latest git tags
+     *     R->>U: Prompt for new tag
+     *     U-->>R: return new tag
+     *   end
+     */
+    async prepareVersion(tag) {
+        const log = this.log.for(this.prepareVersion);
+        tag = this.testVersion(tag || "");
+        if (!tag) {
+            log.verbose("No release message provided. Prompting for one:");
+            log.info(`Listing latest git tags:`);
+            await runCommand("git tag --sort=-taggerdate | head -n 5").promise;
+            return await UserInput.insistForText("tag", "Enter the new tag number (accepts v*.*.*[-...])", (val) => !!val.toString().match(/^v[0-9]+\.[0-9]+.[0-9]+(-[0-9a-zA-Z-]+)?$/));
+        }
+        return tag;
+    }
+    /**
+     * @description Tests if the provided version is valid.
+     * @summary This method checks if the version is a valid semantic version or a predefined update type (PATCH, MINOR, MAJOR).
+     * @param {string} version - The version to test
+     * @returns {string | undefined} The validated version or undefined if invalid
+     */
+    testVersion(version) {
+        const log = this.log.for(this.testVersion);
+        version = version.trim().toLowerCase();
+        switch (version) {
+            case SemVersion.PATCH:
+            case SemVersion.MINOR:
+            case SemVersion.MAJOR:
+                log.verbose(`Using provided SemVer update: ${version}`, 1);
+                return version;
+            default:
+                log.verbose(`Testing provided version for SemVer compatibility: ${version}`, 1);
+                if (!new RegExp(SemVersionRegex).test(version)) {
+                    log.debug(`Invalid version number: ${version}`);
+                    return undefined;
+                }
+                log.verbose(`version approved: ${version}`, 1);
+                return version;
+        }
+    }
+    /**
+     * @description Prepares the release message.
+     * @summary This method either returns the provided message or prompts the user for a new one if not provided.
+     * @param {string} [message] - The release message
+     * @returns {Promise<string>} The prepared release message
+     */
+    async prepareMessage(message) {
+        const log = this.log.for(this.prepareMessage);
+        if (!message) {
+            log.verbose("No release message provided. Prompting for one");
+            return await UserInput.insistForText("message", "What should be the release message/ticket?", (val) => !!val && val.toString().length > 5);
+        }
+        return message;
+    }
+    /**
+     * @description Runs the release script.
+     * @summary This method orchestrates the entire release process, including version preparation, message creation,
+     * git operations, and npm publishing (if not in CI environment).
+     * @param {ParseArgsResult} args - The parsed command-line arguments
+     * @returns {Promise<void>}
+     *
+     * @mermaid
+     * sequenceDiagram
+     *   participant R as ReleaseScript
+     *   participant V as PrepareVersion
+     *   participant M as PrepareMessage
+     *   participant N as NPM
+     *   participant G as Git
+     *   participant U as UserInput
+     *   R->>V: prepareVersion(tag)
+     *   R->>M: prepareMessage(message)
+     *   R->>N: Run prepare-release script
+     *   R->>G: Check git status
+     *   alt changes exist
+     *     R->>U: Ask for confirmation
+     *     U-->>R: Confirm
+     *     R->>G: Add and commit changes
+     *   end
+     *   R->>N: Update npm version
+     *   R->>G: Push changes and tags
+     *   alt not CI environment
+     *     R->>N: Publish to npm
+     *   end
+     */
+    async run(args) {
+        let result;
+        const { ci } = args;
+        let { tag, message } = args;
+        tag = await this.prepareVersion(tag);
+        message = await this.prepareMessage(message);
+        result = await runCommand(`npm run prepare-release -- ${tag} ${message}`, {
+            cwd: process.cwd(),
+        }).promise;
+        result = await runCommand("git status --porcelain").promise;
+        await result;
+        if (result.logs.length &&
+            (await UserInput.askConfirmation("git-changes", "Do you want to push the changes to the remote repository?", true))) {
+            await runCommand("git add .").promise;
+            await runCommand(`git commit -m "${tag} - ${message} - after release preparation${ci ? "" : NoCIFLag}"`).promise;
+        }
+        await runCommand(`npm version "${tag}" -m "${message}${ci ? "" : NoCIFLag}"`).promise;
+        await runCommand("git push --follow-tags").promise;
+        if (!ci) {
+            await runCommand("NPM_TOKEN=$(cat .npmtoken) npm publish --access public")
+                .promise;
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["src/cli/commands/tag-release.ts"],"names":[],"mappings":"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","file":"cli/commands/tag-release.js","sourcesContent":["import { runCommand } from \"../../utils/utils\";\nimport { NoCIFLag, SemVersion, SemVersionRegex } from \"../../utils/constants\";\nimport { UserInput } from \"../../input/input\";\nimport { Command } from \"../command\";\nimport { LoggingConfig } from \"../../output\";\nimport { DefaultCommandValues } from \"../index\";\n\nconst options = {\n  ci: {\n    type: \"boolean\",\n    default: true,\n  },\n  message: {\n    type: \"string\",\n    short: \"m\",\n  },\n  tag: {\n    type: \"string\",\n    short: \"t\",\n    default: undefined,\n  },\n};\n\n/**\n * @class ReleaseScript\n * @extends {Command}\n * @cavegory scripts\n * @description A command-line script for managing releases and version updates.\n * @summary This script automates the process of creating and pushing new releases. It handles version updates,\n * commit messages, and optionally publishes to NPM. The script supports semantic versioning and can work in both CI and non-CI environments.\n *\n * @param {Object} options - Configuration options for the script\n * @param {boolean} options.ci - Whether the script is running in a CI environment (default: true)\n * @param {string} options.message - The release message (short: 'm')\n * @param {string} options.tag - The version tag to use (short: 't', default: undefined)\n */\nexport class ReleaseScript extends Command<typeof options, void> {\n  constructor() {\n    super(\"ReleaseScript\", options);\n  }\n\n  /**\n   * @description Prepares the version for the release.\n   * @summary This method validates the provided tag or prompts the user for a new one if not provided or invalid.\n   * It also displays the latest git tags for reference.\n   * @param {string} tag - The version tag to prepare\n   * @returns {Promise<string>} The prepared version tag\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant R as ReleaseScript\n   *   participant T as TestVersion\n   *   participant U as UserInput\n   *   participant G as Git\n   *   R->>T: testVersion(tag)\n   *   alt tag is valid\n   *     T-->>R: return tag\n   *   else tag is invalid or not provided\n   *     R->>G: List latest git tags\n   *     R->>U: Prompt for new tag\n   *     U-->>R: return new tag\n   *   end\n   */\n  async prepareVersion(tag?: string): Promise<string> {\n    const log = this.log.for(this.prepareVersion);\n    tag = this.testVersion((tag as string) || \"\");\n    if (!tag) {\n      log.verbose(\"No release message provided. Prompting for one:\");\n      log.info(`Listing latest git tags:`);\n      await runCommand(\"git tag --sort=-taggerdate | head -n 5\").promise;\n      return await UserInput.insistForText(\n        \"tag\",\n        \"Enter the new tag number (accepts v*.*.*[-...])\",\n        (val) =>\n          !!val.toString().match(/^v[0-9]+\\.[0-9]+.[0-9]+(-[0-9a-zA-Z-]+)?$/)\n      );\n    }\n    return tag;\n  }\n\n  /**\n   * @description Tests if the provided version is valid.\n   * @summary This method checks if the version is a valid semantic version or a predefined update type (PATCH, MINOR, MAJOR).\n   * @param {string} version - The version to test\n   * @returns {string | undefined} The validated version or undefined if invalid\n   */\n  testVersion(version: string): string | undefined {\n    const log = this.log.for(this.testVersion);\n    version = version.trim().toLowerCase();\n    switch (version) {\n      case SemVersion.PATCH:\n      case SemVersion.MINOR:\n      case SemVersion.MAJOR:\n        log.verbose(`Using provided SemVer update: ${version}`, 1);\n        return version;\n      default:\n        log.verbose(\n          `Testing provided version for SemVer compatibility: ${version}`,\n          1\n        );\n        if (!new RegExp(SemVersionRegex).test(version)) {\n          log.debug(`Invalid version number: ${version}`);\n          return undefined;\n        }\n        log.verbose(`version approved: ${version}`, 1);\n        return version;\n    }\n  }\n\n  /**\n   * @description Prepares the release message.\n   * @summary This method either returns the provided message or prompts the user for a new one if not provided.\n   * @param {string} [message] - The release message\n   * @returns {Promise<string>} The prepared release message\n   */\n  async prepareMessage(message?: string) {\n    const log = this.log.for(this.prepareMessage);\n    if (!message) {\n      log.verbose(\"No release message provided. Prompting for one\");\n      return await UserInput.insistForText(\n        \"message\",\n        \"What should be the release message/ticket?\",\n        (val) => !!val && val.toString().length > 5\n      );\n    }\n    return message;\n  }\n\n  /**\n   * @description Runs the release script.\n   * @summary This method orchestrates the entire release process, including version preparation, message creation,\n   * git operations, and npm publishing (if not in CI environment).\n   * @param {ParseArgsResult} args - The parsed command-line arguments\n   * @returns {Promise<void>}\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant R as ReleaseScript\n   *   participant V as PrepareVersion\n   *   participant M as PrepareMessage\n   *   participant N as NPM\n   *   participant G as Git\n   *   participant U as UserInput\n   *   R->>V: prepareVersion(tag)\n   *   R->>M: prepareMessage(message)\n   *   R->>N: Run prepare-release script\n   *   R->>G: Check git status\n   *   alt changes exist\n   *     R->>U: Ask for confirmation\n   *     U-->>R: Confirm\n   *     R->>G: Add and commit changes\n   *   end\n   *   R->>N: Update npm version\n   *   R->>G: Push changes and tags\n   *   alt not CI environment\n   *     R->>N: Publish to npm\n   *   end\n   */\n  async run(\n    args: LoggingConfig &\n      typeof DefaultCommandValues & { [k in keyof typeof options]: unknown }\n  ): Promise<void> {\n    let result: any;\n    const { ci } = args;\n    let { tag, message } = args;\n    tag = await this.prepareVersion(tag as string);\n    message = await this.prepareMessage(message as string);\n    result = await runCommand(`npm run prepare-release -- ${tag} ${message}`, {\n      cwd: process.cwd(),\n    }).promise;\n    result = await runCommand(\"git status --porcelain\").promise;\n    await result;\n    if (\n      result.logs.length &&\n      (await UserInput.askConfirmation(\n        \"git-changes\",\n        \"Do you want to push the changes to the remote repository?\",\n        true\n      ))\n    ) {\n      await runCommand(\"git add .\").promise;\n      await runCommand(\n        `git commit -m \"${tag} - ${message} - after release preparation${ci ? \"\" : NoCIFLag}\"`\n      ).promise;\n    }\n    await runCommand(\n      `npm version \"${tag}\" -m \"${message}${ci ? \"\" : NoCIFLag}\"`\n    ).promise;\n    await runCommand(\"git push --follow-tags\").promise;\n    if (!ci) {\n      await runCommand(\"NPM_TOKEN=$(cat .npmtoken) npm publish --access public\")\n        .promise;\n    }\n  }\n}\n"]}