@kcconfigs/vitest 0.0.1 → 0.1.0-beta.0

package/src/constants.ts

@@ -0,0 +1,48 @@
+import type { UserConfig } from "./models";
+
+/** @internal */
+export const baseRootConfig: UserConfig = {
+	test: {
+		restoreMocks: true,
+		mockReset: true,
+		clearMocks: true,
+		unstubGlobals: true,
+		unstubEnvs: true,
+		environment: "node",
+		reporters: ["default", "html", "junit"],
+		outputFile: {
+			html: "reports/test-results/index.html",
+			junit: "reports/test-results/junit.xml",
+		},
+		coverage: {
+			enabled: true,
+			provider: "v8",
+			reporter: [["text"], ["lcovonly"], ["html", { subdir: "html" }]],
+			reportsDirectory: "reports/coverage",
+			thresholds: {
+				perFile: true,
+			},
+			include: ["**/*.{ts,tsx}"],
+			exclude: [
+				// Ignored hidden files
+				"**/[.]**",
+				// Ignored test files
+				"**/*{.,-}{test,spec}?(-d).?(c|m)[jt]s?(x)",
+				"**/__mocks__/**",
+				// Ignored dist files
+				"**/dist/**",
+				// Ignored typescript definition files
+				"**/*.d.{ts,cts,mts}",
+				// Ignored example files
+				"**/*.example.?(c|m)[jt]s?(x)",
+				// Ignored configuration files
+				"**/*.config.?(c|m)[jt]s?(x)",
+				// Ignored schema files
+				"**/*.schema.?(c|m)[jt]s?(x)",
+			],
+		},
+	},
+};
+
+/** @internal */
+export const baseProjectConfig: UserConfig = {};

package/src/index.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "vitest";
+import {
+	defineEmptyProject,
+	defineEmptyRoot,
+	defineProject,
+	defineProjectOrRoot,
+	defineRoot,
+	mergeConfig,
+	setupMocks,
+} from "./index";
+
+describe("Main Exports", () => {
+	test("should export defineRoot", () => {
+		expect(defineRoot).toBeDefined();
+		expect(typeof defineRoot).toBe("function");
+	});
+
+	test("should export defineProject", () => {
+		expect(defineProject).toBeDefined();
+		expect(typeof defineProject).toBe("function");
+	});
+
+	test("should export defineEmptyRoot", () => {
+		expect(defineEmptyRoot).toBeDefined();
+		expect(typeof defineEmptyRoot).toBe("function");
+	});
+
+	test("should export defineEmptyProject", () => {
+		expect(defineEmptyProject).toBeDefined();
+		expect(typeof defineEmptyProject).toBe("function");
+	});
+
+	test("should export defineProjectOrRoot", () => {
+		expect(defineProjectOrRoot).toBeDefined();
+		expect(typeof defineProjectOrRoot).toBe("function");
+	});
+
+	test("should export mergeConfig", () => {
+		expect(mergeConfig).toBeDefined();
+		expect(typeof mergeConfig).toBe("function");
+	});
+
+	test("should export setupMocks", () => {
+		expect(setupMocks).toBeDefined();
+		expect(typeof setupMocks).toBe("function");
+	});
+});

package/src/index.ts

@@ -0,0 +1,8 @@
+export type { AnyConfig, ProjectConfig, UserConfig } from "./models";
+export { defineEmptyProject } from "./utils/defineEmptyProject";
+export { defineEmptyRoot } from "./utils/defineEmptyRoot";
+export { defineProject } from "./utils/defineProject";
+export { defineProjectOrRoot } from "./utils/defineProjectOrRoot";
+export { defineRoot } from "./utils/defineRoot";
+export { mergeConfig } from "./utils/mergeConfig";
+export { setupMocks } from "./utils/setupMocks";

package/src/mockHelpers/fs.ts

@@ -0,0 +1 @@
+export { vol } from "memfs";

package/src/mockHelpers/index.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "vitest";
+import { vol } from "./index";
+
+describe("Mock Helpers", () => {
+	test("should export vol from memfs", () => {
+		expect(vol).toBeDefined();
+		expect(typeof vol).toBe("object");
+	});
+
+	test("vol should have fromJSON method", () => {
+		expect(vol.fromJSON).toBeDefined();
+		expect(typeof vol.fromJSON).toBe("function");
+	});
+
+	test("vol should have reset method", () => {
+		expect(vol.reset).toBeDefined();
+		expect(typeof vol.reset).toBe("function");
+	});
+
+	test("vol should have toJSON method", () => {
+		expect(vol.toJSON).toBeDefined();
+		expect(typeof vol.toJSON).toBe("function");
+	});
+});

