@bitblit/ratchet-node-only 4.0.80-alpha

package/dist/cjs/build/ratchet-node-only-info.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatchetNodeOnlyInfo = void 0;
+class RatchetNodeOnlyInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '80',
+            hash: '10fcb761c2fa4186df89e527e948f5780a4e14ac',
+            branch: 'alpha-2023-03-12-2',
+            tag: 'alpha-2023-03-12-2',
+            timeBuiltISO: '2023-03-12T20:00:51-0700',
+            notes: '',
+        };
+        return val;
+    }
+}
+exports.RatchetNodeOnlyInfo = RatchetNodeOnlyInfo;

package/dist/cjs/ci/apply-ci-env-variables-to-files.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplyCiEnvVariablesToFiles = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const ci_run_information_util_1 = require("./ci-run-information-util");
+class ApplyCiEnvVariablesToFiles {
+    static async process(fileNames, cfg, buildFinder = 'LOCAL-SNAPSHOT', branchFinder = 'LOCAL-BRANCH', hashFinder = 'LOCAL-HASH', tagFinder = 'LOCAL-TAG', timeFinder = 'LOCAL-TIME') {
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(cfg, 'cfg');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(cfg.buildNumber, 'cfg.buildNumber');
+        ratchet_common_1.RequireRatchet.notNullOrUndefined(cfg.localTime, 'cfg.localTime');
+        if (!fileNames) {
+            throw new Error('fileNames must be defined');
+        }
+        if (fileNames.length === 0) {
+            ratchet_common_1.Logger.warn('Warning - no files supplied to process');
+        }
+        if (!cfg.buildNumber) {
+            ratchet_common_1.ErrorRatchet.throwFormattedErr('%s env var not set - apparently not in a CI environment', cfg.buildNumber);
+        }
+        ratchet_common_1.Logger.info('Processing files %j with run info %j', cfg);
+        let foundCount = 0;
+        fileNames.forEach((f) => {
+            if (!fs_1.default.existsSync(f)) {
+                ratchet_common_1.Logger.error('Could not find file %s to process, continuing', f);
+            }
+            else {
+                try {
+                    let contents = fs_1.default.readFileSync(f).toString();
+                    contents = contents.split(buildFinder).join(cfg.buildNumber);
+                    contents = contents.split(branchFinder).join(cfg.branch || '');
+                    contents = contents.split(hashFinder).join(cfg.commitHash || '');
+                    contents = contents.split(tagFinder).join(cfg.tag || '');
+                    contents = contents.split(timeFinder).join(cfg.localTime || '');
+                    fs_1.default.writeFileSync(f, contents);
+                    foundCount++;
+                }
+                catch (err) {
+                    ratchet_common_1.Logger.error('Error processing %s , continuing: %s', f, err, err);
+                }
+            }
+        });
+        return foundCount;
+    }
+    static extractFileNames() {
+        let rval = [];
+        if (process && process.argv && process.argv.length > 3) {
+            rval = process.argv.slice(3);
+        }
+        return rval;
+    }
+    static extractVariableConfig(inName) {
+        let rval = null;
+        const name = ratchet_common_1.StringRatchet.trimToEmpty(inName).toLowerCase();
+        switch (name) {
+            case 'circleci':
+                rval = ci_run_information_util_1.CiRunInformationUtil.createDefaultCircleCiRunInformation();
+                break;
+            case 'github':
+                rval = ci_run_information_util_1.CiRunInformationUtil.createDefaultGithubActionsRunInformation();
+                break;
+            case 'test':
+                rval = ci_run_information_util_1.CiRunInformationUtil.createTestingCiRunInformation();
+                break;
+            default:
+                ratchet_common_1.ErrorRatchet.throwFormattedErr('Unrecognized env var config type : %s', name);
+        }
+        ratchet_common_1.Logger.info('Using variable config : %j', rval);
+        return rval;
+    }
+    static async runFromCliArgs(args) {
+        if (args.length > 1) {
+            return ApplyCiEnvVariablesToFiles.process(args.slice(1), ApplyCiEnvVariablesToFiles.extractVariableConfig(args[0]));
+        }
+        else {
+            ratchet_common_1.Logger.infoP('Usage : apply-ci-env-variables-to-files {file1} {file2} ...');
+            return -1;
+        }
+    }
+}
+exports.ApplyCiEnvVariablesToFiles = ApplyCiEnvVariablesToFiles;

