@kcconfigs/commitlint 0.0.1 → 0.1.0-beta.0

package/src/apis/types.ts

@@ -0,0 +1,103 @@
+export interface TypeEnum {
+	description?: string;
+	title?: string;
+	emoji?: string;
+}
+
+export type TypeObject = Record<string, TypeEnum>;
+
+export type TypeMode = "standard" | "minimal" | string[] | TypeObject;
+
+const STANDARD_TYPES = {
+	feat: {
+		description: "A new feature",
+		title: "Features",
+		emoji: "✨",
+	},
+	perf: {
+		description: "A code change that improves performance",
+		title: "Performance Improvements",
+		emoji: "🚀",
+	},
+	fix: {
+		description: "A bug fix",
+		title: "Bugfixes",
+		emoji: "🐛",
+	},
+	docs: {
+		description: "Documentation only changes",
+		title: "Documentation",
+		emoji: "📚",
+	},
+	test: {
+		description: "Adding missing tests or correcting existing tests",
+		title: "Tests",
+		emoji: "🚨",
+	},
+	style: {
+		description:
+			"Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)",
+		title: "Styles",
+		emoji: "💎",
+	},
+	build: {
+		description:
+			"Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)",
+		title: "Builds",
+		emoji: "🛠",
+	},
+	refactor: {
+		description: "A code change that neither fixes a bug nor adds a feature",
+		title: "Code Refactoring",
+		emoji: "📦",
+	},
+	ci: {
+		description:
+			"Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)",
+		title: "Continuous Integrations",
+		emoji: "⚙️",
+	},
+	chore: {
+		description: "Other changes that don't modify src or test files",
+		title: "Miscellaneous Chores",
+		emoji: "♻️",
+	},
+	revert: {
+		description: "Reverts a previous commit",
+		title: "Reverts",
+		emoji: "🗑",
+	},
+} satisfies TypeObject;
+
+/**
+ * Retrieves commit types based on the specified mode.
+ *
+ * Returns a predefined list of commit types for standard or kc modes,
+ * or a custom list if an array or object is provided.
+ *
+ * @param mode - The commit type mode: "standard", "kc", or a custom object
+ * @returns Map of type object
+ */
+export const getTypes = (mode: TypeMode): TypeObject => {
+	if (Array.isArray(mode)) {
+		return mode.reduce((acc, type) => {
+			acc[type] = {};
+			return acc;
+		}, {} as TypeObject);
+	}
+	if (typeof mode !== "string") {
+		return mode;
+	}
+
+	switch (mode) {
+		case "standard":
+			return STANDARD_TYPES;
+		case "minimal":
+			return {
+				feat: STANDARD_TYPES.feat,
+				perf: STANDARD_TYPES.perf,
+				fix: STANDARD_TYPES.fix,
+				chore: STANDARD_TYPES.chore,
+			};
+	}
+};

package/src/index.test.ts