package/src/mockHelpers/index.ts

@@ -0,0 +1 @@
+export * from "./fs";

package/src/models.test.ts

@@ -0,0 +1,39 @@
+/** biome-ignore-all lint/complexity/useLiteralKeys: Conflict with ts(4111) */
+
+import { describe, expect, test } from "vitest";
+import type { AnyConfig, ProjectConfig, UserConfig } from "./models";
+
+describe("Type Definitions", () => {
+	test("should export UserConfig type", () => {
+		const config: UserConfig = {
+			test: {
+				environment: "node",
+			},
+		};
+
+		expect(config).toBeDefined();
+	});
+
+	test("should export ProjectConfig type", () => {
+		const config: ProjectConfig = {
+			test: {
+				name: "test-project",
+			},
+		};
+
+		expect(config).toBeDefined();
+	});
+
+	test("should export AnyConfig type", () => {
+		const config: AnyConfig = {
+			anyKey: "anyValue",
+			nested: {
+				deep: true,
+			},
+		};
+
+		expect(config).toBeDefined();
+		expect(config["anyKey"]).toBe("anyValue");
+		expect(config["nested"]["deep"]).toBe(true);
+	});
+});

package/src/models.ts

@@ -0,0 +1,27 @@
+import type {
+	UserWorkspaceConfig as _ProjectConfig,
+	ViteUserConfig as _UserConfig,
+} from "vitest/config";
+
+/**
+ * Generic configuration type allowing any string keys and values.
+ * Used as a flexible type for configuration merging operations.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: Necessary for generic config type
+export type AnyConfig = Record<string, any>;
+
+/**
+ * Vitest user configuration type for root workspace setup.
+ * Extends Vite's user configuration with Vitest-specific test settings.
+ *
+ * @see https://vitest.dev/config/
+ */
+export type UserConfig = _UserConfig;
+
+/**
+ * Vitest project configuration type for workspace projects.
+ * Extends Vite's workspace config with project-specific test settings.
+ *
+ * @see https://vitest.dev/config/
+ */
+export type ProjectConfig = _ProjectConfig;

package/src/utils/defineEmptyProject.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test } from "vitest";
+import { defineEmptyProject } from "./defineEmptyProject";
+
+describe("defineEmptyProject", () => {
+	test("should return an empty configuration", () => {
+		const config = defineEmptyProject();
+
+		expect(config).toBeDefined();
+		expect(typeof config).toBe("object");
+	});
+
+	test("should not include base configuration", () => {
+		const config = defineEmptyProject();
+
+		// Should not have default values
+		expect(config.test?.environment).toBeUndefined();
+		expect(config.test?.restoreMocks).toBeUndefined();
+	});
+
+	test("should merge custom configuration", () => {
+		const config = defineEmptyProject({
+			test: {
+				name: "my-project",
+				environment: "jsdom",
+			},
+		});
+
+		expect(config.test?.name).toBe("my-project");
+		expect(config.test?.environment).toBe("jsdom");
+	});
+
+	test("should handle multiple configuration objects", () => {
+		const config = defineEmptyProject(
+			{
+				test: {
+					name: "project-1",
+				},
+			},
+			{
+				test: {
+					environment: "node",
+				},
+			},
+		);
+
+		expect(config.test?.name).toBe("project-1");
+		expect(config.test?.environment).toBe("node");
+	});
+
+	test("should handle undefined configuration", () => {
+		const config = defineEmptyProject(undefined);
+
+		expect(config).toBeDefined();
+		expect(config.test).toBeUndefined();
+	});
+
+	test("should allow project-specific configuration", () => {
+		const config = defineEmptyProject({
+			test: {
+				name: "test-package",
+				root: "./packages/test-package",
+				include: ["src/**/*.test.ts"],
+			},
+		});
+
+		expect(config.test?.name).toBe("test-package");
+		expect(config.test?.root).toBe("./packages/test-package");
+		expect(config.test?.include).toEqual(["src/**/*.test.ts"]);
+	});
+});

package/src/utils/defineEmptyProject.ts

@@ -0,0 +1,9 @@
+import { defineProject } from "vitest/config";
+import type { ProjectConfig } from "../models";
+import { mergeConfig } from "./mergeConfig";
+
+export const defineEmptyProject = (
+	...configs: Optional<ProjectConfig>[]
+): ProjectConfig => {
+	return defineProject(mergeConfig({}, ...configs));
+};

