keep-a-changelog 0.10.2 → 2.0.0

package/types/deps/deno_land/x/semver_v1.4.0/mod.d.ts

@@ -0,0 +1,116 @@
+export declare type ReleaseType = "pre" | "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease";
+export declare type Operator = "===" | "!==" | "" | "=" | "==" | "!=" | ">" | ">=" | "<" | "<=";
+export interface Options {
+    loose?: boolean;
+    includePrerelease?: boolean;
+}
+export declare const SEMVER_SPEC_VERSION = "2.0.0";
+export declare function parse(version: string | SemVer | null, optionsOrLoose?: boolean | Options): SemVer | null;
+export declare function valid(version: string | SemVer | null, optionsOrLoose?: boolean | Options): string | null;
+export declare function clean(version: string, optionsOrLoose?: boolean | Options): string | null;
+export declare class SemVer {
+    raw: string;
+    loose: boolean;
+    options: Options;
+    major: number;
+    minor: number;
+    patch: number;
+    version: string;
+    build: ReadonlyArray<string>;
+    prerelease: Array<string | number>;
+    constructor(version: string | SemVer, optionsOrLoose?: boolean | Options);
+    format(): string;
+    compare(other: string | SemVer): 1 | 0 | -1;
+    compareMain(other: string | SemVer): 1 | 0 | -1;
+    comparePre(other: string | SemVer): 1 | 0 | -1;
+    compareBuild(other: string | SemVer): 1 | 0 | -1;
+    inc(release: ReleaseType, identifier?: string): SemVer;
+    toString(): string;
+}
+/**
+ * Return the version incremented by the release type (major, minor, patch, or prerelease), or null if it's not valid.
+ */
+export declare function inc(version: string | SemVer, release: ReleaseType, optionsOrLoose?: boolean | Options, identifier?: string): string | null;
+export declare function diff(version1: string | SemVer, version2: string | SemVer, optionsOrLoose?: boolean | Options): ReleaseType | null;
+export declare function compareIdentifiers(a: string | number | null, b: string | number | null): 1 | 0 | -1;
+export declare function rcompareIdentifiers(a: string | null, b: string | null): 1 | 0 | -1;
+/**
+ * Return the major version number.
+ */
+export declare function major(v: string | SemVer, optionsOrLoose?: boolean | Options): number;
+/**
+ * Return the minor version number.
+ */
+export declare function minor(v: string | SemVer, optionsOrLoose?: boolean | Options): number;
+/**
+ * Return the patch version number.
+ */
+export declare function patch(v: string | SemVer, optionsOrLoose?: boolean | Options): number;
+export declare function compare(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): 1 | 0 | -1;
+export declare function compareLoose(a: string | SemVer, b: string | SemVer): 1 | 0 | -1;
+export declare function compareBuild(a: string | SemVer, b: string | SemVer, loose?: boolean | Options): 1 | 0 | -1;
+export declare function rcompare(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): 1 | 0 | -1;
+export declare function sort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | Options): T[];
+export declare function rsort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | Options): T[];
+export declare function gt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function lt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function eq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function neq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function gte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function lte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare function cmp(v1: string | SemVer, operator: Operator, v2: string | SemVer, optionsOrLoose?: boolean | Options): boolean;
+export declare class Comparator {
+    semver: SemVer;
+    operator: "" | "=" | "<" | ">" | "<=" | ">=";
+    value: string;
+    loose: boolean;
+    options: Options;
+    constructor(comp: string | Comparator, optionsOrLoose?: boolean | Options);
+    parse(comp: string): void;
+    test(version: string | SemVer): boolean;
+    intersects(comp: Comparator, optionsOrLoose?: boolean | Options): boolean;
+    toString(): string;
+}
+export declare class Range {
+    range: string;
+    raw: string;
+    loose: boolean;
+    options: Options;
+    includePrerelease: boolean;
+    set: ReadonlyArray<ReadonlyArray<Comparator>>;
+    constructor(range: string | Range | Comparator, optionsOrLoose?: boolean | Options);
+    format(): string;
+    parseRange(range: string): ReadonlyArray<Comparator>;
+    test(version: string | SemVer): boolean;
+    intersects(range?: Range, optionsOrLoose?: boolean | Options): boolean;
+    toString(): string;
+}
+export declare function toComparators(range: string | Range, optionsOrLoose?: boolean | Options): string[][];
+export declare function satisfies(version: string | SemVer, range: string | Range, optionsOrLoose?: boolean | Options): boolean;
+export declare function maxSatisfying<T extends string | SemVer>(versions: ReadonlyArray<T>, range: string | Range, optionsOrLoose?: boolean | Options): T | null;
+export declare function minSatisfying<T extends string | SemVer>(versions: ReadonlyArray<T>, range: string | Range, optionsOrLoose?: boolean | Options): T | null;
+export declare function minVersion(range: string | Range, optionsOrLoose?: boolean | Options): SemVer | null;
+export declare function validRange(range: string | Range | null, optionsOrLoose?: boolean | Options): string | null;
+/**
+ * Return true if version is less than all the versions possible in the range.
+ */
+export declare function ltr(version: string | SemVer, range: string | Range, optionsOrLoose?: boolean | Options): boolean;
+/**
+ * Return true if version is greater than all the versions possible in the range.
+ */
+export declare function gtr(version: string | SemVer, range: string | Range, optionsOrLoose?: boolean | Options): boolean;
+/**
+ * Return true if the version is outside the bounds of the range in either the high or low direction.
+ * The hilo argument must be either the string '>' or '<'. (This is the function called by gtr and ltr.)
+ */
+export declare function outside(version: string | SemVer, range: string | Range, hilo: ">" | "<", optionsOrLoose?: boolean | Options): boolean;
+export declare function prerelease(version: string | SemVer, optionsOrLoose?: boolean | Options): ReadonlyArray<string | number> | null;
+/**
+ * Return true if any of the ranges comparators intersect
+ */
+export declare function intersects(range1: string | Range | Comparator, range2: string | Range | Comparator, optionsOrLoose?: boolean | Options): boolean;
+/**
+ * Coerces a string to semver if possible
+ */
+export declare function coerce(version: string | SemVer, optionsOrLoose?: boolean | Options): SemVer | null;
+export default SemVer;

