keep-a-changelog 0.10.3 → 2.0.1

package/umd/mod.js

@@ -0,0 +1,24 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(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", "./src/parser.js", "./src/Change.js", "./src/Changelog.js", "./src/Release.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Release = exports.parser = exports.Changelog = exports.Change = void 0;
+    const parser_js_1 = __importDefault(require("./src/parser.js"));
+    exports.parser = parser_js_1.default;
+    const Change_js_1 = __importDefault(require("./src/Change.js"));
+    exports.Change = Change_js_1.default;
+    const Changelog_js_1 = __importDefault(require("./src/Changelog.js"));
+    exports.Changelog = Changelog_js_1.default;
+    const Release_js_1 = __importDefault(require("./src/Release.js"));
+    exports.Release = Release_js_1.default;
+});

package/umd/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/umd/src/Change.js

@@ -0,0 +1,61 @@
+(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) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    class Change {
+        constructor(title, description = "") {
+            Object.defineProperty(this, "title", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "description", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "issues", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: []
+            });
+            this.title = Change.extractIssues(title, this.issues);
+            this.description = Change.extractIssues(description, this.issues);
+        }
+        static extractIssues(text, issues) {
+            return text
+                .replace(/(^|[^\\])\[#(\d+)\](?=[^\(]|$)/g, (_, start, index) => {
+                if (!issues.includes(index)) {
+                    issues.push(index);
+                }
+                return `${start}[#${index}]`;
+            })
+                .replace(/(^|[\s,])#(\d+)(?=[\s,\.]|$)/g, (_, start, index) => {
+                if (!issues.includes(index)) {
+                    issues.push(index);
+                }
+                return `${start}[#${index}]`;
+            });
+        }
+        toString() {
+            let t = this.title.split("\n").map((line) => `  ${line}`.trimEnd());
+            t[0] = "-" + t[0].substr(1);
+            if (this.description) {
+                t.push("");
+                t = t.concat(this.description.split("\n").map((line) => `  ${line}`.trimEnd()));
+            }
+            return t.join("\n").trim();
+        }
+    }
+    exports.default = Change;
+});

package/umd/src/Changelog.js

@@ -0,0 +1,150 @@
+(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", "./deps.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const deps_js_1 = require("./deps.js");
+    class Changelog {
+        constructor(title, description = "") {
+            Object.defineProperty(this, "flag", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "title", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "description", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "head", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: "HEAD"
+            });
+            Object.defineProperty(this, "footer", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "url", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "releases", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: []
+            });
+            Object.defineProperty(this, "tagNameBuilder", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            this.title = title;
+            this.description = description;
+        }
+        addRelease(release) {
+            this.releases.push(release);
+            this.sortReleases();
+            release.changelog = this;
+            return this;
+        }
+        findRelease(version) {
+            if (!version) {
+                return this.releases.find((release) => !release.version);
+            }
+            return this.releases.find((release) => release.version && (0, deps_js_1.eq)(release.version, version));
+        }
+        sortReleases() {
+            this.releases.sort((a, b) => a.compare(b));
+        }
+        tagName(release) {
+            if (this.tagNameBuilder) {
+                return this.tagNameBuilder(release);
+            }
+            return `v${release.version}`;
+        }
+        toString() {
+            const t = [];
+            if (this.flag) {
+                t.push(`<!-- ${this.flag} -->`);
+                t.push("");
+            }
+            t.push(`# ${this.title}`);
+            const links = [];
+            const compareLinks = [];
+            const description = this.description.trim() ||
+                `All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).`;
+            if (description) {
+                t.push("");
+                t.push(description);
+            }
+            this.releases.forEach((release) => {
+                t.push("");
+                t.push(release.toString(this));
+                release.getLinks(this).forEach((link) => {
+                    if (!links.includes(link)) {
+                        links.push(link);
+                    }
+                });
+                const compareLink = release.getCompareLink(this);
+                if (compareLink) {
+                    compareLinks.push(compareLink);
+                }
+            });
+            if (links.length) {
+                t.push("");
+                links.sort(compare);
+                links.forEach((link) => t.push(link));
+            }
+            if (compareLinks.length) {
+                t.push("");
+                compareLinks.forEach((link) => t.push(link));
+            }
+            t.push("");
+            if (this.footer) {
+                t.push("---");
+                t.push("");
+                t.push(this.footer);
+                t.push("");
+            }
+            return t.join("\n");
+        }
+    }
+    exports.default = Changelog;
+    function compare(a, b) {
+        if (a === b) {
+            return 0;
+        }
+        const reg = /^\[#(\d+)\]:/;
+        const aNumber = a.match(reg);
+        const bNumber = b.match(reg);
+        if (aNumber && bNumber) {
+            return parseInt(aNumber[1]) - parseInt(bNumber[1]);
+        }
+        return a < b ? -1 : 1;
+    }
+});

