keep-a-changelog 2.0.1 → 2.1.0

package/script/mod.js

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

@@ -0,0 +1,51 @@
+"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/script/src/Changelog.js

@@ -0,0 +1,140 @@
+"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/script/src/Release.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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, "yanked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        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;
+        const yanked = this.yanked ? " [YANKED]" : "";
+        if (this.version) {
+            if (hasCompareLink) {
+                t.push(`## [${this.version}] - ${formatDate(this.date)}${yanked}`);
+            }
+            else {
+                t.push(`## ${this.version} - ${formatDate(this.date)}${yanked}`);
+            }
+        }
+        else {
+            if (hasCompareLink) {
+                t.push(`## [Unreleased]${yanked}`);
+            }
+            else {
+                t.push(`## Unreleased${yanked}`);
+            }
+        }
+        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/script/src/deps.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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/script/src/parser.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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})(\s+\[yanked\])?$/);
+        if (matches) {
+            release = opts.releaseCreator(matches[1], matches[2]);
+            release.yanked = !!matches[3];
+        }
+        else if (release.includes("unreleased")) {
+            const matches = release.match(/\[?([^\]]+)\]?\s*-\s*unreleased(\s+\[yanked\])?$/);
+            const yanked = release.includes("[yanked]");
+            release = matches
+                ? opts.releaseCreator(matches[1])
+                : opts.releaseCreator();
+            release.yanked = yanked;
+        }
+        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 → script}/test/changelog.expected.md

@@ -6,11 +6,11 @@ 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]
+## [Unreleased] [YANKED]
 ### Added
 - Test
 
-## [2.0.0] - Unreleased
+## [2.0.0] - Unreleased [YANKED]
 ### Added
 - None
 - Test with issue link [#1]
@@ -100,7 +100,7 @@ and this project adheres to
 ### Fixed
 - Fix Markdown links to tag comparison URL with footnote-style links.
 
-## [0.0.6] - 2014-12-12
+## [0.0.6] - 2014-12-12 [YANKED]
 ### Added
 - README section on "yanked" releases.
 

package/{umd → script}/test/changelog.md

@@ -6,13 +6,13 @@ 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]
+## [Unreleased] [Yanked]
 
 ### Added
 
 - Test
 
-## [2.0.0] - unreleased
+## [2.0.0] - unreleased [Yanked]
 
 ### Added
 
@@ -122,7 +122,7 @@ and this project adheres to
 
 - Fix Markdown links to tag comparison URL with footnote-style links.
 
-## [0.0.6] - 2014-12-12
+## [0.0.6] - 2014-12-12 [YANKED]
 
 ### Added
 

package/types/_dnt.polyfills.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};

package/types/_dnt.shims.d.ts

@@ -1,9 +1,5 @@
 import { Deno } from "@deno/shim-deno";
 export { Deno } from "@deno/shim-deno";
-declare const dntGlobals: {
-    Deno: typeof Deno;
-};
 export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
     Deno: typeof Deno;
 };
-export declare type dntGlobalThisType = Omit<typeof dntGlobals, keyof typeof dntGlobals> & typeof dntGlobals & {};

package/types/bin.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import "./_dnt.polyfills.js";