package/types/mod.d.ts

@@ -0,0 +1,5 @@
+import parser from "./src/parser.js";
+import Change from "./src/Change.js";
+import Changelog from "./src/Changelog.js";
+import Release from "./src/Release.js";
+export { Change, Changelog, parser, Release };

package/types/src/Change.d.ts

@@ -0,0 +1,8 @@
+export default class Change {
+    title: string;
+    description: string;
+    issues: string[];
+    static extractIssues(text: string, issues: string[]): string;
+    constructor(title: string, description?: string);
+    toString(): string;
+}

package/types/src/Changelog.d.ts

@@ -0,0 +1,18 @@
+import Release from "./Release.js";
+import { Semver } from "./deps.js";
+export default class Changelog {
+    flag?: string;
+    title: string;
+    description: string;
+    head: string;
+    footer?: string;
+    url?: string;
+    releases: Release[];
+    tagNameBuilder?: (release: Release) => string;
+    constructor(title: string, description?: string);
+    addRelease(release: Release): this;
+    findRelease(version?: Semver | string): Release | undefined;
+    sortReleases(): void;
+    tagName(release: Release): string;
+    toString(): string;
+}

package/types/src/Release.d.ts

@@ -0,0 +1,25 @@
+import { Semver } from "./deps.js";
+import Change from "./Change.js";
+import Changelog from "./Changelog.js";
+export default class Release {
+    changelog?: Changelog;
+    version?: Semver;
+    date?: Date;
+    description: string;
+    changes: Map<string, Change[]>;
+    constructor(version?: string | Semver, date?: string | Date, description?: string);
+    compare(release: Release): number;
+    isEmpty(): boolean;
+    setVersion(version?: string | Semver): void;
+    setDate(date?: Date | string): void;
+    addChange(type: string, change: Change | string): this;
+    added(change: Change | string): this;
+    changed(change: Change | string): this;
+    deprecated(change: Change | string): this;
+    removed(change: Change | string): this;
+    fixed(change: Change | string): this;
+    security(change: Change | string): this;
+    toString(changelog?: Changelog): string;
+    getCompareLink(changelog?: Changelog): string | undefined;
+    getLinks(changelog: Changelog): string[];
+}

package/types/src/deps.d.ts

@@ -0,0 +1 @@
+export { default as Semver, eq, } from "../deps/deno_land/x/semver_v1.4.0/mod.js";

package/types/src/parser.d.ts

@@ -0,0 +1,11 @@
+import Changelog from "./Changelog.js";
+import Release from "./Release.js";
+export interface Options {
+    /**
+     * Custom function to create Release instances.
+     * Needed if you want to use a custom Release class.
+     */
+    releaseCreator: (version?: string, date?: string, description?: string) => Release;
+}
+/** Parse a markdown string */
+export default function parser(markdown: string, options?: Options): Changelog;

package/types/test/Change.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/test/fixture/CustomRelease.d.ts

@@ -0,0 +1,8 @@
+import { Release, Change } from "../../mod.js";
+import { Semver } from "../../src/deps.js";
+declare class CustomRelease extends Release {
+    constructor(version?: Semver | string, date?: Date | string, description?: string);
+    maintenance(change: string | Change): this;
+}
+export default function (version?: Semver | string, date?: Date | string, description?: string): CustomRelease;
+export {};

package/types/test/parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/test/test.d.ts

@@ -0,0 +1 @@
+export {};