package/dist/cjs/ci/ci-run-information-util.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CiRunInformationUtil = void 0;
+const luxon_1 = require("luxon");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class CiRunInformationUtil {
+    static createTestingCiRunInformation(timezone = CiRunInformationUtil.DEFAULT_TIME_ZONE) {
+        const now = new Date().toISOString();
+        const rval = {
+            buildNumber: 'Test_buildNumberVar_' + now,
+            localTime: luxon_1.DateTime.local().setZone(timezone).toFormat(CiRunInformationUtil.DEFAULT_TIME_FORMAT),
+            branch: 'Test_branchVar_' + now,
+            tag: 'Test_tagVar_' + now,
+            commitHash: 'Test_hashVar_' + now,
+            userName: 'Test_userNameVar_' + now,
+            projectName: 'Test_projectNameVar_' + now,
+        };
+        return rval;
+    }
+    static createDefaultCircleCiRunInformation(timezone = CiRunInformationUtil.DEFAULT_TIME_ZONE) {
+        const rval = {
+            buildNumber: ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_BUILD_NUM'),
+            branch: ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_BRANCH'),
+            tag: ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_TAG'),
+            commitHash: ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_SHA1'),
+            localTime: luxon_1.DateTime.local().setZone(timezone).toFormat(CiRunInformationUtil.DEFAULT_TIME_FORMAT),
+            userName: ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_USERNAME'),
+            projectName: ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_PROJECT_REPONAME'),
+        };
+        return rval;
+    }
+    static createDefaultGithubActionsRunInformation(timezone = CiRunInformationUtil.DEFAULT_TIME_ZONE) {
+        const rval = {
+            buildNumber: ratchet_common_1.GlobalRatchet.fetchGlobalVar('GITHUB_RUN_NUMBER'),
+            branch: ratchet_common_1.GlobalRatchet.fetchGlobalVar('GITHUB_REF_NAME'),
+            tag: ratchet_common_1.GlobalRatchet.fetchGlobalVar('GITHUB_REF_NAME'),
+            commitHash: ratchet_common_1.GlobalRatchet.fetchGlobalVar('GITHUB_SHA'),
+            localTime: luxon_1.DateTime.local().setZone(timezone).toFormat(CiRunInformationUtil.DEFAULT_TIME_FORMAT),
+            userName: ratchet_common_1.GlobalRatchet.fetchGlobalVar('GITHUB_ACTOR'),
+            projectName: ratchet_common_1.GlobalRatchet.fetchGlobalVar('GITHUB_REPOSITORY'),
+        };
+        return rval;
+    }
+}
+exports.CiRunInformationUtil = CiRunInformationUtil;
+CiRunInformationUtil.DEFAULT_TIME_FORMAT = 'yyyy-MM-dd HH:mm:ss a z';
+CiRunInformationUtil.DEFAULT_TIME_ZONE = 'America/Los_Angeles';

package/dist/cjs/ci/ci-run-information.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/cli/abstract-ratchet-cli-handler.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRatchetCliHandler = void 0;
+const cli_ratchet_1 = require("./cli-ratchet");
+class AbstractRatchetCliHandler {
+    async findAndExecuteHandler() {
+        let handler = null;
+        if (cli_ratchet_1.CliRatchet.argsAfterCommand(['version'])) {
+            console.log('Version : ' + JSON.stringify(this.fetchVersionInfo()));
+        }
+        else {
+            const handlerMap = this.fetchHandlerMap();
+            const keys = Object.keys(handlerMap);
+            let remainArgs = null;
+            for (let i = 0; i < keys.length && !handler; i++) {
+                remainArgs = cli_ratchet_1.CliRatchet.argsAfterCommand([keys[i], keys[i] + '.js']);
+                if (remainArgs) {
+                    handler = handlerMap[keys[i]];
+                }
+            }
+            if (handler) {
+                console.debug('Running command with args ' + JSON.stringify(remainArgs));
+                await handler(remainArgs);
+            }
+            else {
+                console.log('Unrecognized command : ', process.argv);
+                console.log('Valid commands are : ', Object.keys(handlerMap));
+            }
+        }
+    }
+}
+exports.AbstractRatchetCliHandler = AbstractRatchetCliHandler;

