keep-a-changelog 2.1.0 → 2.3.0

package/CHANGELOG.md

@@ -1,12 +1,30 @@
 <!-- deno-fmt-ignore-file -->
 
 # Changelog
-
 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/).
 
+## [2.3.0] - 2023-05-25
+### Added
+- New option `--create`, to create unreleased versions [#31].
+
+### Fixed
+- Allow empty values for `--release` option
+
+## [2.2.1] - 2023-01-25
+### Fixed
+- Allow list elements in the descriptions of releases and changelogs [#30].
+
+## [2.2.0] - 2023-01-18
+### Added
+- New option `format` to configure the output option [#28].
+- `Release.setYanked` function [#26].
+
+### Fixed
+- Removed unnecessary new line after the title [#27].
+
 ## [2.1.0] - 2022-04-03
 ### Added
 - Support for `[YANKED]` releases [#25]
@@ -29,7 +47,15 @@ New version merging Deno and Node code using Deno's `dnt` package.
 [#21]: https://github.com/oscarotero/keep-a-changelog/issues/21
 [#23]: https://github.com/oscarotero/keep-a-changelog/issues/23
 [#25]: https://github.com/oscarotero/keep-a-changelog/issues/25
-
+[#26]: https://github.com/oscarotero/keep-a-changelog/issues/26
+[#27]: https://github.com/oscarotero/keep-a-changelog/issues/27
+[#28]: https://github.com/oscarotero/keep-a-changelog/issues/28
+[#30]: https://github.com/oscarotero/keep-a-changelog/issues/30
+[#31]: https://github.com/oscarotero/keep-a-changelog/issues/31
+
+[2.3.0]: https://github.com/oscarotero/keep-a-changelog/compare/v2.2.1...v2.3.0
+[2.2.1]: https://github.com/oscarotero/keep-a-changelog/compare/v2.2.0...v2.2.1
+[2.2.0]: https://github.com/oscarotero/keep-a-changelog/compare/v2.1.0...v2.2.0
 [2.1.0]: https://github.com/oscarotero/keep-a-changelog/compare/v2.0.1...v2.1.0
 [2.0.1]: https://github.com/oscarotero/keep-a-changelog/compare/v2.0.0...v2.0.1
 [2.0.0]: https://github.com/oscarotero/keep-a-changelog/releases/tag/v2.0.0

package/README.md

@@ -22,7 +22,7 @@ console.log(changelog.toString());
 ## Usage in Deno
 
 ```js
-import { parser } from "https://deno.land/x/changelog@v2.0.0/mod.ts";
+import { parser } from "https://deno.land/x/changelog@v2.2.1/mod.ts";
 
 //Parse a changelog file
 const changelog = parser(await Deno.readTextFile("CHANGELOG.md"));
@@ -37,7 +37,7 @@ console.log(changelog.toString());
 import {
   Changelog,
   Release,
-} from "https://deno.land/x/changelog@v2.0.0/mod.ts";
+} from "https://deno.land/x/changelog@v2.2.1/mod.ts";
 
 const changelog = new Changelog("My project")
   .addRelease(
@@ -56,6 +56,17 @@ const changelog = new Changelog("My project")
 console.log(changelog.toString());
 ```
 
+### Custom output format
+
+By default, the output format of the markdown is "compact", that removes the
+space after the headings. You can change it to follow the
+[`markdownlint`](https://github.com/DavidAnson/markdownlint) rules:
+
+```js
+const changelog = new Changelog();
+changelog.format = "markdownlint";
+```
+
 ### Custom tag names
 
 By default, the tag names are `v` + version number. For example, the tag for the
@@ -73,10 +84,10 @@ By default and according to the
 [keepachangelog](http://keepachangelog.com/en/1.0.0/) format, the change types
 are `Added`, `Changed`, `Deprecated`, `Removed`, `Fixed`, and `Security`.
 
-In case you'd like add another type in order to use is in your changelog, you
-basically need to extend the `Release` class to support new types. Additionally,
-you have to tell the `parser` that it should create instances of your new
-extended `Release` in order to parse your changelog correctly.
+In case you'd like add another type, you need to extend the `Release` class to
+support new types. Additionally, you have to tell the `parser` that it should
+create instances of your new extended `Release` in order to parse your changelog
+correctly.
 
 For example, we would like to add a type `Maintenance`. Extend the provided
 `Release` class:
@@ -149,6 +160,11 @@ You can release automatically the latest "Unreleased" version:
 changelog --release
 ```
 
+If your "Unreleased" section has no version, you can specify it as an argument:
+```sh
+changelog --release 2.0.0
+```
+
 And return the latest released version:
 
 ```sh
@@ -160,6 +176,7 @@ Available options:
 
 | Option             | Description                                                                                                                                                                                                    |
 | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--format`           | The output format for the generated markdown. It can be `markdownlint` or `compact`. The default value is `compact`.                                                                                                                                       |
 | `--file`           | The markdown file of the changelog. The default value is `CHANGELOG.md`.                                                                                                                                       |
 | `--url`            | The base url used to build the diff urls of the different releases. It is taken from the existing diff urls in the markdown. If no urls are found, try to catch it using the url of the git remote repository. |
 | `--https`          | Set to false to use `http` instead `https` in the url (`--https=false`).                                                                                                                                       |

package/esm/_dnt.test_shims.d.ts

@@ -0,0 +1,5 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};

package/esm/bin.js

@@ -1,28 +1,33 @@
 #!/usr/bin/env node
 import "./_dnt.polyfills.js";
 import * as dntShim from "./_dnt.shims.js";
-import { join } from "./deps/deno.land/std@0.120.0/path/mod.js";
+import { join } from "./deps/deno.land/std@0.189.0/path/mod.js";
 import { Changelog, parser, Release } from "./mod.js";
-import { parse as parseFlag } from "./deps/deno.land/std@0.120.0/flags/mod.js";
+import { parse as parseFlag } from "./deps/deno.land/std@0.189.0/flags/mod.js";
 import { parse as parseIni } from "./deps/deno.land/x/ini@v2.1.0/mod.js";
 const argv = parseFlag(dntShim.Deno.args, {
     default: {
         file: "CHANGELOG.md",
+        format: "compact",
         release: null,
+        create: null,
         url: null,
         https: true,
         quiet: false,
     },
+    string: ["file", "format", "url"],
     boolean: ["https", "init", "latest-release", "quiet"],
 });
 const file = join(dntShim.Deno.cwd(), argv.file);
 try {
     if (argv.init) {
         const changelog = new Changelog("Changelog").addRelease(new Release("0.1.0", new Date(), "First version"));
+        changelog.format = argv.format;
         save(file, changelog, true);
         dntShim.Deno.exit(0);
     }
     const changelog = parser(dntShim.Deno.readTextFileSync(file));
+    changelog.format = argv.format;
     if (argv["latest-release"]) {
         const release = changelog.releases.find((release) => release.date && release.version);
         if (release) {
@@ -51,6 +56,10 @@ try {
             dntShim.Deno.exit(1);
         }
     }
+    if (argv.create) {
+        const version = typeof argv.create === "string" ? argv.create : undefined;
+        changelog.addRelease(new Release(version));
+    }
     if (!changelog.url) {
         if (argv.url) {
             changelog.url = argv.url;

package/esm/deps/deno.land/std@0.133.0/fmt/colors.d.ts

@@ -0,0 +1,270 @@
+/** RGB 8-bits per channel. Each in range `0->255` or `0x00->0xff` */
+interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Set changing text color to enabled or disabled
+ * @param value
+ */
+export declare function setColorEnabled(value: boolean): void;
+/** Get whether text color change is enabled or disabled. */
+export declare function getColorEnabled(): boolean;
+/**
+ * Reset the text modified
+ * @param str text to reset
+ */
+export declare function reset(str: string): string;
+/**
+ * Make the text bold.
+ * @param str text to make bold
+ */
+export declare function bold(str: string): string;
+/**
+ * The text emits only a small amount of light.
+ * @param str text to dim
+ */
+export declare function dim(str: string): string;
+/**
+ * Make the text italic.
+ * @param str text to make italic
+ */
+export declare function italic(str: string): string;
+/**
+ * Make the text underline.
+ * @param str text to underline
+ */
+export declare function underline(str: string): string;
+/**
+ * Invert background color and text color.
+ * @param str text to invert its color
+ */
+export declare function inverse(str: string): string;
+/**
+ * Make the text hidden.
+ * @param str text to hide
+ */
+export declare function hidden(str: string): string;
+/**
+ * Put horizontal line through the center of the text.
+ * @param str text to strike through
+ */
+export declare function strikethrough(str: string): string;
+/**
+ * Set text color to black.
+ * @param str text to make black
+ */
+export declare function black(str: string): string;
+/**
+ * Set text color to red.
+ * @param str text to make red
+ */
+export declare function red(str: string): string;
+/**
+ * Set text color to green.
+ * @param str text to make green
+ */
+export declare function green(str: string): string;
+/**
+ * Set text color to yellow.
+ * @param str text to make yellow
+ */
+export declare function yellow(str: string): string;
+/**
+ * Set text color to blue.
+ * @param str text to make blue
+ */
+export declare function blue(str: string): string;
+/**
+ * Set text color to magenta.
+ * @param str text to make magenta
+ */
+export declare function magenta(str: string): string;
+/**
+ * Set text color to cyan.
+ * @param str text to make cyan
+ */
+export declare function cyan(str: string): string;
+/**
+ * Set text color to white.
+ * @param str text to make white
+ */
+export declare function white(str: string): string;
+/**
+ * Set text color to gray.
+ * @param str text to make gray
+ */
+export declare function gray(str: string): string;
+/**
+ * Set text color to bright black.
+ * @param str text to make bright-black
+ */
+export declare function brightBlack(str: string): string;
+/**
+ * Set text color to bright red.
+ * @param str text to make bright-red
+ */
+export declare function brightRed(str: string): string;
+/**
+ * Set text color to bright green.
+ * @param str text to make bright-green
+ */
+export declare function brightGreen(str: string): string;
+/**
+ * Set text color to bright yellow.
+ * @param str text to make bright-yellow
+ */
+export declare function brightYellow(str: string): string;
+/**
+ * Set text color to bright blue.
+ * @param str text to make bright-blue
+ */
+export declare function brightBlue(str: string): string;
+/**
+ * Set text color to bright magenta.
+ * @param str text to make bright-magenta
+ */
+export declare function brightMagenta(str: string): string;
+/**
+ * Set text color to bright cyan.
+ * @param str text to make bright-cyan
+ */
+export declare function brightCyan(str: string): string;
+/**
+ * Set text color to bright white.
+ * @param str text to make bright-white
+ */
+export declare function brightWhite(str: string): string;
+/**
+ * Set background color to black.
+ * @param str text to make its background black
+ */
+export declare function bgBlack(str: string): string;
+/**
+ * Set background color to red.
+ * @param str text to make its background red
+ */
+export declare function bgRed(str: string): string;
+/**
+ * Set background color to green.
+ * @param str text to make its background green
+ */
+export declare function bgGreen(str: string): string;
+/**
+ * Set background color to yellow.
+ * @param str text to make its background yellow
+ */
+export declare function bgYellow(str: string): string;
+/**
+ * Set background color to blue.
+ * @param str text to make its background blue
+ */
+export declare function bgBlue(str: string): string;
+/**
+ *  Set background color to magenta.
+ * @param str text to make its background magenta
+ */
+export declare function bgMagenta(str: string): string;
+/**
+ * Set background color to cyan.
+ * @param str text to make its background cyan
+ */
+export declare function bgCyan(str: string): string;
+/**
+ * Set background color to white.
+ * @param str text to make its background white
+ */
+export declare function bgWhite(str: string): string;
+/**
+ * Set background color to bright black.
+ * @param str text to make its background bright-black
+ */
+export declare function bgBrightBlack(str: string): string;
+/**
+ * Set background color to bright red.
+ * @param str text to make its background bright-red
+ */
+export declare function bgBrightRed(str: string): string;
+/**
+ * Set background color to bright green.
+ * @param str text to make its background bright-green
+ */
+export declare function bgBrightGreen(str: string): string;
+/**
+ * Set background color to bright yellow.
+ * @param str text to make its background bright-yellow
+ */
+export declare function bgBrightYellow(str: string): string;
+/**
+ * Set background color to bright blue.
+ * @param str text to make its background bright-blue
+ */
+export declare function bgBrightBlue(str: string): string;
+/**
+ * Set background color to bright magenta.
+ * @param str text to make its background bright-magenta
+ */
+export declare function bgBrightMagenta(str: string): string;
+/**
+ * Set background color to bright cyan.
+ * @param str text to make its background bright-cyan
+ */
+export declare function bgBrightCyan(str: string): string;
+/**
+ * Set background color to bright white.
+ * @param str text to make its background bright-white
+ */
+export declare function bgBrightWhite(str: string): string;
+/**
+ * Set text color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit colors to
+ * @param color code
+ */
+export declare function rgb8(str: string, color: number): string;
+/**
+ * Set background color using paletted 8bit colors.
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+ * @param str text color to apply paletted 8bit background colors to
+ * @param color code
+ */
+export declare function bgRgb8(str: string, color: number): string;
+/**
+ * Set text color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { rgb24 } from "./colors.ts";
+ *      rgb24("foo", 0xff00ff);
+ *      rgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function rgb24(str: string, color: number | Rgb): string;
+/**
+ * Set background color using 24bit rgb.
+ * `color` can be a number in range `0x000000` to `0xffffff` or
+ * an `Rgb`.
+ *
+ * To produce the color magenta:
+ *
+ * ```ts
+ *      import { bgRgb24 } from "./colors.ts";
+ *      bgRgb24("foo", 0xff00ff);
+ *      bgRgb24("foo", {r: 255, g: 0, b: 255});
+ * ```
+ * @param str text color to apply 24bit rgb to
+ * @param color code
+ */
+export declare function bgRgb24(str: string, color: number | Rgb): string;
+/**
+ * Remove ANSI escape codes from the string.
+ * @param string to remove ANSI escape codes from
+ */
+export declare function stripColor(string: string): string;
+export {};

package/esm/deps/deno.land/std@0.133.0/testing/_diff.d.ts

@@ -0,0 +1,23 @@
+export declare enum DiffType {
+    removed = "removed",
+    common = "common",
+    added = "added"
+}
+export interface DiffResult<T> {
+    type: DiffType;
+    value: T;
+    details?: Array<DiffResult<T>>;
+}
+/**
+ * Renders the differences between the actual and expected values
+ * @param A Actual value
+ * @param B Expected value
+ */
+export declare function diff<T>(A: T[], B: T[]): Array<DiffResult<T>>;
+/**
+ * Renders the differences between the actual and expected strings
+ * Partially inspired from https://github.com/kpdecker/jsdiff
+ * @param A Actual string
+ * @param B Expected string
+ */
+export declare function diffstr(A: string, B: string): DiffResult<string>[];

package/esm/deps/deno.land/std@0.133.0/testing/asserts.d.ts

@@ -0,0 +1,167 @@
+export declare class AssertionError extends Error {
+    name: string;
+    constructor(message: string);
+}
+/**
+ * Converts the input into a string. Objects, Sets and Maps are sorted so as to
+ * make tests less flaky
+ * @param v Value to be formatted
+ */
+export declare function _format(v: unknown): string;
+/**
+ * Deep equality comparison used in assertions
+ * @param c actual value
+ * @param d expected value
+ */
+export declare function equal(c: unknown, d: unknown): boolean;
+/** Make an assertion, error will be thrown if `expr` does not have truthy value. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+/**
+ * Make an assertion that `actual` and `expected` are equal, deeply. If not
+ * deeply equal, then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ * For example:
+ * ```ts
+ * import { assertEquals } from "./asserts.ts";
+ *
+ * assertEquals<number>(1, 2)
+ * ```
+ */
+export declare function assertEquals(actual: unknown, expected: unknown, msg?: string): void;
+export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are not equal, deeply.
+ * If not then throw.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ * For example:
+ * ```ts
+ * import { assertNotEquals } from "./asserts.ts";
+ *
+ * assertNotEquals<number>(1, 2)
+ * ```
+ */
+export declare function assertNotEquals(actual: unknown, expected: unknown, msg?: string): void;
+export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are strictly equal. If
+ * not then throw.
+ *
+ * ```ts
+ * import { assertStrictEquals } from "./asserts.ts";
+ *
+ * assertStrictEquals(1, 2)
+ * ```
+ */
+export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
+/**
+ * Make an assertion that `actual` and `expected` are not strictly equal.
+ * If the values are strictly equal then throw.
+ *
+ * ```ts
+ * import { assertNotStrictEquals } from "./asserts.ts";
+ *
+ * assertNotStrictEquals(1, 1)
+ * ```
+ */
+export declare function assertNotStrictEquals(actual: unknown, expected: unknown, msg?: string): void;
+export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+/**
+ * Make an assertion that `actual` and `expected` are almost equal numbers through
+ * a given tolerance. It can be used to take into account IEEE-754 double-precision
+ * floating-point representation limitations.
+ * If the values are not almost equal then throw.
+ *
+ * ```ts
+ * import { assertAlmostEquals, assertThrows } from "./asserts.ts";
+ *
+ * assertAlmostEquals(0.1, 0.2);
+ *
+ * // Using a custom tolerance value
+ * assertAlmostEquals(0.1 + 0.2, 0.3, 1e-16);
+ * assertThrows(() => assertAlmostEquals(0.1 + 0.2, 0.3, 1e-17));
+ * ```
+ */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+type AnyConstructor = new (...args: any[]) => any;
+type GetConstructorType<T extends AnyConstructor> = T extends new (...args: any) => infer C ? C : never;
+/**
+ * Make an assertion that `obj` is an instance of `type`.
+ * If not then throw.
+ */
+export declare function assertInstanceOf<T extends AnyConstructor>(actual: unknown, expectedType: T, msg?: string): asserts actual is GetConstructorType<T>;
+/**
+ * Make an assertion that actual is not null or undefined.
+ * If not then throw.
+ */
+export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;
+/**
+ * Make an assertion that actual includes expected. If not
+ * then throw.
+ */
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
+/**
+ * Make an assertion that `actual` includes the `expected` values.
+ * If not then an error will be thrown.
+ *
+ * Type parameter can be specified to ensure values under comparison have the same type.
+ * For example:
+ *
+ * ```ts
+ * import { assertArrayIncludes } from "./asserts.ts";
+ *
+ * assertArrayIncludes<number>([1, 2], [2])
+ * ```
+ */
+export declare function assertArrayIncludes(actual: ArrayLike<unknown>, expected: ArrayLike<unknown>, msg?: string): void;
+export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;
+/**
+ * Make an assertion that `actual` match RegExp `expected`. If not
+ * then throw.
+ */
+export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;
+/**
+ * Make an assertion that `actual` not match RegExp `expected`. If match
+ * then throw.
+ */
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
+/**
+ * Make an assertion that `actual` object is a subset of `expected` object, deeply.
+ * If not, then throw.
+ */
+export declare function assertObjectMatch(actual: Record<PropertyKey, any>, expected: Record<PropertyKey, unknown>): void;
+/**
+ * Forcefully throws a failed assertion
+ */
+export declare function fail(msg?: string): never;
+/**
+ * Make an assertion that `error` is an `Error`.
+ * If not then an error will be thrown.
+ * An error class and a string that should be included in the
+ * error message can also be asserted.
+ */
+export declare function assertIsError<E extends Error = Error>(error: unknown, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): asserts error is E;
+/**
+ * Executes a function, expecting it to throw.  If it does not, then it
+ * throws. An error class and a string that should be included in the
+ * error message can also be asserted. Or you can pass a
+ * callback which will be passed the error, usually to apply some custom
+ * assertions on it.
+ */
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): void;
+export declare function assertThrows(fn: () => unknown, errorCallback: (e: Error) => unknown, msg?: string): void;
+/**
+ * Executes a function which returns a promise, expecting it to throw or reject.
+ * If it does not, then it throws. An error class and a string that should be
+ * included in the error message can also be asserted. Or you can pass a
+ * callback which will be passed the error, usually to apply some custom
+ * assertions on it.
+ */
+export declare function assertRejects<E extends Error = Error>(fn: () => Promise<unknown>, ErrorClass?: new (...args: any[]) => E, msgIncludes?: string, msg?: string): Promise<void>;
+export declare function assertRejects(fn: () => Promise<unknown>, errorCallback: (e: Error) => unknown, msg?: string): Promise<void>;
+/** Use this to stub out methods that will throw when invoked. */
+export declare function unimplemented(msg?: string): never;
+/** Use this to assert unreachable code. */
+export declare function unreachable(): never;
+export {};