commitlint-config-spellbookx 0.11.0 → 0.12.0

package/.turbo/turbo-build.log

@@ -1,7 +1,19 @@
-
-> commitlint-config-spellbookx@0.11.0 build /home/runner/work/spellbookx/spellbookx/packages/commitlint-config-spellbookx
-> rolldown -c && tsc
-
-[log] <DIR>/index.js  chunk │ size: 272.64 kB
-[log]
-[success] rolldown v1.0.0-rc.5 Finished in 51.92 ms
+
+> commitlint-config-spellbookx@0.12.0 build /home/dcdavidev/spellbookx/packages/commitlint-config-spellbookx
+> rolldown -c && tsc
+
+<DIR>/lib/get-workspaces-raw-path.js       chunk │ size:   0.12 kB
+<DIR>/lib/get-scopes.js                    chunk │ size:   0.13 kB
+<DIR>/constants/commit-types.js            chunk │ size:   0.39 kB
+<DIR>/lib/index.js                         chunk │ size:   0.40 kB
+<DIR>/lib/package-json.js                  chunk │ size:   0.50 kB
+<DIR>/rules.js                             chunk │ size:   0.66 kB
+<DIR>/lib/find-git-root.js                 chunk │ size:   0.80 kB
+<DIR>/index.js                             chunk │ size:   1.03 kB
+<DIR>/lib/get-scope-description.js         chunk │ size:   1.05 kB
+<DIR>/scopes.js                            chunk │ size:   1.10 kB
+<DIR>/prompt.js                            chunk │ size:   2.59 kB
+<DIR>/get-workspaces-raw-path-Cg196xaD.js  chunk │ size:  80.88 kB
+<DIR>/get-scopes-D9bIfVqN.js               chunk │ size: 188.65 kB
+
+✔ rolldown v1.0.0-rc.5 Finished in 89.57 ms

package/.turbo/turbo-test.log