package/dist/cjs/cli/cli-ratchet.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliRatchet = void 0;
+class CliRatchet {
+    static isCalledFromCLI(filenames) {
+        let rval = false;
+        for (let i = 0; filenames && i < filenames.length && !rval; i++) {
+            rval = CliRatchet.indexOfCommandArgument(filenames[i]) > -1;
+        }
+        return rval;
+    }
+    static argsAfterCommand(filenames) {
+        var _a;
+        let rval = null;
+        if (((_a = process === null || process === void 0 ? void 0 : process.argv) === null || _a === void 0 ? void 0 : _a.length) && (filenames === null || filenames === void 0 ? void 0 : filenames.length)) {
+            let idx = null;
+            for (let i = 0; i < filenames.length && idx === null; i++) {
+                idx = CliRatchet.indexOfCommandArgument(filenames[i]);
+            }
+            rval = idx !== null ? process.argv.slice(idx + 1, process.argv.length) : null;
+        }
+        return rval;
+    }
+    static isCalledFromCLISingle(filename) {
+        return CliRatchet.isCalledFromCLI([filename]);
+    }
+    static indexOfCommandArgument(filename) {
+        const contFileName = process.argv.map((arg) => arg.indexOf(filename) !== -1);
+        const idx = contFileName.indexOf(true);
+        return idx === -1 ? null : idx;
+    }
+}
+exports.CliRatchet = CliRatchet;

package/dist/cjs/cli/ratchet-cli-handler.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RatchetCliHandler = void 0;
+const ratchet_node_only_info_1 = require("../build/ratchet-node-only-info");
+const apply_ci_env_variables_to_files_1 = require("../ci/apply-ci-env-variables-to-files");
+const files_to_static_class_1 = require("../files/files-to-static-class");
+const publish_ci_release_to_slack_1 = require("../third-party/slack/publish-ci-release-to-slack");
+const abstract_ratchet_cli_handler_1 = require("./abstract-ratchet-cli-handler");
+class RatchetCliHandler extends abstract_ratchet_cli_handler_1.AbstractRatchetCliHandler {
+    fetchHandlerMap() {
+        return {
+            'apply-ci-env-variables-to-files': apply_ci_env_variables_to_files_1.ApplyCiEnvVariablesToFiles.runFromCliArgs,
+            'files-to-static-class': files_to_static_class_1.FilesToStaticClass.runFromCliArgs,
+            'publish-ci-release-to-slack': publish_ci_release_to_slack_1.PublishCiReleaseToSlack.runFromCliArgs,
+        };
+    }
+    fetchVersionInfo() {
+        return ratchet_node_only_info_1.RatchetNodeOnlyInfo.buildInformation();
+    }
+}
+exports.RatchetCliHandler = RatchetCliHandler;

