conventional-changelog 7.0.0 → 7.0.2

package/dist/cli/cli.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+import { createReadStream, createWriteStream } from 'fs';
+import {} from '../index.js';
+import { parseOptions, parseCommitsOptions, parseTagsOptions } from './options.js';
+import { loadDataFile, isFileExists } from './utils.js';
+export const flags = {
+    infile: {
+        shortFlag: 'i',
+        default: 'CHANGELOG.md',
+        type: 'string'
+    },
+    outfile: {
+        shortFlag: 'o',
+        type: 'string'
+    },
+    stdout: {
+        type: 'boolean'
+    },
+    preset: {
+        shortFlag: 'p',
+        type: 'string'
+    },
+    pkg: {
+        shortFlag: 'k',
+        type: 'string'
+    },
+    append: {
+        shortFlag: 'a',
+        type: 'boolean'
+    },
+    releaseCount: {
+        shortFlag: 'r',
+        type: 'number'
+    },
+    skipUnstable: {
+        type: 'boolean'
+    },
+    outputUnreleased: {
+        shortFlag: 'u',
+        type: 'boolean'
+    },
+    verbose: {
+        shortFlag: 'v',
+        type: 'boolean'
+    },
+    config: {
+        shortFlag: 'n',
+        type: 'string'
+    },
+    context: {
+        shortFlag: 'c',
+        type: 'string'
+    },
+    firstRelease: {
+        shortFlag: 'f',
+        type: 'boolean'
+    },
+    lernaPackage: {
+        shortFlag: 'l',
+        type: 'string'
+    },
+    tagPrefix: {
+        shortFlag: 't',
+        type: 'string'
+    }
+};
+export async function runProgram(generator, flags) {
+    let { infile, outfile, stdout, verbose, pkg, preset, config, context } = flags;
+    generator.readPackage(pkg);
+    if (preset) {
+        generator.loadPreset(preset);
+    }
+    if (config) {
+        const configOptions = await loadDataFile(config);
+        if (configOptions.tags) {
+            generator.tags(configOptions.tags);
+        }
+        if (configOptions.commits || configOptions.parser) {
+            generator.commits(configOptions.commits || {}, configOptions.parser);
+        }
+        if (configOptions.writer) {
+            generator.writer(configOptions.writer);
+        }
+    }
+    if (context) {
+        const writerContext = await loadDataFile(context);
+        if (writerContext) {
+            generator.context(writerContext);
+        }
+    }
+    const options = parseOptions(flags);
+    if (options) {
+        generator.options(options);
+    }
+    const tagsOptions = parseTagsOptions(flags);
+    if (tagsOptions) {
+        generator.tags(tagsOptions);
+    }
+    const commitsOptions = parseCommitsOptions(flags);
+    if (commitsOptions) {
+        generator.commits(commitsOptions);
+    }
+    if (verbose) {
+        generator.options({
+            debug(namespace, payload) {
+                console.info(`[${namespace}]:`, payload);
+            },
+            warn(namespace, payload) {
+                console.warn(`[${namespace}]:`, payload);
+            }
+        });
+    }
+    outfile ||= infile;
+    const sameFile = !stdout && infile === outfile;
+    const changelog = generator.write();
+    const streams = [];
+    if (infile && options?.releaseCount !== 0) {
+        const isInfileExists = await isFileExists(infile);
+        const input = isInfileExists
+            ? createReadStream(infile)
+            : [];
+        if (!isInfileExists && verbose) {
+            console.warn(`"${infile}" does not exist.`);
+        }
+        if (sameFile) {
+            if (options?.append) {
+                streams.push(changelog);
+            }
+            else {
+                const buffer = [];
+                for await (const chunk of changelog) {
+                    buffer.push(chunk);
+                }
+                for await (const chunk of input) {
+                    buffer.push(chunk);
+                }
+                streams.push(buffer);
+            }
+        }
+        else if (options?.append) {
+            streams.push(input, changelog);
+        }
+        else {
+            streams.push(changelog, input);
+        }
+    }
+    else {
+        streams.push(changelog);
+    }
+    const output = (outfile && !stdout
+        ? createWriteStream(outfile, {
+            flags: sameFile && options?.append ? 'a' : 'w'
+        })
+        : process.stdout);
+    for (const stream of streams) {
+        for await (const chunk of stream) {
+            output.write(chunk);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NsaS9jbGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUNBLE9BQU8sRUFFTCxnQkFBZ0IsRUFDaEIsaUJBQWlCLEVBQ2xCLE1BQU0sSUFBSSxDQUFBO0FBQ1gsT0FBTyxFQUdOLE1BQU0sYUFBYSxDQUFBO0FBQ3BCLE9BQU8sRUFDTCxZQUFZLEVBQ1osbUJBQW1CLEVBQ25CLGdCQUFnQixFQUNqQixNQUFNLGNBQWMsQ0FBQTtBQUNyQixPQUFPLEVBQ0wsWUFBWSxFQUNaLFlBQVksRUFDYixNQUFNLFlBQVksQ0FBQTtBQW9CbkIsTUFBTSxDQUFDLE1BQU0sS0FBSyxHQUFHO0lBQ25CLE1BQU0sRUFBRTtRQUNOLFNBQVMsRUFBRSxHQUFHO1FBQ2QsT0FBTyxFQUFFLGNBQWM7UUFDdkIsSUFBSSxFQUFFLFFBQVE7S0FDZjtJQUNELE9BQU8sRUFBRTtRQUNQLFNBQVMsRUFBRSxHQUFHO1FBQ2QsSUFBSSxFQUFFLFFBQVE7S0FDZjtJQUNELE1BQU0sRUFBRTtRQUNOLElBQUksRUFBRSxTQUFTO0tBQ2hCO0lBQ0QsTUFBTSxFQUFFO1FBQ04sU0FBUyxFQUFFLEdBQUc7UUFDZCxJQUFJLEVBQUUsUUFBUTtLQUNmO0lBQ0QsR0FBRyxFQUFFO1FBQ0gsU0FBUyxFQUFFLEdBQUc7UUFDZCxJQUFJLEVBQUUsUUFBUTtLQUNmO0lBQ0QsTUFBTSxFQUFFO1FBQ04sU0FBUyxFQUFFLEdBQUc7UUFDZCxJQUFJLEVBQUUsU0FBUztLQUNoQjtJQUNELFlBQVksRUFBRTtRQUNaLFNBQVMsRUFBRSxHQUFHO1FBQ2QsSUFBSSxFQUFFLFFBQVE7S0FDZjtJQUNELFlBQVksRUFBRTtRQUNaLElBQUksRUFBRSxTQUFTO0tBQ2hCO0lBQ0QsZ0JBQWdCLEVBQUU7UUFDaEIsU0FBUyxFQUFFLEdBQUc7UUFDZCxJQUFJLEVBQUUsU0FBUztLQUNoQjtJQUNELE9BQU8sRUFBRTtRQUNQLFNBQVMsRUFBRSxHQUFHO1FBQ2QsSUFBSSxFQUFFLFNBQVM7S0FDaEI7SUFDRCxNQUFNLEVBQUU7UUFDTixTQUFTLEVBQUUsR0FBRztRQUNkLElBQUksRUFBRSxRQUFRO0tBQ2Y7SUFDRCxPQUFPLEVBQUU7UUFDUCxTQUFTLEVBQUUsR0FBRztRQUNkLElBQUksRUFBRSxRQUFRO0tBQ2Y7SUFDRCxZQUFZLEVBQUU7UUFDWixTQUFTLEVBQUUsR0FBRztRQUNkLElBQUksRUFBRSxTQUFTO0tBQ2hCO0lBQ0QsWUFBWSxFQUFFO1FBQ1osU0FBUyxFQUFFLEdBQUc7UUFDZCxJQUFJLEVBQUUsUUFBUTtLQUNmO0lBQ0QsU0FBUyxFQUFFO1FBQ1QsU0FBUyxFQUFFLEdBQUc7UUFDZCxJQUFJLEVBQUUsUUFBUTtLQUNmO0NBQ08sQ0FBQTtBQUVWLE1BQU0sQ0FBQyxLQUFLLFVBQVUsVUFBVSxDQUM5QixTQUFnQyxFQUNoQyxLQUFZO0lBRVosSUFBSSxFQUNGLE1BQU0sRUFDTixPQUFPLEVBQ1AsTUFBTSxFQUNOLE9BQU8sRUFDUCxHQUFHLEVBQ0gsTUFBTSxFQUNOLE1BQU0sRUFDTixPQUFPLEVBQ1IsR0FBRyxLQUFLLENBQUE7SUFFVCxTQUFTLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBRTFCLElBQUksTUFBTSxFQUFFO1FBQ1YsU0FBUyxDQUFDLFVBQVUsQ0FBQyxNQUFNLENBQUMsQ0FBQTtLQUM3QjtJQUVELElBQUksTUFBTSxFQUFFO1FBQ1YsTUFBTSxhQUFhLEdBQUcsTUFBTSxZQUFZLENBQUMsTUFBTSxDQUFXLENBQUE7UUFFMUQsSUFBSSxhQUFhLENBQUMsSUFBSSxFQUFFO1lBQ3RCLFNBQVMsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxDQUFBO1NBQ25DO1FBRUQsSUFBSSxhQUFhLENBQUMsT0FBTyxJQUFJLGFBQWEsQ0FBQyxNQUFNLEVBQUU7WUFDakQsU0FBUyxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsT0FBTyxJQUFJLEVBQUUsRUFBRSxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUE7U0FDckU7UUFFRCxJQUFJLGFBQWEsQ0FBQyxNQUFNLEVBQUU7WUFDeEIsU0FBUyxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUE7U0FDdkM7S0FDRjtJQUVELElBQUksT0FBTyxFQUFFO1FBQ1gsTUFBTSxhQUFhLEdBQUcsTUFBTSxZQUFZLENBQUMsT0FBTyxDQUFDLENBQUE7UUFFakQsSUFBSSxhQUFhLEVBQUU7WUFDakIsU0FBUyxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsQ0FBQTtTQUNqQztLQUNGO0lBRUQsTUFBTSxPQUFPLEdBQUcsWUFBWSxDQUFDLEtBQWdDLENBQUMsQ0FBQTtJQUU5RCxJQUFJLE9BQU8sRUFBRTtRQUNYLFNBQVMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLENBQUE7S0FDM0I7SUFFRCxNQUFNLFdBQVcsR0FBRyxnQkFBZ0IsQ0FBQyxLQUFnQyxDQUFDLENBQUE7SUFFdEUsSUFBSSxXQUFXLEVBQUU7UUFDZixTQUFTLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFBO0tBQzVCO0lBRUQsTUFBTSxjQUFjLEdBQUcsbUJBQW1CLENBQUMsS0FBZ0MsQ0FBQyxDQUFBO0lBRTVFLElBQUksY0FBYyxFQUFFO1FBQ2xCLFNBQVMsQ0FBQyxPQUFPLENBQUMsY0FBYyxDQUFDLENBQUE7S0FDbEM7SUFFRCxJQUFJLE9BQU8sRUFBRTtRQUNYLFNBQVMsQ0FBQyxPQUFPLENBQUM7WUFDaEIsS0FBSyxDQUFDLFNBQVMsRUFBRSxPQUFPO2dCQUN0QixPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksU0FBUyxJQUFJLEVBQUUsT0FBTyxDQUFDLENBQUE7WUFDMUMsQ0FBQztZQUNELElBQUksQ0FBQyxTQUFTLEVBQUUsT0FBTztnQkFDckIsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLFNBQVMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFBO1lBQzFDLENBQUM7U0FDRixDQUFDLENBQUE7S0FDSDtJQUVELE9BQU8sS0FBSyxNQUFNLENBQUE7SUFFbEIsTUFBTSxRQUFRLEdBQUcsQ0FBQyxNQUFNLElBQUksTUFBTSxLQUFLLE9BQU8sQ0FBQTtJQUM5QyxNQUFNLFNBQVMsR0FBRyxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUE7SUFDbkMsTUFBTSxPQUFPLEdBQUcsRUFBRSxDQUFBO0lBRWxCLElBQUksTUFBTSxJQUFJLE9BQU8sRUFBRSxZQUFZLEtBQUssQ0FBQyxFQUFFO1FBQ3pDLE1BQU0sY0FBYyxHQUFHLE1BQU0sWUFBWSxDQUFDLE1BQU0sQ0FBQyxDQUFBO1FBQ2pELE1BQU0sS0FBSyxHQUFHLGNBQWM7WUFDMUIsQ0FBQyxDQUFDLGdCQUFnQixDQUFDLE1BQU0sQ0FBQztZQUMxQixDQUFDLENBQUMsRUFBRSxDQUFBO1FBRU4sSUFBSSxDQUFDLGNBQWMsSUFBSSxPQUFPLEVBQUU7WUFDOUIsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLE1BQU0sbUJBQW1CLENBQUMsQ0FBQTtTQUM1QztRQUVELElBQUksUUFBUSxFQUFFO1lBQ1osSUFBSSxPQUFPLEVBQUUsTUFBTSxFQUFFO2dCQUNuQixPQUFPLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFBO2FBQ3hCO2lCQUFNO2dCQUNMLE1BQU0sTUFBTSxHQUFHLEVBQUUsQ0FBQTtnQkFFakIsSUFBSSxLQUFLLEVBQUUsTUFBTSxLQUFLLElBQUksU0FBUyxFQUFFO29CQUNuQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFBO2lCQUNuQjtnQkFFRCxJQUFJLEtBQUssRUFBRSxNQUFNLEtBQUssSUFBSSxLQUFLLEVBQUU7b0JBQy9CLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7aUJBQ25CO2dCQUVELE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUE7YUFDckI7U0FDRjthQUNDLElBQUksT0FBTyxFQUFFLE1BQU0sRUFBRTtZQUNuQixPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRSxTQUFTLENBQUMsQ0FBQTtTQUMvQjthQUFNO1lBQ0wsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsS0FBSyxDQUFDLENBQUE7U0FDL0I7S0FDSjtTQUFNO1FBQ0wsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQTtLQUN4QjtJQUVELE1BQU0sTUFBTSxHQUFHLENBQ2IsT0FBTyxJQUFJLENBQUMsTUFBTTtRQUNoQixDQUFDLENBQUMsaUJBQWlCLENBQUMsT0FBTyxFQUFFO1lBQzNCLEtBQUssRUFBRSxRQUFRLElBQUksT0FBTyxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHO1NBQy9DLENBQUM7UUFDRixDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FDSixDQUFBO0lBRWhCLEtBQUssTUFBTSxNQUFNLElBQUksT0FBTyxFQUFFO1FBQzVCLElBQUksS0FBSyxFQUFFLE1BQU0sS0FBSyxJQUFJLE1BQU0sRUFBRTtZQUNoQyxNQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFBO1NBQ3BCO0tBQ0Y7QUFDSCxDQUFDIn0=

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import meow from 'meow';
+import { ConventionalChangelog } from '../index.js';
+import { flags, runProgram } from './cli.js';
+const cli = meow(`
+  Usage
+    conventional-changelog
+
+  Example
+    conventional-changelog -i changelog -o CHANGELOG.md
+
+  Options
+    -i, --infile              Read the CHANGELOG from this file (default: CHANGELOG.md)
+    -o, --outfile             Write the CHANGELOG to this file (default: infile)
+    --stdout                  Output the result to stdout
+    -p, --preset              Name of the preset you want to use
+    -k, --pkg                 A filepath of where your package.json is located (default: closest package.json)
+    -a, --append              Should the newer release be appended to the older release (default: false)
+    -f, --first-release       Generate the CHANGELOG for the first time
+    -r, --release-count       How many releases to be generated from the latest (default: 1)
+                              If 0, the whole changelog will be regenerated and the outfile will be overwritten
+    --skip-unstable           If given, unstable tags will be skipped, e.g., x.x.x-alpha.1, x.x.x-rc.2
+    -u, --output-unreleased   Output unreleased changelog
+    -v, --verbose             Verbose output. Use this for debugging (default: false)
+    -n, --config              A filepath of your config script
+    -c, --context             A filepath of a json that is used to define template variables
+    -l, --lerna-package       Generate a changelog for a specific lerna package (:pkg-name@1.0.0)
+    -t, --tag-prefix          Tag prefix to consider when reading the tags
+    --commit-path             Generate a changelog scoped to a specific directory
+`, {
+    importMeta: import.meta,
+    booleanDefault: undefined,
+    flags
+});
+await runProgram(new ConventionalChangelog(process.cwd()), cli.flags);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFDQSxPQUFPLElBQUksTUFBTSxNQUFNLENBQUE7QUFDdkIsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sYUFBYSxDQUFBO0FBQ25ELE9BQU8sRUFDTCxLQUFLLEVBQ0wsVUFBVSxFQUNYLE1BQU0sVUFBVSxDQUFBO0FBRWpCLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztDQXlCaEIsRUFBRTtJQUNELFVBQVUsRUFBRSxNQUFNLENBQUMsSUFBSTtJQUN2QixjQUFjLEVBQUUsU0FBUztJQUN6QixLQUFLO0NBQ04sQ0FBQyxDQUFBO0FBRUYsTUFBTSxVQUFVLENBQ2QsSUFBSSxxQkFBcUIsQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUMsRUFDeEMsR0FBRyxDQUFDLEtBQUssQ0FDVixDQUFBIn0=

package/dist/cli/options.d.ts

@@ -0,0 +1,6 @@
+import type { GetCommitsParams, GetSemverTagsParams } from '@conventional-changelog/git-client';
+import type { Options } from '../types.js';
+export declare function parseOptions(options: Record<string, unknown>): Options | null;
+export declare function parseTagsOptions(options: Record<string, unknown>): GetSemverTagsParams | null;
+export declare function parseCommitsOptions(options: Record<string, unknown>): GetCommitsParams | null;
+//# sourceMappingURL=options.d.ts.map

package/dist/cli/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/cli/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,oCAAoC,CAAA;AAE3C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,GAAG,IAAI,CAuB7E;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,mBAAmB,GAAG,IAAI,CAoB7F;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,gBAAgB,GAAG,IAAI,CAY7F"}

package/dist/cli/options.js

@@ -0,0 +1,47 @@
+import { packagePrefix } from '@conventional-changelog/git-client';
+export function parseOptions(options) {
+    const result = {};
+    if (typeof options.append === 'boolean') {
+        result.append = options.append;
+    }
+    if (options.firstRelease === true) {
+        result.releaseCount = 0;
+    }
+    else if (typeof options.releaseCount === 'number') {
+        result.releaseCount = options.releaseCount;
+    }
+    if (typeof options.outputUnreleased === 'boolean') {
+        result.outputUnreleased = options.outputUnreleased;
+    }
+    if (!Object.keys(result).length) {
+        return null;
+    }
+    return result;
+}
+export function parseTagsOptions(options) {
+    const result = {};
+    if (typeof options.tagPrefix === 'string') {
+        result.prefix = options.tagPrefix;
+    }
+    if (typeof options.lernaPackage === 'string') {
+        result.prefix = packagePrefix(options.lernaPackage);
+    }
+    if (options.skipUnstable) {
+        result.skipUnstable = true;
+    }
+    if (!Object.keys(result).length) {
+        return null;
+    }
+    return result;
+}
+export function parseCommitsOptions(options) {
+    const result = {};
+    if (typeof options.commitPath === 'string') {
+        result.path = options.commitPath;
+    }
+    if (!Object.keys(result).length) {
+        return null;
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jbGkvb3B0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0NBQW9DLENBQUE7QUFHbEUsTUFBTSxVQUFVLFlBQVksQ0FBQyxPQUFnQztJQUMzRCxNQUFNLE1BQU0sR0FBWSxFQUFFLENBQUE7SUFFMUIsSUFBSSxPQUFPLE9BQU8sQ0FBQyxNQUFNLEtBQUssU0FBUyxFQUFFO1FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQTtLQUMvQjtJQUVELElBQUksT0FBTyxDQUFDLFlBQVksS0FBSyxJQUFJLEVBQUU7UUFDakMsTUFBTSxDQUFDLFlBQVksR0FBRyxDQUFDLENBQUE7S0FDeEI7U0FDQyxJQUFJLE9BQU8sT0FBTyxDQUFDLFlBQVksS0FBSyxRQUFRLEVBQUU7UUFDNUMsTUFBTSxDQUFDLFlBQVksR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFBO0tBQzNDO0lBRUgsSUFBSSxPQUFPLE9BQU8sQ0FBQyxnQkFBZ0IsS0FBSyxTQUFTLEVBQUU7UUFDakQsTUFBTSxDQUFDLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQTtLQUNuRDtJQUVELElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLE1BQU0sRUFBRTtRQUMvQixPQUFPLElBQUksQ0FBQTtLQUNaO0lBRUQsT0FBTyxNQUFNLENBQUE7QUFDZixDQUFDO0FBRUQsTUFBTSxVQUFVLGdCQUFnQixDQUFDLE9BQWdDO0lBQy9ELE1BQU0sTUFBTSxHQUF3QixFQUFFLENBQUE7SUFFdEMsSUFBSSxPQUFPLE9BQU8sQ0FBQyxTQUFTLEtBQUssUUFBUSxFQUFFO1FBQ3pDLE1BQU0sQ0FBQyxNQUFNLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQTtLQUNsQztJQUVELElBQUksT0FBTyxPQUFPLENBQUMsWUFBWSxLQUFLLFFBQVEsRUFBRTtRQUM1QyxNQUFNLENBQUMsTUFBTSxHQUFHLGFBQWEsQ0FBQyxPQUFPLENBQUMsWUFBWSxDQUFDLENBQUE7S0FDcEQ7SUFFRCxJQUFJLE9BQU8sQ0FBQyxZQUFZLEVBQUU7UUFDeEIsTUFBTSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUE7S0FDM0I7SUFFRCxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxNQUFNLEVBQUU7UUFDL0IsT0FBTyxJQUFJLENBQUE7S0FDWjtJQUVELE9BQU8sTUFBTSxDQUFBO0FBQ2YsQ0FBQztBQUVELE1BQU0sVUFBVSxtQkFBbUIsQ0FBQyxPQUFnQztJQUNsRSxNQUFNLE1BQU0sR0FBcUIsRUFBRSxDQUFBO0lBRW5DLElBQUksT0FBTyxPQUFPLENBQUMsVUFBVSxLQUFLLFFBQVEsRUFBRTtRQUMxQyxNQUFNLENBQUMsSUFBSSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUE7S0FDakM7SUFFRCxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxNQUFNLEVBQUU7UUFDL0IsT0FBTyxJQUFJLENBQUE7S0FDWjtJQUVELE9BQU8sTUFBTSxDQUFBO0FBQ2YsQ0FBQyJ9

package/dist/cli/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function loadDataFile(filePath: string): Promise<object>;
+export declare function isFileExists(filePath: string): Promise<boolean>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/cli/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/cli/utils.ts"],"names":[],"mappings":"AAWA,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAWpE;AAED,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAMrE"}

package/dist/cli/utils.js

@@ -0,0 +1,25 @@
+import { resolve, extname } from 'path';
+import { pathToFileURL } from 'url';
+import { readFile, stat } from 'fs/promises';
+function relativeResolve(filePath) {
+    return pathToFileURL(resolve(process.cwd(), filePath));
+}
+export async function loadDataFile(filePath) {
+    const resolvedFilePath = relativeResolve(filePath);
+    const ext = extname(resolvedFilePath.toString());
+    if (ext === '.json') {
+        return JSON.parse(await readFile(resolvedFilePath, 'utf8'));
+    }
+    // @ts-expect-error Dynamic import actually works with file URLs
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    return (await import(resolvedFilePath)).default;
+}
+export async function isFileExists(filePath) {
+    try {
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFBO0FBQ3ZDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxLQUFLLENBQUE7QUFDbkMsT0FBTyxFQUNMLFFBQVEsRUFDUixJQUFJLEVBQ0wsTUFBTSxhQUFhLENBQUE7QUFFcEIsU0FBUyxlQUFlLENBQUMsUUFBZ0I7SUFDdkMsT0FBTyxhQUFhLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxRQUFRLENBQUMsQ0FBQyxDQUFBO0FBQ3hELENBQUM7QUFFRCxNQUFNLENBQUMsS0FBSyxVQUFVLFlBQVksQ0FBQyxRQUFnQjtJQUNqRCxNQUFNLGdCQUFnQixHQUFHLGVBQWUsQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUNsRCxNQUFNLEdBQUcsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQTtJQUVoRCxJQUFJLEdBQUcsS0FBSyxPQUFPLEVBQUU7UUFDbkIsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sUUFBUSxDQUFDLGdCQUFnQixFQUFFLE1BQU0sQ0FBQyxDQUFXLENBQUE7S0FDdEU7SUFFRCxnRUFBZ0U7SUFDaEUsc0VBQXNFO0lBQ3RFLE9BQU8sQ0FBQyxNQUFNLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUMsT0FBaUIsQ0FBQTtBQUMzRCxDQUFDO0FBRUQsTUFBTSxDQUFDLEtBQUssVUFBVSxZQUFZLENBQUMsUUFBZ0I7SUFDakQsSUFBSTtRQUNGLE9BQU8sQ0FBQyxNQUFNLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFBO0tBQ3ZDO0lBQUMsTUFBTTtRQUNOLE9BQU8sS0FBSyxDQUFBO0tBQ2I7QUFDSCxDQUFDIn0=

package/dist/hostedGitInfo.d.ts

@@ -0,0 +1,3 @@
+import type { HostedGitInfo } from './types.js';
+export declare function parseHostedGitUrl(input: string): HostedGitInfo | null;
+//# sourceMappingURL=hostedGitInfo.d.ts.map

package/dist/hostedGitInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostedGitInfo.d.ts","sourceRoot":"","sources":["../src/hostedGitInfo.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,aAAa,EACd,MAAM,YAAY,CAAA;AA6DnB,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAuFrE"}

package/dist/hostedGitInfo.js

@@ -0,0 +1,118 @@
+function getType(domain) {
+    if (domain.includes('github')) {
+        return 'github';
+    }
+    if (domain.includes('gitlab')) {
+        return 'gitlab';
+    }
+    if (domain.includes('bitbucket')) {
+        return 'bitbucket';
+    }
+    if (domain.includes('git.sr.ht')) {
+        return 'sourcehut';
+    }
+    return '';
+}
+function getHost(type) {
+    switch (type) {
+        case 'github':
+            return 'https://github.com';
+        case 'gitlab':
+            return 'https://gitlab.com';
+        case 'bitbucket':
+            return 'https://bitbucket.org';
+        case 'sourcehut':
+            return 'https://git.sr.ht';
+        default:
+            return '';
+    }
+}
+function getRepositoryUrl(type, host, owner, project, branch) {
+    if (!host) {
+        return '';
+    }
+    let treepath = '';
+    if (branch) {
+        if (type === 'bitbucket') {
+            treepath = `/src/${encodeURIComponent(branch)}`;
+        }
+        else {
+            treepath = `/tree/${encodeURIComponent(branch)}`;
+        }
+    }
+    return `${host}/${owner}/${project}${treepath}`;
+}
+export function parseHostedGitUrl(input) {
+    // github edge case with branch in the url
+    let matches = input.match(/^(?:https:\/\/)?github\.com\/([^/]+)\/([^/.#]+)(?:\/tree\/[^/]+)?$/);
+    if (matches) {
+        return {
+            url: input,
+            type: 'github',
+            host: 'https://github.com',
+            owner: matches[1],
+            project: matches[2]
+        };
+    }
+    let type;
+    let host;
+    let owner;
+    let project;
+    // git+ssh and ssh urls
+    matches = input.match(/^(?:(?:git\+)?ssh:\/\/(?:[^@]+@)?|[^@]+@)(?:www\.)?([^@:]+):([^/]+(?:\/[^/]+)?)\/([^/.#]+)(?:\.git)?(?:#(.+))?/);
+    if (matches) {
+        type = getType(matches[1]);
+        host = `https://${matches[1]}`;
+        owner = matches[2];
+        project = matches[3];
+        return {
+            url: getRepositoryUrl(type, host, owner, project, matches[4]),
+            type,
+            host,
+            owner,
+            project
+        };
+    }
+    // git+https and https urls
+    matches = input.match(/^(?:(?:git\+)?https|git):\/\/(?:[^@]+@)?(?:www\.)?([^@/]+)\/([^/]+(?:\/[^/]+)?)\/([^/.#]+)(?:\.git)?(?:#(.+))?/);
+    if (matches) {
+        type = getType(matches[1]);
+        host = `http${type || input.includes('https://') ? 's' : ''}://${matches[1]}`;
+        owner = matches[2];
+        project = matches[3];
+        return {
+            url: getRepositoryUrl(type, host, owner, project, matches[4]),
+            type,
+            host,
+            owner,
+            project
+        };
+    }
+    // shortcuts
+    matches = input.match(/^(?:([^@:]+):)?(?:[^@:]+@|[^@:]*:[^@:]+@)?([^/#]+(?:\/[^/]+)?)\/([^/.#]+)(?:\.git)?(?:#(.+))?/);
+    if (matches) {
+        type = matches[1] || 'github';
+        host = getHost(type);
+        owner = matches[2];
+        project = matches[3];
+        return {
+            url: getRepositoryUrl(type, host, owner, project, matches[4]),
+            type,
+            host,
+            owner,
+            project
+        };
+    }
+    matches = input.match(/^\w+:\/\/([^/]+)(\/[^#]+)?/);
+    if (matches) {
+        type = getType(matches[1]);
+        host = `http${type || input.includes('https://') ? 's' : ''}://${matches[1]}`;
+        return {
+            url: `${host}${matches[2]?.replace(/\/?\.git.*/, '') || ''}`,
+            type,
+            host
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,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