@@ -0,0 +1,59 @@
+
+> commitlint-config-spellbookx@0.11.1 test /home/dcdavidev/spellbookx/packages/commitlint-config-spellbookx
+> vitest run
+
+[?25l
+ RUN  v5.0.5 /home/dcdavidev/spellbookx/packages/commitlint-config-spellbookx
+
+[?2026h
+ ❯ __tests__/index.test.ts [queued]
+
+ Test Files 0 passed (4)
+      Tests 0 passed (0)
+   Start at 16:06:47
+   Duration 100ms
+[?2026l[?2026h
+ ❯ __tests__/index.test.ts [queued]
+ ❯ __tests__/lint.test.ts [queued]
+ ❯ __tests__/workspaces.test.ts [queued]
+
+ Test Files 0 passed (4)
+      Tests 0 passed (0)
+   Start at 16:06:47
+   Duration 301ms
+[?2026l[?2026h
+ ❯ __tests__/index.test.ts 1/3
+ ❯ __tests__/lint.test.ts [queued]
+ ❯ __tests__/scopes.test.ts [queued]
+ ❯ __tests__/workspaces.test.ts [queued]
+
+ Test Files 0 passed (4)
+      Tests 1 passed (3)
+   Start at 16:06:47
+   Duration 402ms
+[?2026l[?2026h ✓ __tests__/index.test.ts (3 tests) 15ms
+ ✓ __tests__/workspaces.test.ts (5 tests) 46ms
+
+ ❯ __tests__/lint.test.ts [queued]
+ ❯ __tests__/scopes.test.ts 0/4
+
+ Test Files 2 passed (4)
+      Tests 8 passed (12)
+   Start at 16:06:47
+   Duration 603ms
+[?2026l[?2026h ✓ __tests__/scopes.test.ts (4 tests) 20ms
+
+ ❯ __tests__/lint.test.ts 0/7
+
+ Test Files 3 passed (4)
+      Tests 12 passed (19)
+   Start at 16:06:47
+   Duration 904ms
+[?2026l[?2026h ✓ __tests__/lint.test.ts (7 tests) 24ms
+
+ Test Files  4 passed (4)
+      Tests  19 passed (19)
+   Start at  16:06:47
+   Duration  1.02s (import 81%, transform 9%, tests 7%, worker 3%)
+
+[?2026l[?2026h[?2026l[?25h

package/README.md

@@ -1,63 +1,234 @@
 # commitlint-config-spellbookx
 
-Shared [Commitlint](https://commitlint.js.org/) configuration for the Spellbookx project. This package ensures that all commits adhere to the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.
+A modern, highly modular, and opinionated [Commitlint](https://commitlint.js.org/) configuration for the Spellbookx ecosystem. It enforces the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification, automatically discovers monorepo package scopes, and provides an interactive [cz-git](https://cz-git.qbenben.com/) Commitizen prompt with emojis.
 
-## Description
+---
 
-This package provides a base commitlint configuration that:
+## Features
 
-- Extends the widely-used `@commitlint/config-conventional`.
-- Dynamically generates commit scopes based on the packages present in the `@spellbookx` monorepo.
-- Includes pre-defined commit types with emojis for better readability.
-- Offers a customized `commitizen` prompt for an enhanced commit experience.
+| Feature                       | Description                                                                                                                               |
+| :---------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- |
+| **Conventional Commits**      | Extends `@commitlint/config-conventional` with strict, opinionated rules (72-char headers, 100-char bodies/footers, no trailing periods). |
+| **Dynamic Monorepo Scopes**   | Automatically discovers workspace packages from `pnpm-workspace.yaml`, `package.json`, and `lerna.json`.                                  |
+| **Standard Special Scopes**   | Built-in support for `workspace` (root/infra changes) and `release` (versioning commits).                                                 |
+| **Interactive cz-git Prompt** | Out-of-the-box support for `commitizen` with rich emojis, descriptions, and multi-scope selection.                                        |
+| **Modular Architecture**      | Import individual building blocks (`rules`, `prompt`, `scopes`, `COMMIT_TYPES`) or atomic functions (`lib/`).                             |
 
-## Why use this?
+---
 
-Using this package ensures consistent and readable commit messages across the entire project. This helps in:
+## Supported Commit Types
 
-- Automatically generating changelogs.
-- Simplifying the release process.
-- Improving the readability of the project's history.
+| Type           | Emoji | Title                   | Description                                                                       |
+| :------------- | :---: | :---------------------- | :-------------------------------------------------------------------------------- |
+| **`feat`**     |  ✨   | Features                | A new feature for the user or codebase                                            |
+| **`fix`**      |  🐛   | Bug Fixes               | A bug fix                                                                         |
+| **`docs`**     |  📚   | Documentation           | Documentation only changes                                                        |
+| **`style`**    |  💎   | Styles                  | Changes that do not affect the meaning of the code (whitespace, formatting, etc.) |
+| **`refactor`** |  📦   | Code Refactoring        | A code change that neither fixes a bug nor adds a feature                         |
+| **`perf`**     |  🚀   | Performance             | A code change that improves performance                                           |
+| **`test`**     |  🚨   | Tests                   | Adding missing tests or correcting existing tests                                 |
+| **`build`**    |   🛠   | Builds                  | Changes that affect the build system or external dependencies                     |
+| **`ci`**       |  ⚙️   | Continuous Integrations | Changes to CI configuration files and scripts                                     |
+| **`chore`**    |  ♻️   | Chores                  | Other changes that don't modify src or test files                                 |
+| **`revert`**   |   🗑   | Reverts                 | Reverts a previous commit                                                         |
 
-## Installation
+---
 
-Install the package using your favorite package manager:
+## Installation
 
-**npm**
+Install the package and commitlint using **npm**:
 
 ```bash
 npm install --save-dev commitlint-config-spellbookx @commitlint/cli
 ```
 
-**pnpm**
+---
 
-```bash
-pnpm add -D commitlint-config-spellbookx @commitlint/cli
+## Usage
+
+Commitlint loads configuration from standard config files in your repository root. You can use this package in multiple ways depending on your project needs:
+
+### 1. Default Export (Recommended)
+
+The simplest way to use this preset:
+
+```javascript
+// commitlint.config.mjs
+export { default } from 'commitlint-config-spellbookx';
 ```
 
-**yarn**
+### 2. Customizing Rules
 
-```bash
-yarn add -D commitlint-config-spellbookx @commitlint/cli
+Extend and customize specific commitlint rules while keeping the shared defaults:
+
+```javascript
+// commitlint.config.mjs
+import { config, rules } from 'commitlint-config-spellbookx';
+
+export default {
+  ...config,
+  rules: {
+    ...rules,
+    'header-max-length': [2, 'always', 100],
+  },
+};
 ```
 
-**bun**
+### 3. Adding Custom Scopes
 
-```bash
-bun add -d commitlint-config-spellbookx @commitlint/cli
+You can extend the dynamically discovered monorepo scopes with custom scopes:
+
+```javascript
+// commitlint.config.mjs
+import { config, rules, scopesArray } from 'commitlint-config-spellbookx';
+
+export default {
+  ...config,
+  rules: {
+    ...rules,
+    'scope-enum': [2, 'always', [...scopesArray, 'custom-scope', 'analytics']],
+  },
+};
 ```
 
-## Usage
+### 4. Fully Modular Building Blocks
+
+Assemble your configuration from modular pieces:
+
+```javascript
+// commitlint.config.mjs
+import {
+  rules,
+  prompt,
+  scopesArray,
+  scopesEnum,
+  COMMIT_TYPES,
+} from 'commitlint-config-spellbookx';
+
+export default {
+  extends: ['@commitlint/config-conventional'],
+  parserPreset: 'conventional-changelog-conventionalcommits',
+  rules,
+  prompt,
+};
+```
+
+Available building blocks:
+
+- `config`: Complete, ready-to-use commitlint configuration object.
+- `rules`: Strict Conventional Commit rules (`type-enum`, `scope-enum`, `header-max-length`, etc.).
+- `prompt`: Commitizen / `cz-git` interactive questionnaire configuration with emojis and multi-scope support.
+- `scopesArray`: Array of discovered workspace package names plus `'workspace'` and `'release'`.
+- `scopesEnum`: Record of scopes with human-readable descriptions for interactive CLI prompts.
+- `COMMIT_TYPES`: Array of all 11 allowed commit type strings.
+- `SCOPE_WORKSPACE`: Constant `'workspace'`.
+- `SCOPE_RELEASE`: Constant `'release'`.
+
+### 5. Atomic Utility Functions (`lib`)
+
+Every helper and utility function is implemented atomically under `lib/` and can be imported either from the package root or from `commitlint-config-spellbookx/lib`:
+
+```javascript
+import {
+  findGitRoot,
+  getScopes,
+  getScopeDescription,
+  getWorkspacesRawPath,
+} from 'commitlint-config-spellbookx/lib';
+```
+
+- `getScopes(cwd?)`: Scans the monorepo configuration files and returns all workspace package names.
+- `findGitRoot(startDir?)`: Traverses upwards to locate the root of the current git repository.
+- `getScopeDescription(scope)`: Generates a human-friendly description string for a given scope identifier.
+- `getWorkspacesRawPath(configPath, parser, property?)`: Parses JSON or YAML configuration files to extract workspace glob patterns.
+
+---
+
+## Configuration File Formats
+
+According to the [Commitlint Configuration Documentation](https://commitlint.js.org/#/reference-configuration), you can define your configuration in any of the following formats:
+
+### In `commitlint.config.mjs` (ES Modules)
+
+```javascript
+export { default } from 'commitlint-config-spellbookx';
+```
 
-To use this configuration, create a `commitlint.config.mjs` file in your project's root and extend this package:
+### In `commitlint.config.cjs` (CommonJS)
 
 ```javascript
+module.exports = require('commitlint-config-spellbookx').default;
+```
+
+### In `commitlint.config.ts` (TypeScript)
+
+```typescript
+import type { UserConfig } from '@commitlint/types';
 import config from 'commitlint-config-spellbookx';
 
-export default config;
+const userConfig: UserConfig = {
+  ...config,
+};
+
+export default userConfig;
+```
+
+### In `.commitlintrc.json`
+
+```json
+{
+  "extends": ["commitlint-config-spellbookx"]
+}
+```
+
+### In `.commitlintrc.yml`
+
+```yaml
+extends:
+  - commitlint-config-spellbookx
 ```
 
-For an interactive commit experience, you can use `commitizen` with `cz-git`. Update your `package.json` with the following configuration:
+### In `package.json`
+
+```json
+{
+  "name": "my-project",
+  "commitlint": {
+    "extends": ["commitlint-config-spellbookx"]
+  }
+}
+```
+
+---
+
+## Git Hooks Integration
+
+To enforce commit message conventions automatically before commits are finalized, configure a git hook manager:
+
+### Using Lefthook
+
+Add a `commit-msg` hook in your `lefthook.yml`:
+
+```yaml
+commit-msg:
+  commands:
+    commitlint:
+      run: pnpm exec commitlint --edit {1}
+```
+
+### Using Husky
+
+Add a `commit-msg` hook with Husky:
+
+```bash
+npx husky add .husky/commit-msg 'npx --no -- commitlint --edit "$1"'
+```
+
+---
+
+## Interactive Commits with Commitizen
+
+For a guided, interactive commit experience with `cz-git`, configure Commitizen in your `package.json`:
 
 ```json
 {
@@ -72,10 +243,20 @@ For an interactive commit experience, you can use `commitizen` with `cz-git`. Up
 }
 ```
 
+Then run:
+
+```bash
+npm run commit
+```
+
+---
+
 ## License
 
 This project is licensed under the MIT License.
 
-**Copyright (c) 2026 Davide Di Criscito**
+- **Author & Creator**: [Davide Di Criscito](https://github.com/dcdavidev)
+- **GitHub Organization**: [Spellbookx](https://github.com/spellbookx)
+- **Copyright**: © 2026 Davide Di Criscito and [Spellbookx](https://github.com/spellbookx) contributors.
 
-For the full details, see the [LICENSE](LICENSE) file.
+For full details, see the [LICENSE](LICENSE) file.

package/__tests__/index.test.ts

@@ -0,0 +1,47 @@
+/**
+ * @file index.test.ts
+ * Tests verifying the main configuration export and metadata of commitlint-config-spellbookx.
+ */
+
+import { describe, expect, test } from 'vitest';
+
+import defaultExport, {
+  COMMIT_TYPES,
+  config,
+  prompt,
+  rules,
+  SCOPE_RELEASE,
+  SCOPE_WORKSPACE,
+  scopesArray,
+  scopesEnum,
+} from '../src/index.js';
+import { packageJson } from '../src/lib/package-json.js';
+
+describe('commitlint-config-spellbookx entrypoint', () => {
+  test('should export valid configuration object', () => {
+    expect(defaultExport).toBe(config);
+    expect(typeof config).toBe('object');
+    expect(Array.isArray(config.extends)).toBe(true);
+    expect(config.extends).toContain('@commitlint/config-conventional');
+    expect(config.parserPreset).toBe(
+      'conventional-changelog-conventionalcommits'
+    );
+    expect(config.rules).toBe(rules);
+    expect(config.prompt).toBe(prompt);
+  });
+
+  test('should contain valid package metadata in helpers', () => {
+    expect(packageJson.name).toBe('commitlint-config-spellbookx');
+    expect(packageJson.version).toBeDefined();
+  });
+
+  test('should export conventional commit types and scope constants', () => {
+    expect(Array.isArray(COMMIT_TYPES)).toBe(true);
+    expect(COMMIT_TYPES).toContain('feat');
+    expect(COMMIT_TYPES).toContain('fix');
+    expect(SCOPE_WORKSPACE).toBe('workspace');
+    expect(SCOPE_RELEASE).toBe('release');
+    expect(Array.isArray(scopesArray)).toBe(true);
+    expect(typeof scopesEnum).toBe('object');
+  });
+});

package/__tests__/lint.test.ts

@@ -0,0 +1,65 @@
+/**
+ * @file lint.test.ts
+ * Tests verifying conventional commit validation rules using `@commitlint/lint`.
+ */
+
+import { describe, expect, test } from 'vitest';
+
+import lint from '@commitlint/lint';
+
+import config from '../src/index.js';
+
+describe('commitlint validation rules', () => {
+  test('should validate valid conventional commits', async () => {
+    const result = await lint(
+      'feat(eslint-plugin-spellbookx): add new awesome feature',
+      config.rules
+    );
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  test('should validate valid workspace scope commits', async () => {
+    const result = await lint(
+      'chore(workspace): update root configs',
+      config.rules
+    );
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  test('should validate valid release scope commits', async () => {
+    const result = await lint('feat(release): publish v1.0.0', config.rules);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  test('should fail when type is invalid', async () => {
+    const result = await lint('unknown(workspace): some change', config.rules);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.name === 'type-enum')).toBe(true);
+  });
+
+  test('should fail when scope is not in scope-enum', async () => {
+    const result = await lint(
+      'feat(nonexistent-scope): some change',
+      config.rules
+    );
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.name === 'scope-enum')).toBe(true);
+  });
+
+  test('should fail when subject has a trailing period', async () => {
+    const result = await lint('fix(workspace): fix config typo.', config.rules);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.name === 'subject-full-stop')).toBe(
+      true
+    );
+  });
+
+  test('should fail when subject is empty', async () => {
+    const result = await lint('fix(workspace): ', config.rules);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.name === 'subject-empty')).toBe(true);
+  });
+});

package/__tests__/scopes.test.ts

@@ -0,0 +1,55 @@
+/**
+ * @file scopes.test.ts
+ * Tests for scope identifiers, scope descriptions, and scopes enumeration.
+ */
+
+import { describe, expect, test } from 'vitest';
+
+import {
+  getScopeDescription,
+  SCOPE_RELEASE,
+  SCOPE_WORKSPACE,
+  scopesArray,
+  scopesEnum,
+} from '../src/index.js';
+
+describe('commitlint scopes', () => {
+  test('constants should be properly defined', () => {
+    expect(SCOPE_WORKSPACE).toBe('workspace');
+    expect(SCOPE_RELEASE).toBe('release');
+  });
+
+  test('scopesArray should contain workspace, release, and monorepo packages', () => {
+    expect(Array.isArray(scopesArray)).toBe(true);
+    expect(scopesArray).toContain(SCOPE_WORKSPACE);
+    expect(scopesArray).toContain(SCOPE_RELEASE);
+    expect(scopesArray).toContain('commitlint-config-spellbookx');
+    expect(scopesArray).toContain('cspell-config-spellbookx');
+    expect(scopesArray).toContain('eslint-plugin-spellbookx');
+    expect(scopesArray).toContain('prettier-config-spellbookx');
+    expect(scopesArray).toContain('@spellbookx/recipes');
+  });
+
+  test('getScopeDescription should return user-friendly descriptions', () => {
+    expect(getScopeDescription(SCOPE_WORKSPACE)).toBe(
+      'workspace scope - root files such as config files, root package.json, etc'
+    );
+    expect(getScopeDescription(SCOPE_RELEASE)).toBe(
+      'Special scope for release commits'
+    );
+    expect(getScopeDescription('custom-pkg')).toBe('custom-pkg scope');
+  });
+
+  test('scopesEnum should populate descriptions for all scopes', () => {
+    expect(scopesEnum[SCOPE_WORKSPACE]?.description).toBe(
+      getScopeDescription(SCOPE_WORKSPACE)
+    );
+    expect(scopesEnum[SCOPE_RELEASE]?.description).toBe(
+      getScopeDescription(SCOPE_RELEASE)
+    );
+    for (const scope of scopesArray) {
+      expect(scopesEnum[scope]).toBeDefined();
+      expect(scopesEnum[scope]?.description).toBe(getScopeDescription(scope));
+    }
+  });
+});

package/__tests__/workspaces.test.ts

@@ -0,0 +1,76 @@
+/**
+ * @file workspaces.test.ts
+ * Tests for git root discovery, workspace config parsing, and scopes gathering.
+ */
+
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+
+import {
+  findGitRoot,
+  getScopes,
+  getWorkspacesRawPath,
+} from '../src/lib/index.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const testDir = path.resolve(__dirname, '../temp-test-commitlint');
+
+describe('workspace discovery and parsing', () => {
+  beforeAll(() => {
+    if (existsSync(testDir)) rmSync(testDir, { recursive: true, force: true });
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    if (existsSync(testDir)) rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test('findGitRoot should locate git root directory', () => {
+    const root = findGitRoot(__dirname);
+    expect(root).not.toBeNull();
+    expect(existsSync(path.join(root!, '.git'))).toBe(true);
+  });
+
+  test('should parse workspaces from JSON correctly', () => {
+    const jsonPath = path.join(testDir, 'package.json');
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(
+      jsonPath,
+      JSON.stringify({ workspaces: ['packages/*', 'apps/*'] })
+    );
+
+    const workspaces = getWorkspacesRawPath(jsonPath, 'json', 'workspaces');
+    expect(workspaces).toEqual(['packages/*', 'apps/*']);
+  });
+
+  test('should parse packages from YAML correctly', () => {
+    const yamlPath = path.join(testDir, 'pnpm-workspace.yaml');
+    mkdirSync(testDir, { recursive: true });
+    writeFileSync(yamlPath, 'packages:\n  - "packages/*"\n  - "plugins/*"\n');
+
+    const packages = getWorkspacesRawPath(yamlPath, 'yaml', 'packages');
+    expect(packages).toEqual(['packages/*', 'plugins/*']);
+  });
+
+  test('should throw on unsupported parser', () => {
+    const filePath = path.join(testDir, 'config.txt');
+    writeFileSync(filePath, 'some text');
+    expect(() => {
+      // @ts-expect-error Testing invalid parser
+      getWorkspacesRawPath(filePath, 'xml');
+    }).toThrow(/Unsupported parser type/);
+  });
+
+  test('should return scopes including workspace and monorepo packages', () => {
+    const scopes = getScopes();
+    expect(Array.isArray(scopes)).toBe(true);
+    expect(scopes).toContain('commitlint-config-spellbookx');
+    expect(scopes).toContain('cspell-config-spellbookx');
+    expect(scopes).toContain('eslint-plugin-spellbookx');
+    expect(scopes).toContain('prettier-config-spellbookx');
+    expect(scopes).toContain('@spellbookx/recipes');
+  });
+});

package/dist/constants/commit-types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @file commit-types.ts
+ * Standard Conventional Commit types supported by Spellbookx.
+ */
+/**
+ * List of allowed commit types based on the Conventional Commits specification.
+ */
+export declare const COMMIT_TYPES: readonly ["feat", "fix", "docs", "style", "refactor", "perf", "test", "chore", "ci", "build", "revert"];
+/**
+ * Valid Conventional Commit type string.
+ */
+export type CommitType = (typeof COMMIT_TYPES)[number];
+//# sourceMappingURL=commit-types.d.ts.map

package/dist/constants/commit-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-types.d.ts","sourceRoot":"","sources":["../../src/constants/commit-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY,yGAYf,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/constants/commit-types.js

@@ -0,0 +1,24 @@
+//#region src/constants/commit-types.ts
+/**
+* @file commit-types.ts
+* Standard Conventional Commit types supported by Spellbookx.
+*/
+/**
+* List of allowed commit types based on the Conventional Commits specification.
+*/
+const COMMIT_TYPES = [
+	"feat",
+	"fix",
+	"docs",
+	"style",
+	"refactor",
+	"perf",
+	"test",
+	"chore",
+	"ci",
+	"build",
+	"revert"
+];
+
+//#endregion
+export { COMMIT_TYPES };