package/dist/cjs/csv/csv-ratchet.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CsvRatchet = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const csv_parse_1 = require("csv-parse");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const csv_stringify_1 = require("csv-stringify");
+const ratchet_common_2 = require("@bitblit/ratchet-common");
+const ratchet_common_3 = require("@bitblit/ratchet-common");
+const stream_1 = require("stream");
+class CsvRatchet {
+    static defaultParseOptions() {
+        const rval = {
+            delimiter: ',',
+            columns: true,
+        };
+        return rval;
+    }
+    static defaultStringifyOptions() {
+        const rval = {
+            header: true,
+        };
+        return rval;
+    }
+    static async stringParse(input, pf, opts = CsvRatchet.defaultParseOptions()) {
+        return CsvRatchet.streamParse(stream_1.Readable.from(input), pf, opts);
+    }
+    static async streamParse(readStream, pf, opts = CsvRatchet.defaultParseOptions()) {
+        return new Promise((res, rej) => {
+            const rval = [];
+            const p = (0, csv_parse_1.parse)(opts);
+            p.on('readable', () => {
+                let record = p.read();
+                while (record) {
+                    const newVal = pf(record);
+                    if (newVal) {
+                        rval.push(newVal);
+                    }
+                    else {
+                    }
+                    record = p.read();
+                }
+            });
+            p.on('error', (err) => {
+                rej(err);
+            });
+            p.on('end', () => {
+                res(rval);
+            });
+            readStream.pipe(p);
+        });
+    }
+    static async fileParse(filename, pf) {
+        const readStream = fs_1.default.createReadStream(filename);
+        return CsvRatchet.streamParse(readStream, pf);
+    }
+    static async generateCsvData(objectsToConvert, opts = CsvRatchet.defaultStringifyOptions()) {
+        ratchet_common_1.Logger.silly('Converting %d items into csv file', objectsToConvert.length);
+        const genProm = new Promise((res, rej) => {
+            (0, csv_stringify_1.stringify)(objectsToConvert, opts, function (err, data) {
+                if (err) {
+                    rej(err);
+                }
+                else {
+                    res(data);
+                }
+            });
+        });
+        return genProm;
+    }
+    static async generateComparison(file1, file2, keyField) {
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(file1, 'file1');
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(file2, 'file2');
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(keyField, 'keyField');
+        ratchet_common_1.Logger.info('Created csv compare with files %s and %s keyed on %s', file1, file2, keyField);
+        let file1Parsed = await this.streamParse(fs_1.default.createReadStream(file1), (f) => {
+            f;
+        });
+        file1Parsed = file1Parsed.map((m) => {
+            const next = {};
+            Object.keys(m).forEach((k) => {
+                next[k.trim()] = m[k];
+            });
+            return next;
+        });
+        const file1Mapped = ratchet_common_3.MapRatchet.mapByUniqueProperty(file1Parsed, keyField);
+        let file2Parsed = await this.streamParse(fs_1.default.createReadStream(file2), (f) => {
+            f;
+        });
+        file2Parsed = file2Parsed.map((m) => {
+            const next = {};
+            Object.keys(m).forEach((k) => {
+                next[k.trim()] = m[k];
+            });
+            return next;
+        });
+        const file2Mapped = ratchet_common_3.MapRatchet.mapByUniqueProperty(file2Parsed, keyField);
+        const f1Only = [];
+        const f2Only = [];
+        const both = [];
+        Array.from(file1Mapped.keys()).forEach((f1k) => {
+            if (file2Mapped.has(f1k)) {
+                both.push(f1k);
+            }
+            else {
+                f1Only.push(f1k);
+            }
+        });
+        Array.from(file2Mapped.keys()).forEach((f1k) => {
+            if (!file1Mapped.has(f1k)) {
+                f2Only.push(f1k);
+            }
+        });
+        const rval = {
+            file1Data: file1Mapped,
+            file2Data: file2Mapped,
+            file1OnlyKeys: f1Only,
+            file2OnlyKeys: f2Only,
+            bothFilesKeys: both,
+        };
+        return rval;
+    }
+    static async streamObjectsToCsv(srcSubject, output, inOpts) {
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(srcSubject, 'srcSubject');
+        ratchet_common_2.RequireRatchet.notNullOrUndefined(output, 'output');
+        const opts = inOpts || CsvRatchet.defaultStringifyOptions();
+        ratchet_common_1.Logger.silly('Running pipe to csv output : %j', opts);
+        let count = 0;
+        const genProm = new Promise((res, rej) => {
+            const stringifier = (0, csv_stringify_1.stringify)(opts);
+            stringifier.on('error', (err) => {
+                if (sub) {
+                    sub.unsubscribe();
+                }
+                rej(err);
+            });
+            stringifier.on('finish', () => {
+                if (sub) {
+                    sub.unsubscribe();
+                }
+                res(count);
+            });
+            stringifier.pipe(output);
+            const sub = srcSubject.subscribe((next) => {
+                ratchet_common_1.Logger.debug('Adding %j to csv', next);
+                count++;
+                stringifier.write(next);
+            }, (err) => {
+                ratchet_common_1.Logger.error('Error generating : %s', err);
+                rej(err);
+            }, () => {
+                ratchet_common_1.Logger.debug('Finished');
+                stringifier.end();
+            });
+        });
+        return genProm;
+    }
+    static defaultParseFunction(row) {
+        return row;
+    }
+}
+exports.CsvRatchet = CsvRatchet;