package/src/utils/defineEmptyRoot.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from "vitest";
+import { defineEmptyRoot } from "./defineEmptyRoot";
+
+describe("defineEmptyRoot", () => {
+	test("should return an empty configuration", () => {
+		const config = defineEmptyRoot();
+
+		expect(config).toBeDefined();
+		expect(typeof config).toBe("object");
+	});
+
+	test("should not include base root configuration", () => {
+		const config = defineEmptyRoot();
+
+		// Should not have default values from baseRootConfig
+		expect(config.test?.environment).toBeUndefined();
+		expect(config.test?.restoreMocks).toBeUndefined();
+	});
+
+	test("should merge custom configuration", () => {
+		const config = defineEmptyRoot({
+			test: {
+				environment: "jsdom",
+				globals: true,
+			},
+		});
+
+		expect(config.test?.environment).toBe("jsdom");
+		expect(config.test?.globals).toBe(true);
+	});
+
+	test("should handle multiple configuration objects", () => {
+		const config = defineEmptyRoot(
+			{
+				test: {
+					environment: "node",
+				},
+			},
+			{
+				test: {
+					globals: true,
+				},
+			},
+		);
+
+		expect(config.test?.environment).toBe("node");
+		expect(config.test?.globals).toBe(true);
+	});
+
+	test("should handle undefined configuration", () => {
+		const config = defineEmptyRoot(undefined);
+
+		expect(config).toBeDefined();
+		expect(config.test).toBeUndefined();
+	});
+
+	test("should handle null configuration", () => {
+		const config = defineEmptyRoot(null);
+
+		expect(config).toBeDefined();
+		expect(config.test).toBeUndefined();
+	});
+
+	test("should merge nested configurations", () => {
+		const config = defineEmptyRoot({
+			test: {
+				coverage: {
+					enabled: true,
+					provider: "v8",
+				},
+			},
+		});
+
+		expect(config.test?.coverage?.enabled).toBe(true);
+		expect(config.test?.coverage?.provider).toBe("v8");
+	});
+
+	test("should allow full custom configuration", () => {
+		const customConfig = {
+			test: {
+				name: "custom-test",
+				environment: "happy-dom",
+				reporters: ["json"],
+				coverage: {
+					enabled: false,
+				},
+			},
+		};
+
+		const config = defineEmptyRoot(customConfig);
+
+		expect(config.test?.name).toBe("custom-test");
+		expect(config.test?.environment).toBe("happy-dom");
+		expect(config.test?.reporters).toEqual(["json"]);
+		expect(config.test?.coverage?.enabled).toBe(false);
+	});
+});

package/src/utils/defineEmptyRoot.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "vitest/config";
+import type { UserConfig } from "../models";
+import { mergeConfig } from "./mergeConfig";
+
+export const defineEmptyRoot = (
+	...configs: Optional<UserConfig>[]
+): UserConfig => {
+	return defineConfig(mergeConfig({}, ...configs));
+};

package/src/utils/defineProject.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, test } from "vitest";
+import { defineProject } from "./defineProject";
+
+describe("defineProject", () => {
+	test("should return a configuration object", () => {
+		const config = defineProject();
+
+		expect(config).toBeDefined();
+		expect(typeof config).toBe("object");
+	});
+
+	test("should include base root configuration", () => {
+		const config = defineProject();
+
+		expect(config.test).toBeDefined();
+		expect(config.test?.environment).toBe("node");
+		expect(config.test?.restoreMocks).toBe(true);
+	});
+
+	test("should merge custom configuration", () => {
+		const config = defineProject({
+			test: {
+				name: "my-project",
+			},
+		});
+
+		expect(config.test?.name).toBe("my-project");
+	});
+
+	test("should preserve base configuration when merging", () => {
+		const config = defineProject({
+			test: {
+				name: "my-project",
+			},
+		});
+
+		expect(config.test?.restoreMocks).toBe(true);
+		expect(config.test?.environment).toBe("node");
+	});
+
+	test("should handle multiple configuration overrides", () => {
+		const config = defineProject(
+			{
+				test: {
+					name: "my-project",
+				},
+			},
+			{
+				test: {
+					environment: "jsdom",
+				},
+			},
+		);
+
+		expect(config.test?.name).toBe("my-project");
+		expect(config.test?.environment).toBe("jsdom");
+	});
+
+	test("should handle undefined configuration", () => {
+		const config = defineProject(undefined);
+
+		expect(config).toBeDefined();
+		expect(config.test?.environment).toBe("node");
+	});
+
+	test("should support root property for workspace project", () => {
+		const config = defineProject({
+			test: {
+				root: "./packages/my-package",
+			},
+		});
+
+		expect(config.test?.root).toBe("./packages/my-package");
+	});
+
+	test("should merge project-specific test configuration", () => {
+		const config = defineProject({
+			test: {
+				name: "test-package",
+				include: ["src/**/*.test.ts"],
+			},
+		});
+
+		expect(config.test?.name).toBe("test-package");
+		expect(config.test?.include).toEqual(["src/**/*.test.ts"]);
+	});
+});