package/umd/bin.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "deno.ns", "./deps/deno_land/std_0.113.0/path/mod.js", "./mod.js", "./deps/deno_land/std_0.113.0/flags/mod.js", "./deps/deno_land/x/ini_v2.1.0/mod.js"], factory);
+    }
+})(function (require, exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const denoShim = __importStar(require("deno.ns"));
+    const mod_js_1 = require("./deps/deno_land/std_0.113.0/path/mod.js");
+    const mod_js_2 = require("./mod.js");
+    const mod_js_3 = require("./deps/deno_land/std_0.113.0/flags/mod.js");
+    const mod_js_4 = require("./deps/deno_land/x/ini_v2.1.0/mod.js");
+    const argv = (0, mod_js_3.parse)(denoShim.Deno.args, {
+        default: {
+            file: "CHANGELOG.md",
+            url: null,
+            https: true,
+            quiet: false,
+        },
+        boolean: ["https", "init", "latest-release", "quiet"],
+    });
+    const file = (0, mod_js_1.join)(denoShim.Deno.cwd(), argv.file);
+    try {
+        if (argv.init) {
+            const changelog = new mod_js_2.Changelog("Changelog").addRelease(new mod_js_2.Release("0.1.0", new Date(), "First version"));
+            save(file, changelog, true);
+            denoShim.Deno.exit(0);
+        }
+        const changelog = (0, mod_js_2.parser)(denoShim.Deno.readTextFileSync(file));
+        if (argv.latestRelease) {
+            const release = changelog.releases.find((release) => release.date && release.version);
+            if (release) {
+                console.log(release.version?.toString());
+            }
+            denoShim.Deno.exit(0);
+        }
+        if (argv.release) {
+            const release = changelog.releases.find((release) => {
+                if (release.date) {
+                    return false;
+                }
+                if (typeof argv.release === "string") {
+                    return !release.version || argv.release === release.version.toString();
+                }
+                return !!release.version;
+            });
+            if (release) {
+                release.date = new Date();
+                if (typeof argv.release === "string") {
+                    release.setVersion(argv.release);
+                }
+            }
+            else {
+                console.error("Not found any valid unreleased version");
+                denoShim.Deno.exit(1);
+            }
+        }
+        if (!changelog.url) {
+            if (argv.url) {
+                changelog.url = argv.url;
+            }
+            else {
+                const url = getRemoteUrl(argv.https);
+                if (url) {
+                    changelog.url = url;
+                }
+                else {
+                    console.error(red('Please, set the repository url with --url="https://github.com/username/repository"'));
+                    denoShim.Deno.exit(1);
+                }
+            }
+        }
+        save(file, changelog);
+    }
+    catch (err) {
+        console.error(red(err.message));
+        if (!argv.quiet) {
+            denoShim.Deno.exit(1);
+        }
+    }
+    function save(file, changelog, isNew = false) {
+        const url = changelog.url;
+        if (url && url.includes("gitlab.com")) {
+            changelog.head = "master";
+        }
+        denoShim.Deno.writeTextFileSync(file, changelog.toString());
+        if (isNew) {
+            console.log(green("Generated new file"), file);
+        }
+        else {
+            console.log(green("Updated file"), file);
+        }
+    }
+    function red(message) {
+        return "\u001b[" + 31 + "m" + message + "\u001b[" + 39 + "m";
+    }
+    function green(message) {
+        return "\u001b[" + 32 + "m" + message + "\u001b[" + 39 + "m";
+    }
+    function getRemoteUrl(https = true) {
+        try {
+            const file = (0, mod_js_1.join)(denoShim.Deno.cwd(), ".git", "config");
+            const content = denoShim.Deno.readTextFileSync(file);
+            const data = (0, mod_js_4.parse)(content);
+            const url = data?.['remote "origin"']?.url;
+            if (!url) {
+                return;
+            }
+            const remoteUrl = new URL(url.replace(/^git@([^:]+):(.*)\.git$/, "https://$1/$2"));
+            if (https) {
+                remoteUrl.protocol = "https:";
+            }
+            return remoteUrl.href;
+        }
+        catch (err) {
+            console.error(red(err.message));
+            // Ignore
+        }
+    }
+});

package/umd/deps/deno_land/std_0.113.0/_util/assert.js

@@ -0,0 +1,27 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.assert = exports.DenoStdInternalError = void 0;
+    class DenoStdInternalError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = "DenoStdInternalError";
+        }
+    }
+    exports.DenoStdInternalError = DenoStdInternalError;
+    /** Make an assertion, if not `true`, then throw. */
+    function assert(expr, msg = "") {
+        if (!expr) {
+            throw new DenoStdInternalError(msg);
+        }
+    }
+    exports.assert = assert;
+});

package/umd/deps/deno_land/std_0.113.0/_util/os.js

@@ -0,0 +1,46 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "deno.ns"], factory);
+    }
+})(function (require, exports) {
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isWindows = exports.osType = void 0;
+    const denoShim = __importStar(require("deno.ns"));
+    exports.osType = (() => {
+        // deno-lint-ignore no-explicit-any
+        const { Deno } = ({ ...denoShim, ...globalThis });
+        if (typeof Deno?.build?.os === "string") {
+            return Deno.build.os;
+        }
+        // deno-lint-ignore no-explicit-any
+        const { navigator } = ({ ...denoShim, ...globalThis });
+        if (navigator?.appVersion?.includes?.("Win") ?? false) {
+            return "windows";
+        }
+        return "linux";
+    })();
+    exports.isWindows = exports.osType === "windows";
+});