package/dist/cjs/files/files-to-static-class.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesToStaticClass = void 0;
+const tslib_1 = require("tslib");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const cli_ratchet_1 = require("../cli/cli-ratchet");
+class FilesToStaticClass {
+    static async process(fileNames, outClassName, outFileName = null) {
+        if (!fileNames) {
+            throw new Error('fileNames must be defined');
+        }
+        if (!outClassName) {
+            throw new Error('outClassName must be defined');
+        }
+        if (fileNames.length === 0) {
+            ratchet_common_1.Logger.warn('Warning - no files supplied to process');
+        }
+        ratchet_common_1.Logger.info('Generating class %s from files %j (output file: %s)', outClassName, fileNames, outFileName);
+        let rval = '/** \n';
+        rval += '* Holder for the constants to be used by consumers \n';
+        rval += '* Moves it into code so that it can survive a trip through WebPack \n';
+        rval += '*/ \n\n';
+        rval += 'export class ' + outClassName + ' { \n';
+        rval += '  public static readonly VALUES:Record<string, string> = { \n';
+        for (let i = 0; i < fileNames.length; i++) {
+            let contents = 'NOT-FOUND';
+            if (fs_1.default.existsSync(fileNames[i])) {
+                const trimmed = fileNames[i].substring(fileNames[i].lastIndexOf('/') + 1);
+                contents = fs_1.default.readFileSync(fileNames[i]).toString();
+                rval += i > 0 ? ',' : '';
+                rval += '"' + trimmed + '":' + JSON.stringify(contents) + '\n';
+            }
+            else {
+                ratchet_common_1.Logger.warn('Could not find file %s', fileNames[i]);
+            }
+        }
+        rval += '}; \n';
+        rval += '}';
+        if (!!outFileName) {
+            ratchet_common_1.Logger.info('Writing to %s', outFileName);
+            fs_1.default.writeFileSync(outFileName, rval);
+        }
+        return rval;
+    }
+    static async runFromCliArgs(args) {
+        if (args.length < 4) {
+            ratchet_common_1.Logger.infoP('Usage: ratchet-files-to-static-class {outFileName} {outClassName} {file0} ... {fileN}');
+            return null;
+        }
+        else {
+            const idx = cli_ratchet_1.CliRatchet.indexOfCommandArgument('files-to-static-class');
+            const outFileName = process.argv[idx + 1];
+            const outClassName = process.argv[idx + 2];
+            const files = process.argv.slice(idx + 3);
+            ratchet_common_1.Logger.info('Running FilesToStaticClass from command line arguments Target: %s TargetClass: %s InFiles: %j', outFileName, outClassName, files);
+            return FilesToStaticClass.process(files, outClassName, outFileName);
+        }
+    }
+}
+exports.FilesToStaticClass = FilesToStaticClass;

package/dist/cjs/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./build/ratchet-node-only-info"), exports);
+tslib_1.__exportStar(require("./ci/apply-ci-env-variables-to-files"), exports);
+tslib_1.__exportStar(require("./ci/ci-run-information-util"), exports);
+tslib_1.__exportStar(require("./ci/ci-run-information"), exports);
+tslib_1.__exportStar(require("./cli/abstract-ratchet-cli-handler"), exports);
+tslib_1.__exportStar(require("./cli/cli-ratchet"), exports);
+tslib_1.__exportStar(require("./cli/ratchet-cli-handler"), exports);
+tslib_1.__exportStar(require("./csv/csv-ratchet"), exports);
+tslib_1.__exportStar(require("./files/files-to-static-class"), exports);
+tslib_1.__exportStar(require("./third-party/git/git-ratchet"), exports);
+tslib_1.__exportStar(require("./third-party/slack/publish-ci-release-to-slack"), exports);

package/dist/cjs/third-party/git/git-ratchet.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitRatchet = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = tslib_1.__importDefault(require("child_process"));
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+class GitRatchet {
+    static async executeCommand(command, options) {
+        let dst = __dirname;
+        if (!!options && !!options.dst) {
+            dst = options.dst;
+        }
+        return new Promise((res, rej) => {
+            child_process_1.default.exec(command, { cwd: dst }, (err, stdout, stderr) => {
+                if (stdout === '') {
+                    rej('this does not look like a git repo');
+                }
+                if (!!stderr) {
+                    rej(stderr);
+                }
+                res(stdout);
+            });
+        });
+    }
+    static getCommandString(splitChar) {
+        return ('git log -1 --pretty=format:"' +
+            GitRatchet.PRETTY_FORMAT.join(splitChar) +
+            '"' +
+            ' && git rev-parse --abbrev-ref HEAD' +
+            ' && git tag --contains HEAD');
+    }
+    static async getLastCommitSwallowException(options = {}) {
+        let rval = null;
+        try {
+            rval = await this.getLastCommit(options);
+        }
+        catch (err) {
+            ratchet_common_1.Logger.warn('Failed to fetch git data : %s', err, err);
+        }
+        return rval;
+    }
+    static async getLastCommit(options = {}) {
+        const command = GitRatchet.getCommandString(GitRatchet.SPLIT_CHARACTER);
+        const res = await GitRatchet.executeCommand(command, options);
+        const a = res.split(GitRatchet.SPLIT_CHARACTER);
+        const branchAndTags = a[a.length - 1].split('\n').filter((n) => n);
+        const branch = branchAndTags[0];
+        const tags = branchAndTags.slice(1);
+        const rval = {
+            shortHash: a[0],
+            hash: a[1],
+            subject: a[2],
+            sanitizedSubject: a[3],
+            body: a[4],
+            authoredOn: a[5],
+            committedOn: a[6],
+            author: {
+                name: a[7],
+                email: a[8],
+            },
+            committer: {
+                name: a[9],
+                email: a[10],
+            },
+            notes: a[11],
+            branch,
+            tags,
+        };
+        return rval;
+    }
+}
+exports.GitRatchet = GitRatchet;
+GitRatchet.SPLIT_CHARACTER = '<##>';
+GitRatchet.PRETTY_FORMAT = ['%h', '%H', '%s', '%f', '%b', '%at', '%ct', '%an', '%ae', '%cn', '%ce', '%N', ''];

