@w5s/conventional-changelog 1.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Julien Polo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+<!-- AUTO-GENERATED-CONTENT:START (PKG_JSON:template=# W5s Commitlint configuration _(${name})_) -->
+# W5s Commitlint configuration _(@w5s/commitlint-config)_
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+[![NPM Version][package-version-svg]][package-url]
+[![License][license-image]][license-url]
+
+<!-- AUTO-GENERATED-CONTENT:START (PKG_JSON:template=> ${description}&unknownTxt= ) -->
+> Commitlint configuration presets
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+## Installation
+
+<!-- AUTO-GENERATED-CONTENT:START (PKG_JSON:template=```console\nnpm install --save-dev ${name} @commitlint/cli\n```) -->
+```console
+npm install --save-dev @w5s/commitlint-config @commitlint/cli
+```
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+## Usage
+
+In the `package.json` of your project
+
+<!-- AUTO-GENERATED-CONTENT:START (PKG_JSON:template=```json\n{\n  "commitlint": {\n    "extends": ["${name}"]\n  }\n}\n```) -->
+```json
+{
+  "commitlint": {
+    "extends": ["@w5s/commitlint-config"]
+  }
+}
+```
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+Extra rules
+
+```jsonc
+{
+  "commitlint": {
+    "rules": {
+      // Rule to validate gitmoji unicode (🐛) or emoji (:bug:)
+      "type-gitmoji-style": ["error", "always", "unicode" /* | 'emoji' */],
+      // Rule to validate a gitmoji in the list
+      "type-valid-gitmoji": ["error", "always"]
+    }
+  }
+}
+```
+
+Ensure the `commitlint` is setup on husky commit message hook (default `.husky/commit-msg`)
+
+```console
+commitlint --edit $1
+# -OR-
+npm exec --no -- commitlint --edit $1
+```
+
+## License
+<!-- AUTO-GENERATED-CONTENT:START (PKG_JSON:template=[${license}][license-url] © ${author}) -->
+[MIT][license-url] © Julien Polo <julien.polo@gmail.com>
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+<!-- VARIABLES -->
+
+<!-- AUTO-GENERATED-CONTENT:START (PKG_JSON:template=[package-version-svg]: https://img.shields.io/npm/v/${name}.svg?style=flat-square) -->
+[package-version-svg]: https://img.shields.io/npm/v/@w5s/commitlint-config.svg?style=flat-square
+<!-- AUTO-GENERATED-CONTENT:END -->
+<!-- AUTO-GENERATED-CONTENT:START (PKG_JSON:template=[package-url]: https://www.npmjs.com/package/${name}) -->
+[package-url]: https://www.npmjs.com/package/@w5s/commitlint-config
+<!-- AUTO-GENERATED-CONTENT:END -->
+<!-- AUTO-GENERATED-CONTENT:START (PKG_JSON:template=[license-image]: https://img.shields.io/badge/license-${license}-green.svg?style=flat-square) -->
+[license-image]: https://img.shields.io/badge/license-MIT-green.svg?style=flat-square
+<!-- AUTO-GENERATED-CONTENT:END -->
+[license-url]: ../../LICENSE

package/lib/data.d.ts

@@ -0,0 +1,27 @@
+import type { Commit as CommitDefault } from 'conventional-commits-parser';
+export type Commit = CommitDefault<never> & {
+    hash?: string;
+};
+export type CommitConventionalType = 'build' | 'ci' | 'docs' | 'feat' | 'fix' | 'perf' | 'refactor' | 'revert' | 'style' | 'test' | 'wip' | 'chore';
+export declare const CommitConventionalType: {
+    hasInstance: (anyValue: unknown) => anyValue is CommitConventionalType;
+    getData: (commitType: CommitConventionalType) => CommitConventionalTypeData;
+    values: () => readonly CommitConventionalType[];
+    parse: (anyValue: string) => CommitConventionalType | undefined;
+    Build: "build";
+    CI: "ci";
+    Docs: "docs";
+    Feat: "feat";
+    Fix: "fix";
+    Perf: "perf";
+    Refactor: "refactor";
+    Revert: "revert";
+    Style: "style";
+    Test: "test";
+    WIP: "wip";
+    Chore: "chore";
+};
+export interface CommitConventionalTypeData {
+    emoji: string;
+    'en-US': string;
+}

package/lib/data.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommitConventionalType = void 0;
+exports.CommitConventionalType = (() => {
+    const enumObject = Object.freeze({
+        Build: 'build',
+        CI: 'ci',
+        Docs: 'docs',
+        Feat: 'feat',
+        Fix: 'fix',
+        Perf: 'perf',
+        Refactor: 'refactor',
+        Revert: 'revert',
+        Style: 'style',
+        Test: 'test',
+        WIP: 'wip',
+        Chore: 'chore',
+    });
+    const enumValues = Object.freeze(Object.values(enumObject).sort());
+    const enumValuesSet = new Set(enumValues);
+    const typeData = {
+        feat: {
+            emoji: '✨',
+            'en-US': 'Features',
+        },
+        fix: {
+            emoji: '🐛',
+            'en-US': 'Bug Fixes',
+        },
+        build: {
+            emoji: '👷',
+            'en-US': 'Build System',
+        },
+        chore: {
+            emoji: '🎫',
+            'en-US': 'Chores',
+        },
+        ci: {
+            emoji: '🔧',
+            'en-US': 'Continuous Integration',
+        },
+        docs: {
+            emoji: '📝',
+            'en-US': 'Documentation',
+        },
+        test: {
+            emoji: '✅',
+            'en-US': 'Tests',
+        },
+        perf: {
+            emoji: '⚡',
+            'en-US': 'Performance Improvements',
+        },
+        refactor: {
+            emoji: '♻',
+            'en-US': 'Code Refactoring',
+        },
+        revert: {
+            emoji: '⏪',
+            'en-US': 'Reverts',
+        },
+        style: {
+            emoji: '💄',
+            'en-US': 'Styles',
+        },
+        wip: {
+            emoji: '🚧',
+            'en-US': 'Work in progress',
+        },
+    };
+    function hasInstance(anyValue) {
+        return typeof anyValue === 'string' && enumValuesSet.has(anyValue);
+    }
+    function getData(commitType) {
+        return typeData[commitType];
+    }
+    function parse(anyValue) {
+        return hasInstance(anyValue) ? anyValue : undefined;
+    }
+    function values() {
+        return enumValues;
+    }
+    return { ...enumObject, hasInstance, getData, values, parse };
+})();

package/lib/gitmoji.d.ts

@@ -0,0 +1,28 @@
+import type { CommitConventionalType } from './data';
+export type Emoji = Emoji.Unicode | Emoji.Text;
+export declare namespace Emoji {
+    const reEmojiUnicode: RegExp;
+    const reEmojiText: RegExp;
+    type Unicode = string & {
+        '@@EmojiStyle': 'unicode';
+    };
+    type Text = string & {
+        '@@EmojiStyle': 'text';
+    };
+    function isUnicode(anyValue: string): anyValue is Unicode;
+    function isText(anyValue: string): anyValue is Text;
+    function hasInstance(anyValue: string): anyValue is Emoji;
+}
+export type GitmojiCode = Emoji & {
+    '@@Gitmoji': true;
+};
+export declare namespace GitmojiCode {
+    type Unicode = Emoji.Unicode & {
+        '@@Gitmoji': true;
+    };
+    type Emoji = Emoji.Text & {
+        '@@Gitmoji': true;
+    };
+    function isValid(anyValue: string): anyValue is GitmojiCode;
+    function toConventionalCommitType(gitmoji: GitmojiCode): CommitConventionalType;
+}

package/lib/gitmoji.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitmojiCode = exports.Emoji = void 0;
+const emoji_regex_1 = __importDefault(require("emoji-regex"));
+const gitmojis_1 = require("gitmojis");
+var Emoji;
+(function (Emoji) {
+    Emoji.reEmojiUnicode = (0, emoji_regex_1.default)();
+    Emoji.reEmojiText = /:(\w+):/;
+    const reMatchOnly = (input) => new RegExp(`^${input.source}$`, input.flags);
+    const _reEmojiUnicode = reMatchOnly(Emoji.reEmojiUnicode);
+    const _reEmojiText = reMatchOnly(Emoji.reEmojiText);
+    function isUnicode(anyValue) {
+        return anyValue.match(_reEmojiUnicode) != null;
+    }
+    Emoji.isUnicode = isUnicode;
+    function isText(anyValue) {
+        return anyValue.match(_reEmojiText) != null;
+    }
+    Emoji.isText = isText;
+    function hasInstance(anyValue) {
+        return isText(anyValue) || isUnicode(anyValue);
+    }
+    Emoji.hasInstance = hasInstance;
+})(Emoji = exports.Emoji || (exports.Emoji = {}));
+var GitmojiCode;
+(function (GitmojiCode) {
+    // export const reEmoji = emojiRegexp();
+    const allGitmojiCodes = new Set(gitmojis_1.gitmojis
+        .map((gitmoji) => gitmoji.code)
+        .concat(gitmojis_1.gitmojis.map((gitmoji) => gitmoji.emoji)));
+    const index = {
+        // code: createIndex(gitmojis, 'code'),
+        emoji: createIndex(gitmojis_1.gitmojis, 'emoji'),
+    };
+    function createIndex(list, key) {
+        return new Map(list.map((gitmoji) => [gitmoji[key], gitmoji]));
+    }
+    function isValid(anyValue) {
+        return allGitmojiCodes.has(anyValue);
+    }
+    GitmojiCode.isValid = isValid;
+    const defaultType = 'chore';
+    const conversionMap = (() => {
+        const data = {
+            feat: ['✨', '♿️', '🚸'],
+            fix: ['🐛'],
+            docs: ['📝'],
+            style: ['🎨', '🚨'],
+            refactor: ['♻️', '🏗️'],
+            test: ['✅'],
+            perf: ['⚡️'],
+            revert: ['⏪️'],
+            ci: ['👷', '💚'],
+            wip: ['🚧'],
+            build: [],
+            chore: [],
+        };
+        const entries = Array.from(
+        // @ts-ignore
+        Object.entries(data));
+        return new Map(entries.reduce((acc, [commitType, gitmojiUnicodeArray]) => acc
+            .concat(gitmojiUnicodeArray.map((gitmojiUnicode) => [gitmojiUnicode, commitType]))
+            .concat(gitmojiUnicodeArray.map((gitmojiUnicode) => [
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            index.emoji.get(gitmojiUnicode)?.code,
+            commitType,
+        ])), []));
+    })();
+    function toConventionalCommitType(gitmoji) {
+        return conversionMap.get(gitmoji) ?? defaultType;
+    }
+    GitmojiCode.toConventionalCommitType = toConventionalCommitType;
+})(GitmojiCode = exports.GitmojiCode || (exports.GitmojiCode = {}));

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    parserOpts: import("./parser-opts").ParserOptions;
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parser_opts_1 = require("./parser-opts");
+exports.default = {
+    parserOpts: parser_opts_1.parserOpts,
+};

package/lib/parser-opts.d.ts

@@ -0,0 +1,4 @@
+import type { Options } from 'conventional-commits-parser';
+export interface ParserOptions extends Options {
+}
+export declare const parserOpts: ParserOptions;

package/lib/parser-opts.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parserOpts = void 0;
+const gitmoji_1 = require("./gitmoji");
+exports.parserOpts = {
+    headerPattern: new RegExp(`^(:\\w*:|${gitmoji_1.Emoji.reEmojiUnicode.source}) (?:\\((.*)\\):? )?(.*)$`),
+    headerCorrespondence: ['type', 'scope', 'subject'],
+    revertPattern: /^(?:revert|revert:)\s"?([\S\s]+?)"?\s*this reverts commit (\w*)\./i,
+    noteKeywords: ['BREAKING CHANGE', 'BREAKING CHANGES'],
+    // revertPattern: /revert:\s([\S\s]*?)\s*this reverts commit (\w*)\./i,
+    revertCorrespondence: [`header`, `hash`],
+};

package/lib/transform.d.ts

@@ -0,0 +1,20 @@
+import type { Options as WriterOptions } from 'conventional-changelog-writer';
+import { CommitConventionalType } from './data.js';
+export type Language = 'en-US';
+export interface TransformConfig {
+    scopeDisplayName?: Record<string, string>;
+    displayTypes?: CommitConventionalType[];
+    displayScopes?: string[];
+    showAuthor?: boolean;
+    withEmoji?: boolean;
+    language?: Language;
+}
+export declare function displayScope(scope: string | null | undefined, scopeDisplayNameMap: Record<string, string>): string | undefined;
+export declare function displayType(type: CommitConventionalType, options?: displayType.Options): string;
+export declare namespace displayType {
+    interface Options {
+        readonly withEmoji?: boolean;
+        readonly language?: Language;
+    }
+}
+export declare function createTransform(config: TransformConfig): WriterOptions.Transform.Function;

package/lib/transform.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransform = exports.displayType = exports.displayScope = void 0;
+const data_js_1 = require("./data.js");
+const gitmoji_js_1 = require("./gitmoji.js");
+function displayScope(scope, scopeDisplayNameMap) {
+    return scope == null || scope.length === 0
+        ? scopeDisplayNameMap['*']
+        : scopeDisplayNameMap[scope] == null
+            ? scope
+            : scopeDisplayNameMap[scope];
+}
+exports.displayScope = displayScope;
+function displayType(type, options = {}) {
+    const { withEmoji = true, language = 'en-US' } = options;
+    if (data_js_1.CommitConventionalType.hasInstance(type)) {
+        const { emoji, [language]: title } = data_js_1.CommitConventionalType.getData(type);
+        return `${withEmoji ? `${emoji} ` : ''}${title}`;
+    }
+    return type;
+}
+exports.displayType = displayType;
+function createTransform(config) {
+    const displayTypes = new Set(config.displayTypes == null ? data_js_1.CommitConventionalType.values() : config.displayTypes);
+    const ignoreType = (type) => type == null || !displayTypes.has(type);
+    const ignoreScope = (scope) => config.displayScopes == null ? false : scope != null && !config.displayScopes.includes(scope);
+    const transform = (commit, { repository, host, owner, repoUrl }) => {
+        const discard = commit.notes.length === 0;
+        const issues = new Set();
+        const notes = commit.notes.map((note) => ({
+            ...note,
+            title: `${config.withEmoji === false ? '' : '💥 '}BREAKING CHANGES`,
+        }));
+        const conventionalType = commit.type == null
+            ? undefined
+            : data_js_1.CommitConventionalType.parse(commit.type) ??
+                (gitmoji_js_1.GitmojiCode.isValid(commit.type) ? gitmoji_js_1.GitmojiCode.toConventionalCommitType(commit.type) : undefined);
+        if (ignoreType(conventionalType) && discard)
+            return false;
+        const type = conventionalType == null
+            ? conventionalType
+            : displayType(conventionalType, {
+                withEmoji: config.withEmoji,
+            });
+        if (ignoreScope(commit.scope))
+            return false;
+        const scopeIntermediate = commit.scope === '*' ? '' : commit.scope;
+        const scope = config.scopeDisplayName == null ? scopeIntermediate : displayScope(scopeIntermediate, config.scopeDisplayName);
+        const hash = typeof commit.hash === 'string' ? commit.hash.slice(0, 7) : commit.hash;
+        const subject = typeof commit.subject === 'string'
+            ? (() => {
+                let returnValue = commit.subject;
+                const url = repository == null ? repoUrl : [host, owner, repository].filter(Boolean).join('/');
+                if (url != null) {
+                    const issueURL = `${url}/issues/`;
+                    // Issue URLs.
+                    returnValue = returnValue.replace(/#(\d+)/g, (_, issue) => {
+                        issues.add(issue);
+                        return `[#${issue}](${issueURL}${issue})`;
+                    });
+                }
+                if (host != null) {
+                    // User URLs.
+                    // eslint-disable-next-line unicorn/no-unsafe-regex
+                    returnValue = returnValue.replace(/\B@([\da-z](?:-?[\d/a-z]){0,38})/g, (_, username) => username.includes('/') ? `@${username}` : `[@${username}](${host}/${username})`);
+                }
+                return returnValue;
+            })()
+            : commit.subject;
+        // Remove references that already appear in the subject
+        const references = commit.references.filter((reference) => !issues.has(reference.issue));
+        return {
+            ...commit,
+            type,
+            hash,
+            scope,
+            subject,
+            references,
+            header: commit.header,
+            body: commit.body,
+            footer: commit.footer,
+            merge: commit.merge,
+            revert: commit.revert,
+            notes,
+            mentions: commit.mentions,
+        };
+    };
+    return transform;
+}
+exports.createTransform = createTransform;

package/lib/writer-opts.d.ts

@@ -0,0 +1,4 @@
+import type { Options } from 'conventional-changelog-writer';
+export interface WriterOptions extends Options {
+}
+export declare const writerOpts: WriterOptions;

package/lib/writer-opts.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writerOpts = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const transform_js_1 = require("./transform.js");
+const basePath = (0, node_path_1.resolve)(__dirname, './templates');
+const template = (0, node_fs_1.readFileSync)(`${basePath}/template.hbs`, 'utf8');
+const header = (0, node_fs_1.readFileSync)(`${basePath}/header.hbs`, 'utf8');
+const commit = (0, node_fs_1.readFileSync)(`${basePath}/commit.hbs`, 'utf8');
+const footer = (0, node_fs_1.readFileSync)(`${basePath}/footer.hbs`, 'utf8');
+const author = (0, node_fs_1.readFileSync)(`${basePath}/author.hbs`, 'utf8');
+exports.writerOpts = {
+    transform: (0, transform_js_1.createTransform)({}),
+    groupBy: 'type',
+    commitGroupsSort: 'title',
+    commitsSort: ['scope', 'subject'],
+    noteGroupsSort: 'title',
+    mainTemplate: template,
+    headerPartial: header,
+    commitPartial: commit.replace(/{{gitUserInfo}}/g, author),
+    footerPartial: footer,
+};

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@w5s/conventional-changelog",
+  "version": "1.0.0-alpha.1",
+  "description": "Conventional changelog plugin for @w5s",
+  "keywords": [],
+  "homepage": "https://github.com/w5s/project-config/blob/main/packages/conventional-changelog#readme",
+  "bugs": {
+    "url": "https://github.com/w5s/project-config/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:w5s/project-config.git",
+    "directory": "packages/conventional-changelog"
+  },
+  "license": "MIT",
+  "author": "Julien Polo <julien.polo@gmail.com>",
+  "type": "commonjs",
+  "exports": {
+    ".": "./lib/index.js",
+    "./lib/*": "./lib/*"
+  },
+  "typings": "./lib/index.d.ts",
+  "files": [
+    "lib/**/!(*.spec).d.ts",
+    "lib/**/!(*.spec).d.ts.map",
+    "lib/**/!(*.spec).js.map",
+    "lib/**/!(*.spec).js",
+    "src/**/!(*.spec).ts",
+    "index.js",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "build": "concurrently \"npm:build:*\" \":\"",
+    "build:src": "tsc",
+    "clean": "concurrently \"npm:clean:*\" \":\"",
+    "clean:src": "rm -rf lib/*",
+    "docs": "md-magic --path '**/*.md' --ignore='node_modules'",
+    "format": "concurrently \"npm:format:*\" \":\"",
+    "format:src": "eslint . --fix --ext=mjs,cjs,js,jsx,ts,tsx,json,jsonc,json5,yml,yaml",
+    "lint": "concurrently \"npm:lint:*\" \":\"",
+    "lint:src": "eslint . --ext=mjs,cjs,js,jsx,ts,tsx,json,jsonc,json5,yml,yaml",
+    "prepare": "concurrently \"npm:prepare:*\" \":\"",
+    "prepublishOnly": "npm run clean;npm run build",
+    "spellcheck": "cspell --no-progress '**'",
+    "test": "concurrently \"npm:test:*\" ",
+    "test:src": "jest"
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "^(\\.{1,2}/.*)\\.js$": "$1"
+    },
+    "preset": "es-jest",
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "/lib/",
+      "/build/",
+      "/.cache/",
+      "/docs/",
+      "/public/"
+    ]
+  },
+  "dependencies": {
+    "@commitlint/types": "^17.0.0",
+    "emoji-regex": "^10.2.1",
+    "gitmojis": "^3.13.4"
+  },
+  "devDependencies": {
+    "@jest/globals": "29.4.1",
+    "@types/conventional-changelog-writer": "4.0.2",
+    "@types/conventional-commits-parser": "3.0.3"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "dd093c2907cf8e136f4adec9a14b176e0851de17"
+}

package/src/data.ts

@@ -0,0 +1,112 @@
+import type { Commit as CommitDefault } from 'conventional-commits-parser';
+
+export type Commit = CommitDefault<never> & {
+  hash?: string;
+};
+
+export type CommitConventionalType =
+  | 'build'
+  | 'ci'
+  | 'docs'
+  | 'feat'
+  | 'fix'
+  | 'perf'
+  | 'refactor'
+  | 'revert'
+  | 'style'
+  | 'test'
+  | 'wip'
+  | 'chore';
+
+export const CommitConventionalType = (() => {
+  const enumObject = Object.freeze({
+    Build: 'build',
+    CI: 'ci',
+    Docs: 'docs',
+    Feat: 'feat',
+    Fix: 'fix',
+    Perf: 'perf',
+    Refactor: 'refactor',
+    Revert: 'revert',
+    Style: 'style',
+    Test: 'test',
+    WIP: 'wip',
+    Chore: 'chore',
+  });
+  const enumValues: readonly CommitConventionalType[] = Object.freeze(Object.values(enumObject).sort());
+  const enumValuesSet = new Set(enumValues);
+
+  const typeData: Record<CommitConventionalType, CommitConventionalTypeData> = {
+    feat: {
+      emoji: '✨',
+      'en-US': 'Features',
+    },
+    fix: {
+      emoji: '🐛',
+      'en-US': 'Bug Fixes',
+    },
+    build: {
+      emoji: '👷',
+      'en-US': 'Build System',
+    },
+    chore: {
+      emoji: '🎫',
+      'en-US': 'Chores',
+    },
+    ci: {
+      emoji: '🔧',
+      'en-US': 'Continuous Integration',
+    },
+    docs: {
+      emoji: '📝',
+      'en-US': 'Documentation',
+    },
+    test: {
+      emoji: '✅',
+      'en-US': 'Tests',
+    },
+    perf: {
+      emoji: '⚡',
+      'en-US': 'Performance Improvements',
+    },
+    refactor: {
+      emoji: '♻',
+      'en-US': 'Code Refactoring',
+    },
+    revert: {
+      emoji: '⏪',
+      'en-US': 'Reverts',
+    },
+    style: {
+      emoji: '💄',
+      'en-US': 'Styles',
+    },
+    wip: {
+      emoji: '🚧',
+      'en-US': 'Work in progress',
+    },
+  };
+
+  function hasInstance(anyValue: unknown): anyValue is CommitConventionalType {
+    return typeof anyValue === 'string' && enumValuesSet.has(anyValue as unknown as CommitConventionalType);
+  }
+
+  function getData(commitType: CommitConventionalType): CommitConventionalTypeData {
+    return typeData[commitType];
+  }
+
+  function parse(anyValue: string): CommitConventionalType | undefined {
+    return hasInstance(anyValue) ? anyValue : undefined;
+  }
+
+  function values() {
+    return enumValues;
+  }
+
+  return { ...enumObject, hasInstance, getData, values, parse };
+})();
+
+export interface CommitConventionalTypeData {
+  emoji: string;
+  'en-US': string;
+}

package/src/gitmoji.ts

@@ -0,0 +1,98 @@
+import emojiRegexp from 'emoji-regex';
+import { Gitmoji, gitmojis } from 'gitmojis';
+import type { CommitConventionalType } from './data';
+
+export type Emoji = Emoji.Unicode | Emoji.Text;
+export namespace Emoji {
+  export const reEmojiUnicode = emojiRegexp();
+
+  export const reEmojiText = /:(\w+):/;
+
+  const reMatchOnly = (input: RegExp) => new RegExp(`^${input.source}$`, input.flags);
+  const _reEmojiUnicode = reMatchOnly(reEmojiUnicode);
+  const _reEmojiText = reMatchOnly(reEmojiText);
+
+  export type Unicode = string & { '@@EmojiStyle': 'unicode' };
+  export type Text = string & { '@@EmojiStyle': 'text' };
+
+  export function isUnicode(anyValue: string): anyValue is Unicode {
+    return anyValue.match(_reEmojiUnicode) != null;
+  }
+
+  export function isText(anyValue: string): anyValue is Text {
+    return anyValue.match(_reEmojiText) != null;
+  }
+
+  export function hasInstance(anyValue: string): anyValue is Emoji {
+    return isText(anyValue) || isUnicode(anyValue);
+  }
+}
+
+export type GitmojiCode = Emoji & { '@@Gitmoji': true };
+export namespace GitmojiCode {
+  export type Unicode = Emoji.Unicode & { '@@Gitmoji': true };
+  export type Emoji = Emoji.Text & { '@@Gitmoji': true };
+
+  // export const reEmoji = emojiRegexp();
+
+  const allGitmojiCodes = new Set(
+    gitmojis
+      .map((gitmoji) => gitmoji.code as GitmojiCode)
+      .concat(gitmojis.map((gitmoji) => gitmoji.emoji as GitmojiCode))
+  );
+  const index = {
+    // code: createIndex(gitmojis, 'code'),
+    emoji: createIndex(gitmojis, 'emoji'),
+  };
+
+  function createIndex<K extends keyof Gitmoji>(list: readonly Gitmoji[], key: K): ReadonlyMap<Gitmoji[K], Gitmoji> {
+    return new Map(list.map((gitmoji) => [gitmoji[key], gitmoji]));
+  }
+
+  export function isValid(anyValue: string): anyValue is GitmojiCode {
+    return allGitmojiCodes.has(anyValue as GitmojiCode);
+  }
+
+  const defaultType = 'chore';
+  const conversionMap: ReadonlyMap<GitmojiCode, CommitConventionalType> = (() => {
+    const data: Record<CommitConventionalType, GitmojiCode.Unicode[]> = {
+      feat: ['✨', '♿️', '🚸'] as GitmojiCode.Unicode[],
+      fix: ['🐛'] as GitmojiCode.Unicode[],
+      docs: ['📝'] as GitmojiCode.Unicode[],
+      style: ['🎨', '🚨'] as GitmojiCode.Unicode[],
+      refactor: ['♻️', '🏗️'] as GitmojiCode.Unicode[],
+      test: ['✅'] as GitmojiCode.Unicode[],
+      perf: ['⚡️'] as GitmojiCode.Unicode[],
+      revert: ['⏪️'] as GitmojiCode.Unicode[],
+      ci: ['👷', '💚'] as GitmojiCode.Unicode[],
+      wip: ['🚧'] as GitmojiCode.Unicode[],
+      build: [] as GitmojiCode.Unicode[],
+      chore: [] as GitmojiCode.Unicode[],
+    };
+
+    const entries = Array.from<[CommitConventionalType, GitmojiCode.Unicode[]]>(
+      // @ts-ignore
+      Object.entries(data)
+    );
+    return new Map(
+      entries.reduce<Array<[GitmojiCode, CommitConventionalType]>>(
+        (acc, [commitType, gitmojiUnicodeArray]) =>
+          acc
+            .concat(gitmojiUnicodeArray.map((gitmojiUnicode) => [gitmojiUnicode, commitType]))
+
+            .concat(
+              gitmojiUnicodeArray.map((gitmojiUnicode) => [
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                index.emoji.get(gitmojiUnicode)?.code! as GitmojiCode,
+                commitType,
+              ])
+            ),
+        []
+      )
+    );
+  })();
+
+  export function toConventionalCommitType(gitmoji: GitmojiCode): CommitConventionalType {
+    return conversionMap.get(gitmoji) ?? defaultType;
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+import { parserOpts } from './parser-opts';
+
+export default {
+  parserOpts,
+};

package/src/parser-opts.ts

@@ -0,0 +1,13 @@
+import type { Options } from 'conventional-commits-parser';
+import { Emoji } from './gitmoji';
+
+export interface ParserOptions extends Options {}
+
+export const parserOpts: ParserOptions = {
+  headerPattern: new RegExp(`^(:\\w*:|${Emoji.reEmojiUnicode.source}) (?:\\((.*)\\):? )?(.*)$`),
+  headerCorrespondence: ['type', 'scope', 'subject'],
+  revertPattern: /^(?:revert|revert:)\s"?([\S\s]+?)"?\s*this reverts commit (\w*)\./i,
+  noteKeywords: ['BREAKING CHANGE', 'BREAKING CHANGES'],
+  // revertPattern: /revert:\s([\S\s]*?)\s*this reverts commit (\w*)\./i,
+  revertCorrespondence: [`header`, `hash`],
+};

package/src/transform.ts

@@ -0,0 +1,122 @@
+import type { Context, Options as WriterOptions } from 'conventional-changelog-writer';
+import { CommitConventionalType, Commit } from './data.js';
+import { GitmojiCode } from './gitmoji.js';
+
+export type Language = 'en-US';
+
+export interface TransformConfig {
+  scopeDisplayName?: Record<string, string>;
+  displayTypes?: CommitConventionalType[];
+  displayScopes?: string[];
+  showAuthor?: boolean;
+  withEmoji?: boolean;
+  language?: Language;
+}
+
+export function displayScope(scope: string | null | undefined, scopeDisplayNameMap: Record<string, string>) {
+  return scope == null || scope.length === 0
+    ? scopeDisplayNameMap['*']
+    : scopeDisplayNameMap[scope] == null
+    ? scope
+    : scopeDisplayNameMap[scope];
+}
+
+export function displayType(type: CommitConventionalType, options: displayType.Options = {}): string {
+  const { withEmoji = true, language = 'en-US' } = options;
+
+  if (CommitConventionalType.hasInstance(type)) {
+    const { emoji, [language]: title } = CommitConventionalType.getData(type);
+    return `${withEmoji ? `${emoji} ` : ''}${title}`;
+  }
+
+  return type;
+}
+export namespace displayType {
+  export interface Options {
+    readonly withEmoji?: boolean;
+    readonly language?: Language;
+  }
+}
+
+export function createTransform(config: TransformConfig): WriterOptions.Transform.Function {
+  const displayTypes = new Set(config.displayTypes == null ? CommitConventionalType.values() : config.displayTypes);
+  const ignoreType = (type: string | undefined) => type == null || !displayTypes.has(type as CommitConventionalType);
+  const ignoreScope = (scope: string | undefined | null) =>
+    config.displayScopes == null ? false : scope != null && !config.displayScopes.includes(scope);
+
+  const transform = (commit: Commit, { repository, host, owner, repoUrl }: Context): Commit | false => {
+    const discard = commit.notes.length === 0;
+    const issues = new Set<string>();
+    const notes = commit.notes.map((note) => ({
+      ...note,
+      title: `${config.withEmoji === false ? '' : '💥 '}BREAKING CHANGES`,
+    }));
+    const conventionalType =
+      commit.type == null
+        ? undefined
+        : CommitConventionalType.parse(commit.type) ??
+          (GitmojiCode.isValid(commit.type) ? GitmojiCode.toConventionalCommitType(commit.type) : undefined);
+
+    if (ignoreType(conventionalType) && discard) return false;
+
+    const type =
+      conventionalType == null
+        ? conventionalType
+        : displayType(conventionalType, {
+            withEmoji: config.withEmoji,
+          });
+
+    if (ignoreScope(commit.scope)) return false;
+
+    const scopeIntermediate = commit.scope === '*' ? '' : commit.scope;
+    const scope =
+      config.scopeDisplayName == null ? scopeIntermediate : displayScope(scopeIntermediate, config.scopeDisplayName);
+    const hash = typeof commit.hash === 'string' ? commit.hash.slice(0, 7) : commit.hash;
+
+    const subject =
+      typeof commit.subject === 'string'
+        ? (() => {
+            let returnValue = commit.subject;
+            const url = repository == null ? repoUrl : [host, owner, repository].filter(Boolean).join('/');
+            if (url != null) {
+              const issueURL = `${url}/issues/`;
+              // Issue URLs.
+              returnValue = returnValue.replace(/#(\d+)/g, (_, issue: string) => {
+                issues.add(issue);
+
+                return `[#${issue}](${issueURL}${issue})`;
+              });
+            }
+            if (host != null) {
+              // User URLs.
+              // eslint-disable-next-line unicorn/no-unsafe-regex
+              returnValue = returnValue.replace(/\B@([\da-z](?:-?[\d/a-z]){0,38})/g, (_, username: string) =>
+                username.includes('/') ? `@${username}` : `[@${username}](${host}/${username})`
+              );
+            }
+            return returnValue;
+          })()
+        : commit.subject;
+
+    // Remove references that already appear in the subject
+    const references = commit.references.filter((reference) => !issues.has(reference.issue));
+
+    return {
+      ...commit,
+      type,
+      hash,
+      scope,
+      subject,
+      references,
+      header: commit.header,
+      body: commit.body,
+      footer: commit.footer,
+      merge: commit.merge,
+      revert: commit.revert,
+      notes,
+      mentions: commit.mentions,
+    };
+  };
+
+  return transform as unknown as WriterOptions.Transform.Function;
+}

package/src/writer-opts.ts

@@ -0,0 +1,26 @@
+import type { Options } from 'conventional-changelog-writer';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createTransform } from './transform.js';
+
+export interface WriterOptions extends Options {}
+
+const basePath = resolve(__dirname, './templates');
+
+const template = readFileSync(`${basePath}/template.hbs`, 'utf8');
+const header = readFileSync(`${basePath}/header.hbs`, 'utf8');
+const commit = readFileSync(`${basePath}/commit.hbs`, 'utf8');
+const footer = readFileSync(`${basePath}/footer.hbs`, 'utf8');
+const author = readFileSync(`${basePath}/author.hbs`, 'utf8');
+
+export const writerOpts: WriterOptions = {
+  transform: createTransform({}),
+  groupBy: 'type',
+  commitGroupsSort: 'title',
+  commitsSort: ['scope', 'subject'],
+  noteGroupsSort: 'title',
+  mainTemplate: template,
+  headerPartial: header,
+  commitPartial: commit.replace(/{{gitUserInfo}}/g, author),
+  footerPartial: footer,
+};