keep-a-changelog 0.10.3 → 2.0.1

package/esm/mod.js

@@ -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/esm/package.json

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

package/esm/src/Change.js

@@ -0,0 +1,48 @@
+export default 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();
+    }
+}

package/esm/src/Changelog.js

@@ -0,0 +1,137 @@
+import { eq } from "./deps.js";
+export default 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 && 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");
+    }
+}
+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/esm/src/Release.js

@@ -0,0 +1,204 @@
+import { Semver } from "./deps.js";
+import Change from "./Change.js";
+export default 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 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)) {
+            change = new Change(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;
+    }
+}
+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/esm/src/deps.js

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

package/esm/src/parser.js

@@ -0,0 +1,159 @@
+import Changelog from "./Changelog.js";
+import Release from "./Release.js";
+const defaultOptions = {
+    releaseCreator: (version, date, description) => new Release(version, date, description),
+};
+/** Parse a markdown string */
+export default 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}`);
+    }
+}
+/** Process an array of tokens to build the Changelog */
+function processTokens(tokens, opts) {
+    const changelog = new Changelog("");
+    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/esm/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