package/dist/cjs/third-party/slack/publish-ci-release-to-slack.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishCiReleaseToSlack = void 0;
+const tslib_1 = require("tslib");
+const luxon_1 = require("luxon");
+const ratchet_common_1 = require("@bitblit/ratchet-common");
+const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
+const util_1 = tslib_1.__importDefault(require("util"));
+const git_ratchet_1 = require("../git/git-ratchet");
+class PublishCiReleaseToSlack {
+    static async process(slackHookUrl, timezone = 'America/Los_Angeles') {
+        if (!slackHookUrl) {
+            throw new Error('slackHookUrl must be defined');
+        }
+        const buildNum = ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_BUILD_NUM');
+        const userName = ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_USERNAME');
+        const projectName = ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_PROJECT_REPONAME');
+        const branch = ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_BRANCH') || '';
+        const tag = ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_TAG') || '';
+        const sha1 = ratchet_common_1.GlobalRatchet.fetchGlobalVar('CIRCLE_SHA1') || '';
+        const localTime = luxon_1.DateTime.local().setZone(timezone).toFormat('MMMM Do yyyy, h:mm:ss a z');
+        const gitData = await git_ratchet_1.GitRatchet.getLastCommitSwallowException();
+        if (!buildNum || !userName || !projectName) {
+            throw new Error('CIRCLE_BUILD_NUM, CIRCLE_USERNAME, CIRCLE_PROJECT_REPONAME env vars not set - apparently not in a CircleCI environment');
+        }
+        ratchet_common_1.Logger.info('Sending slack notification %j with build %s, branch %s, tag %s, sha %s, time: %s', buildNum, branch, tag, sha1, localTime);
+        let message = util_1.default.format('%s performed release %s on %s at %s', userName, tag + ' ' + branch, projectName, localTime);
+        if (!!gitData && !!gitData.subject) {
+            message += '\n\n' + gitData.subject;
+        }
+        const response = await (0, cross_fetch_1.default)(slackHookUrl, {
+            method: 'POST',
+            mode: 'cors',
+            cache: 'no-cache',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            redirect: 'follow',
+            body: JSON.stringify({ text: message }),
+        });
+        const bodyOut = await response.text();
+        ratchet_common_1.Logger.info('Slack returned : %s', bodyOut);
+        return bodyOut;
+    }
+    static extractHookUrl() {
+        let rval = null;
+        if (process && process.argv && process.argv.length > 2) {
+            rval = process.argv[2];
+        }
+        return rval;
+    }
+    static async runFromCliArgs(args) {
+        ratchet_common_1.Logger.info('Running PublishCiReleaseToSlack from command line arguments');
+        const hook = PublishCiReleaseToSlack.extractHookUrl();
+        if (!!hook) {
+            return PublishCiReleaseToSlack.process(hook);
+        }
+        else {
+            ratchet_common_1.Logger.infoP('Usage : ratchet-publish-circle-ci-release-to-slack {hookUrl} ...');
+            return null;
+        }
+    }
+}
+exports.PublishCiReleaseToSlack = PublishCiReleaseToSlack;

package/dist/es/build/ratchet-node-only-info.js

@@ -0,0 +1,14 @@
+export class RatchetNodeOnlyInfo {
+    constructor() { }
+    static buildInformation() {
+        const val = {
+            version: '80',
+            hash: '10fcb761c2fa4186df89e527e948f5780a4e14ac',
+            branch: 'alpha-2023-03-12-2',
+            tag: 'alpha-2023-03-12-2',
+            timeBuiltISO: '2023-03-12T20:00:51-0700',
+            notes: '',
+        };
+        return val;
+    }
+}