package/src/utils/defineProject.ts

@@ -0,0 +1,18 @@
+import { baseProjectConfig, baseRootConfig } from "../constants";
+import type { ProjectConfig } from "../models";
+import { defineEmptyProject } from "./defineEmptyProject";
+
+/**
+ * Defines the root Vitest configuration for the workspace.
+ * Merges the base root configuration with any provided user configuration.
+ *
+ * @param config - Optional user-provided Vitest configuration overrides
+ * @returns The merged root Vitest configuration
+ *
+ * @includeExample
+ */
+export const defineProject = (
+	...config: Optional<ProjectConfig>[]
+): ProjectConfig => {
+	return defineEmptyProject(baseRootConfig, baseProjectConfig, ...config);
+};

package/src/utils/defineProjectOrRoot.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "vitest";
+import { defineProjectOrRoot } from "./defineProjectOrRoot";
+
+describe("defineProjectOrRoot", () => {
+	test("should return a configuration object", () => {
+		const config = defineProjectOrRoot();
+
+		expect(config).toBeDefined();
+		expect(typeof config).toBe("object");
+	});
+
+	test("should include base root configuration", () => {
+		const config = defineProjectOrRoot();
+
+		expect(config.test).toBeDefined();
+		expect(config.test?.environment).toBe("node");
+		expect(config.test?.restoreMocks).toBe(true);
+	});
+
+	test("should merge custom configuration", () => {
+		const config = defineProjectOrRoot({
+			test: {
+				name: "my-config",
+			},
+		});
+
+		expect(config.test?.name).toBe("my-config");
+	});
+
+	test("should preserve base configuration when merging", () => {
+		const config = defineProjectOrRoot({
+			test: {
+				name: "my-config",
+			},
+		});
+
+		expect(config.test?.restoreMocks).toBe(true);
+		expect(config.test?.environment).toBe("node");
+	});
+
+	test("should handle multiple configuration overrides", () => {
+		const config = defineProjectOrRoot(
+			{
+				test: {
+					environment: "jsdom",
+				},
+			},
+			{
+				test: {
+					globals: true,
+				},
+			},
+		);
+
+		expect(config.test?.environment).toBe("jsdom");
+		expect(config.test?.globals).toBe(true);
+	});
+
+	test("should work as root configuration", () => {
+		const config = defineProjectOrRoot({
+			test: {
+				projects: ["packages/**/vitest.config.ts"],
+			},
+		});
+
+		expect(config.test?.projects).toEqual(["packages/**/vitest.config.ts"]);
+		expect(config.test?.environment).toBe("node");
+	});
+
+	test("should work as project configuration", () => {
+		const config = defineProjectOrRoot({
+			test: {
+				name: "my-project",
+				root: "./packages/my-project",
+			},
+		});
+
+		expect(config.test?.name).toBe("my-project");
+		expect(config.test?.root).toBe("./packages/my-project");
+	});
+
+	test("should handle undefined configuration", () => {
+		const config = defineProjectOrRoot(undefined);
+
+		expect(config).toBeDefined();
+		expect(config.test?.environment).toBe("node");
+	});
+});

package/src/utils/defineProjectOrRoot.ts

@@ -0,0 +1,18 @@
+import { baseProjectConfig, baseRootConfig } from "../constants";
+import type { ProjectConfig, UserConfig } from "../models";
+import { defineEmptyRoot } from "./defineEmptyRoot";
+
+/**
+ * Defines the root Vitest configuration for the workspace.
+ * Merges the base root configuration with any provided user configuration.
+ *
+ * @param config - Optional user-provided Vitest configuration overrides
+ * @returns The merged root Vitest configuration
+ *
+ * @includeExample
+ */
+export const defineProjectOrRoot = (
+	...config: Optional<UserConfig>[]
+): ProjectConfig => {
+	return defineEmptyRoot(baseRootConfig, baseProjectConfig, ...config);
+};

package/src/utils/defineRoot.example.ts

@@ -0,0 +1,16 @@
+import { defineRoot } from "./defineRoot";
+
+// Example usages of defineRoot
+defineRoot();
+
+// Example with user configuration overrides
+defineRoot({
+	test: {
+		dir: "packages",
+		coverage: {
+			thresholds: {
+				"100": true,
+			},
+		},
+	},
+});