package/umd/src/Release.js

@@ -0,0 +1,220 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(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", "./deps.js", "./Change.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const deps_js_1 = require("./deps.js");
+    const Change_js_1 = __importDefault(require("./Change.js"));
+    class Release {
+        constructor(version, date, description = "") {
+            Object.defineProperty(this, "changelog", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "version", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "date", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "description", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            Object.defineProperty(this, "changes", {
+                enumerable: true,
+                configurable: true,
+                writable: true,
+                value: void 0
+            });
+            this.setVersion(version);
+            this.setDate(date);
+            this.description = description;
+            this.changes = new Map([
+                ["added", []],
+                ["changed", []],
+                ["deprecated", []],
+                ["removed", []],
+                ["fixed", []],
+                ["security", []],
+            ]);
+        }
+        compare(release) {
+            if (!this.version && release.version) {
+                return -1;
+            }
+            if (!release.version) {
+                return 1;
+            }
+            if (!this.date && release.date) {
+                return -1;
+            }
+            if (!release.date) {
+                return 1;
+            }
+            if (this.version && release.version) {
+                return -this.version.compare(release.version);
+            }
+            return 0;
+        }
+        isEmpty() {
+            if (this.description.trim()) {
+                return false;
+            }
+            return Array.from(this.changes.values()).every((change) => !change.length);
+        }
+        setVersion(version) {
+            if (typeof version === "string") {
+                version = new deps_js_1.Semver(version);
+            }
+            this.version = version;
+            //Re-sort the releases of the parent changelog
+            if (this.changelog) {
+                this.changelog.sortReleases();
+            }
+        }
+        setDate(date) {
+            if (typeof date === "string") {
+                date = new Date(date);
+            }
+            this.date = date;
+        }
+        addChange(type, change) {
+            if (!(change instanceof Change_js_1.default)) {
+                change = new Change_js_1.default(change);
+            }
+            if (!this.changes.has(type)) {
+                throw new Error("Invalid change type");
+            }
+            this.changes.get(type).push(change);
+            return this;
+        }
+        added(change) {
+            return this.addChange("added", change);
+        }
+        changed(change) {
+            return this.addChange("changed", change);
+        }
+        deprecated(change) {
+            return this.addChange("deprecated", change);
+        }
+        removed(change) {
+            return this.addChange("removed", change);
+        }
+        fixed(change) {
+            return this.addChange("fixed", change);
+        }
+        security(change) {
+            return this.addChange("security", change);
+        }
+        toString(changelog) {
+            let t = [];
+            const hasCompareLink = this.getCompareLink(changelog) !== undefined;
+            if (this.version) {
+                if (hasCompareLink) {
+                    t.push(`## [${this.version}] - ${formatDate(this.date)}`);
+                }
+                else {
+                    t.push(`## ${this.version} - ${formatDate(this.date)}`);
+                }
+            }
+            else {
+                if (hasCompareLink) {
+                    t.push("## [Unreleased]");
+                }
+                else {
+                    t.push("## Unreleased");
+                }
+            }
+            if (this.description.trim()) {
+                t.push(this.description.trim());
+                t.push("");
+            }
+            this.changes.forEach((changes, type) => {
+                if (changes.length) {
+                    t.push(`### ${type[0].toUpperCase()}${type.substring(1)}`);
+                    t = t.concat(changes.map((change) => change.toString()));
+                    t.push("");
+                }
+            });
+            return t.join("\n").trim();
+        }
+        getCompareLink(changelog) {
+            if (!changelog?.url) {
+                return;
+            }
+            const index = changelog.releases.indexOf(this);
+            if (index === -1) {
+                return;
+            }
+            let offset = 1;
+            let previous = changelog.releases[index + offset];
+            while (previous && !previous.date) {
+                ++offset;
+                previous = changelog.releases[index + offset];
+            }
+            if (!previous) {
+                if (!this.version || !this.date) {
+                    return;
+                }
+                return `[${this.version}]: ${changelog.url}/releases/tag/${changelog.tagName(this)}`;
+            }
+            if (!this.version) {
+                return `[Unreleased]: ${changelog.url}/compare/${changelog.tagName(previous)}...${changelog.head}`;
+            }
+            if (!this.date) {
+                return `[${this.version}]: ${changelog.url}/compare/${changelog.tagName(previous)}...${changelog.head}`;
+            }
+            return `[${this.version}]: ${changelog.url}/compare/${changelog.tagName(previous)}...${changelog.tagName(this)}`;
+        }
+        getLinks(changelog) {
+            const links = [];
+            if (!changelog.url) {
+                return links;
+            }
+            this.changes.forEach((changes) => changes.forEach((change) => {
+                change.issues.forEach((issue) => {
+                    if (!links.includes(issue)) {
+                        links.push(`[#${issue}]: ${changelog.url}/issues/${issue}`);
+                    }
+                });
+            }));
+            return links;
+        }
+    }
+    exports.default = Release;
+    function formatDate(date) {
+        if (!date) {
+            return "Unreleased";
+        }
+        const year = date.getUTCFullYear();
+        let month = date.getUTCMonth() + 1;
+        let day = date.getUTCDate();
+        if (month < 10) {
+            month = "0" + month;
+        }
+        if (day < 10) {
+            day = "0" + day;
+        }
+        return `${year}-${month}-${day}`;
+    }
+});