@@ -0,0 +1,497 @@
+/** biome-ignore-all lint/style/noNonNullAssertion: testing known structures */
+
+import { cwd } from "node:process";
+import { vol } from "@kcconfigs/vitest/mocks";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { defineConfig, Severity } from ".";
+
+describe("Main API", () => {
+	afterEach(() => {
+		vol.reset();
+	});
+
+	describe("exports", () => {
+		test("should export Severity enum", () => {
+			expect(Severity).toBeDefined();
+			expect(Severity.Error).toBe(2);
+			expect(Severity.Warning).toBe(1);
+			expect(Severity.Disabled).toBe(0);
+		});
+	});
+
+	describe(defineConfig.name, () => {
+		beforeEach(() => {
+			vi.mocked(cwd).mockReturnValue("/mock/workspace");
+		});
+
+		test("should return config with default parameters", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config).toBeDefined();
+			expect(config.helpUrl).toBe("use 'pnpm commit' to create commit instead");
+
+			expect(config.rules).toBeDefined();
+			expect(config.prompt?.questions?.type).toBeDefined();
+			expect(config.prompt?.questions?.scope).toBeDefined();
+			expect(config.prompt?.questions?.subject).toBeDefined();
+			expect(config.prompt?.questions?.body).toBeDefined();
+		});
+
+		test("should configure type-enum rule with standard types", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config.rules?.["type-enum"]).toBeDefined();
+			const [severity, condition, types] = config.rules!["type-enum"] as [
+				number,
+				string,
+				string[],
+			];
+
+			expect(severity).toBe(Severity.Error);
+			expect(condition).toBe("always");
+			expect(types.sort()).toEqual(
+				[
+					"feat",
+					"perf",
+					"fix",
+					"docs",
+					"test",
+					"style",
+					"build",
+					"refactor",
+					"ci",
+					"chore",
+					"revert",
+				].sort(),
+			);
+		});
+
+		test("should configure type-enum rule with minimal types", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig({ types: "minimal" });
+
+			const [, , types] = config.rules!["type-enum"] as [
+				number,
+				string,
+				string[],
+			];
+
+			expect(types.sort()).toEqual(["feat", "perf", "fix", "chore"].sort());
+		});
+
+		test("should configure type-enum rule with custom types array", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig({
+				types: ["custom1", "custom2", "custom3"],
+			});
+
+			const [, , types] = config.rules!["type-enum"] as [
+				number,
+				string,
+				string[],
+			];
+
+			expect(types.sort()).toEqual(["custom1", "custom2", "custom3"].sort());
+		});
+
+		test("should configure type-enum rule with custom types object", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const customTypes = {
+				type1: { description: "Type 1", emoji: "🎨" },
+				type2: { description: "Type 2" },
+			};
+
+			const config = await defineConfig({ types: customTypes });
+
+			const [, , types] = config.rules!["type-enum"] as [
+				number,
+				string,
+				string[],
+			];
+
+			expect(types.sort()).toEqual(["type1", "type2"].sort());
+		});
+
+		test("should configure scope-enum with auto-detected scopes", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - 'packages/*'",
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+					"./packages/pkg-b/package.json": JSON.stringify({
+						name: "@scope/pkg-b",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config.rules?.["scope-enum"]).toBeDefined();
+
+			// Test scope-enum rule function
+			const scopeRule = config.rules!["scope-enum"] as () => [
+				number,
+				string,
+				string[],
+			];
+			const [severity, condition, scopes] = scopeRule();
+
+			expect(severity).toBe(Severity.Error);
+			expect(condition).toBe("always");
+			expect(scopes.sort()).toEqual(["scope/pkg-a", "scope/pkg-b"].sort());
+		});
+
+		test("should configure scope-enum with custom scopes", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig({
+				autoScopes: false,
+				scopes: ["custom1", "custom2"],
+			});
+
+			const scopeRule = config.rules!["scope-enum"] as () => [
+				number,
+				string,
+				string[],
+			];
+			const [, , scopes] = scopeRule();
+
+			expect(scopes.sort()).toEqual(["custom1", "custom2"].sort());
+		});
+
+		test("should merge auto-detected and custom scopes", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - 'packages/*'",
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig({
+				autoScopes: true,
+				scopes: ["custom1", "custom2"],
+			});
+
+			const scopeRule = config.rules!["scope-enum"] as () => [
+				number,
+				string,
+				string[],
+			];
+			const [, , scopes] = scopeRule();
+
+			expect(scopes.sort()).toEqual(
+				["custom1", "custom2", "scope/pkg-a"].sort(),
+			);
+		});
+
+		test("should use default scopes when autoScopes is false and no custom scopes", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig({ autoScopes: false });
+
+			const scopeRule = config.rules!["scope-enum"] as () => [
+				number,
+				string,
+				string[],
+			];
+			const [, , scopes] = scopeRule();
+
+			expect(scopes.sort()).toEqual(
+				["core", "config", "script", "deps", "deps-dev"].sort(),
+			);
+		});
+
+		test("should configure subject-max-length rule", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config.rules?.["subject-max-length"]).toEqual([
+				Severity.Warning,
+				"always",
+				80,
+			]);
+		});
+
+		test("should configure body-max-line-length rule", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config.rules?.["body-max-line-length"]).toEqual([
+				Severity.Warning,
+				"always",
+				300,
+			]);
+		});
+
+		test("should configure prompt with type enum", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config.prompt).toBeDefined();
+			expect(config.prompt?.questions).toBeDefined();
+			expect(config.prompt?.questions?.type).toBeDefined();
+			expect(config.prompt?.questions?.type?.enum).toBeDefined();
+
+			const typeEnum = config.prompt!.questions!.type!.enum;
+			expect(typeEnum).toBeDefined();
+			if (typeEnum) {
+				expect(Object.keys(typeEnum).sort()).toEqual(
+					[
+						"feat",
+						"perf",
+						"fix",
+						"docs",
+						"test",
+						"style",
+						"build",
+						"refactor",
+						"ci",
+						"chore",
+						"revert",
+					].sort(),
+				);
+			}
+		});
+
+		test("should configure prompt with scope enum", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - 'packages/*'",
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config.prompt?.questions?.scope).toBeDefined();
+			expect(config.prompt?.questions?.scope?.enum).toBeDefined();
+
+			const scopeEnum = config.prompt!.questions!.scope!.enum;
+			expect(scopeEnum).toBeDefined();
+			if (scopeEnum) {
+				expect(Object.keys(scopeEnum).sort()).toEqual(["scope/pkg-a"].sort());
+			}
+		});
+
+		test("should disable multiple scopes in prompt settings", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config.prompt?.settings).toBeDefined();
+			expect(config.prompt?.settings?.enableMultipleScopes).toBe(false);
+		});
+
+		test("should preserve other rules from config-conventional", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			// Rules from @commitlint/config-conventional should be preserved
+			expect(config.rules).toBeDefined();
+			expect(Object.keys(config.rules!).length).toBeGreaterThan(4);
+		});
+
+		test("should preserve other prompt questions from config-conventional", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config.prompt?.questions).toBeDefined();
+			// Should have type and scope plus other questions
+			expect(Object.keys(config.prompt!.questions!).length).toBeGreaterThan(2);
+		});
+
+		test("should work with empty workspace (npm detection)", async () => {
+			vol.fromJSON(
+				{
+					"./package.json": JSON.stringify({
+						name: "test-workspace",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			expect(config).toBeDefined();
+			expect(config.rules?.["type-enum"]).toBeDefined();
+			expect(config.rules?.["scope-enum"]).toBeDefined();
+		});
+
+		test("should work with bun workspace", async () => {
+			vol.fromJSON(
+				{
+					"./bun.lock": "",
+					"./package.json": JSON.stringify({
+						name: "bun-workspace",
+						workspaces: ["packages/*"],
+					}),
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig();
+
+			const scopeRule = config.rules!["scope-enum"] as () => [
+				number,
+				string,
+				string[],
+			];
+			const [, , scopes] = scopeRule();
+
+			expect(scopes).toContain("scope/pkg-a");
+		});
+
+		test("should handle all parameters together", async () => {
+			vol.fromJSON(
+				{
+					"./pnpm-workspace.yaml": "packages:\n  - 'packages/*'",
+					"./packages/pkg-a/package.json": JSON.stringify({
+						name: "@scope/pkg-a",
+					}),
+				},
+				cwd(),
+			);
+
+			const config = await defineConfig({
+				types: "minimal",
+				autoScopes: true,
+				scopes: ["custom"],
+			});
+
+			// Check types
+			const [, , types] = config.rules!["type-enum"] as [
+				number,
+				string,
+				string[],
+			];
+			expect(types.sort()).toEqual(["feat", "perf", "fix", "chore"].sort());
+
+			// Check scopes
+			const scopeRule = config.rules!["scope-enum"] as () => [
+				number,
+				string,
+				string[],
+			];
+			const [, , scopes] = scopeRule();
+			expect(scopes.sort()).toEqual(["custom", "scope/pkg-a"].sort());
+		});
+	});
+});

package/src/index.ts

@@ -0,0 +1,82 @@
+import {
+	RuleConfigSeverity as Severity,
+	type UserConfig,
+} from "@commitlint/types";
+
+import { getScopes } from "./apis/scopes";
+import { getTypes, type TypeMode } from "./apis/types";
+
+export interface DefineConfigParams {
+	/**
+	 * Commit types configuration
+	 * - `"standard"`: Use standard conventional commit types
+	 * - `string[]`: Use custom types
+	 * @default "standard"
+	 */
+	types?: TypeMode;
+	/**
+	 * Automatically gather scopes from pnpm workspaces
+	 * @default true
+	 */
+	autoScopes?: boolean;
+	/**
+	 * Provide additional scopes; or override if `autoScopes` is false
+	 */
+	scopes?: string[];
+}
+
+/**
+ * Defines a commitlint configuration with automatic workspace scope detection and customizable commit types.
+ *
+ * @param params - Configuration options
+ * @returns A commitlint configuration object
+ */
+export const defineConfig = async (
+	params?: DefineConfigParams,
+): Promise<UserConfig> => {
+	const {
+		default: {
+			parserPreset,
+			prompt: {
+				questions: { type, scope, ...questions },
+				...prompt
+			},
+			rules,
+		},
+	} = await import("@commitlint/config-conventional");
+
+	const types = getTypes(params?.types ?? "standard");
+	const scopes = await getScopes(params?.autoScopes ?? true, params?.scopes);
+
+	return {
+		helpUrl: "use 'pnpm commit' to create commit instead",
+		parserPreset,
+		rules: {
+			...rules,
+			"type-enum": [Severity.Error, "always", Object.keys(types)],
+			"scope-enum": () => [Severity.Error, "always", scopes],
+			"subject-max-length": [Severity.Warning, "always", 80],
+			"body-max-line-length": [Severity.Warning, "always", 300],
+		},
+		prompt: {
+			...prompt,
+			questions: {
+				...questions,
+				type: {
+					...type,
+					enum: types,
+				},
+				scope: {
+					...scope,
+					enum: Object.fromEntries(scopes.map((s) => [s, {}])),
+				},
+			},
+			settings: {
+				enableMultipleScopes: false,
+			},
+		},
+	};
+};
+
+export { Severity };
+export type { UserConfig };