package/umd/src/deps.js

@@ -0,0 +1,19 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(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", "../deps/deno_land/x/semver_v1.4.0/mod.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.eq = exports.Semver = void 0;
+    var mod_js_1 = require("../deps/deno_land/x/semver_v1.4.0/mod.js");
+    Object.defineProperty(exports, "Semver", { enumerable: true, get: function () { return __importDefault(mod_js_1).default; } });
+    Object.defineProperty(exports, "eq", { enumerable: true, get: function () { return mod_js_1.eq; } });
+});

package/umd/src/parser.js

@@ -0,0 +1,175 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(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", "./Changelog.js", "./Release.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const Changelog_js_1 = __importDefault(require("./Changelog.js"));
+    const Release_js_1 = __importDefault(require("./Release.js"));
+    const defaultOptions = {
+        releaseCreator: (version, date, description) => new Release_js_1.default(version, date, description),
+    };
+    /** Parse a markdown string */
+    function parser(markdown, options) {
+        const opts = Object.assign({}, defaultOptions, options);
+        const tokens = tokenize(markdown);
+        try {
+            return processTokens(tokens, opts);
+        }
+        catch (error) {
+            throw new Error(`Parse error in the line ${tokens[0][0]}: ${error.message}`);
+        }
+    }
+    exports.default = parser;
+    /** Process an array of tokens to build the Changelog */
+    function processTokens(tokens, opts) {
+        const changelog = new Changelog_js_1.default("");
+        changelog.flag = getContent(tokens, "flag");
+        changelog.title = getContent(tokens, "h1", true);
+        changelog.description = getContent(tokens, "p");
+        //Releases
+        let release;
+        while ((release = getContent(tokens, "h2").toLowerCase())) {
+            const matches = release.match(/\[?([^\]]+)\]?\s*-\s*([\d]{4}-[\d]{1,2}-[\d]{1,2})$/);
+            if (matches) {
+                release = opts.releaseCreator(matches[1], matches[2]);
+            }
+            else if (release.includes("unreleased")) {
+                const matches = release.match(/\[?([^\]]+)\]?\s*-\s*unreleased$/);
+                release = matches
+                    ? opts.releaseCreator(matches[1])
+                    : opts.releaseCreator();
+            }
+            else {
+                throw new Error(`Syntax error in the release title`);
+            }
+            changelog.addRelease(release);
+            release.description = getContent(tokens, "p");
+            let type;
+            while ((type = getContent(tokens, "h3").toLowerCase())) {
+                let change;
+                while ((change = getContent(tokens, "li"))) {
+                    release.addChange(type, change);
+                }
+            }
+        }
+        //Skip release links
+        let link = getContent(tokens, "link");
+        while (link) {
+            if (!changelog.url) {
+                const matches = link.match(/^\[.*\]\:\s*(http.*)\/compare\/.*$/);
+                if (matches) {
+                    changelog.url = matches[1];
+                }
+            }
+            link = getContent(tokens, "link");
+        }
+        //Footer
+        if (getContent(tokens, "hr")) {
+            changelog.footer = getContent(tokens, "p");
+        }
+        if (tokens.length) {
+            throw new Error(`Unexpected content ${JSON.stringify(tokens)}`);
+        }
+        return changelog;
+    }
+    /** Returns the content of a token */
+    function getContent(tokens, type, required = false) {
+        if (!tokens[0] || tokens[0][1] !== type) {
+            if (required) {
+                throw new Error(`Required token missing in: "${tokens[0][0]}"`);
+            }
+            return "";
+        }
+        return tokens.shift()[2].join("\n");
+    }
+    /** Tokenize a markdown string */
+    function tokenize(markdown) {
+        const tokens = [];
+        markdown
+            .trim()
+            .split("\n")
+            .map((line, index, allLines) => {
+            const lineNumber = index + 1;
+            if (line.startsWith("---")) {
+                return [lineNumber, "hr", ["-"]];
+            }
+            if (line.startsWith("# ")) {
+                return [lineNumber, "h1", [line.substr(1).trim()]];
+            }
+            if (line.startsWith("## ")) {
+                return [lineNumber, "h2", [line.substr(2).trim()]];
+            }
+            if (line.startsWith("### ")) {
+                return [lineNumber, "h3", [line.substr(3).trim()]];
+            }
+            if (line.startsWith("-")) {
+                return [lineNumber, "li", [line.substr(1).trim()]];
+            }
+            if (line.startsWith("*")) {
+                return [lineNumber, "li", [line.substr(1).trim()]];
+            }
+            if (line.match(/^\[.*\]\:\s*http.*$/)) {
+                return [lineNumber, "link", [line.trim()]];
+            }
+            if (line.match(/^\[.*\]\:$/)) {
+                const nextLine = allLines[index + 1];
+                if (nextLine && nextLine.match(/\s+http.*$/)) {
+                    // We found a multi-line link: treat it like a single line
+                    allLines[index + 1] = "";
+                    return [lineNumber, "link", [
+                            line.trim() + "\n" + nextLine.trimEnd(),
+                        ]];
+                }
+            }
+            const result = line.match(/^<!--(.*)-->$/);
+            if (result) {
+                return [lineNumber, "flag", [result[1].trim()]];
+            }
+            return [lineNumber, "p", [line.trimEnd()]];
+        })
+            .forEach((line, index) => {
+            const [lineNumber, type, [content]] = line;
+            if (index > 0) {
+                const prevType = tokens[0][1];
+                if (type === "p") {
+                    if (prevType === "p") {
+                        return tokens[0][2].push(content);
+                    }
+                    if (prevType === "li") {
+                        return tokens[0][2].push(content.replace(/^\s\s/, ""));
+                    }
+                }
+            }
+            tokens.unshift([lineNumber, type, [content]]);
+        });
+        return tokens
+            .filter((token) => !isEmpty(token[2]))
+            .map((token) => {
+            const content = token[2];
+            while (isEmpty(content[content.length - 1])) {
+                content.pop();
+            }
+            while (isEmpty(content[0])) {
+                content.shift();
+            }
+            return token;
+        })
+            .reverse();
+    }
+    /** Check if a string or array is empty */
+    function isEmpty(val) {
+        if (Array.isArray(val)) {
+            val = val.join("");
+        }
+        return !val || val.trim() === "";
+    }
+});

package/umd/test/changelog.custom.type.md

@@ -0,0 +1,24 @@
+# Changelog - demo
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to
+[Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+### Maintenance
+- upgrade
+- fix vulnerabilities
+
+## [2.0.0] - 2020-02-07
+### Added
+- custom release
+
+## [1.0.0] - 2020-02-06
+### Maintenance
+- fix naming
+
+[Unreleased]: https://github.com/olivierlacan/keep-a-changelog/compare/v2.0.0...HEAD
+[2.0.0]: https://github.com/olivierlacan/keep-a-changelog/compare/v1.0.0...v2.0.0
+[1.0.0]: https://github.com/olivierlacan/keep-a-changelog/releases/tag/v1.0.0