ag-toolkit 0.1.4 → 0.3.0

package/dist/tests/config.test.js

@@ -0,0 +1,234 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { findLocalConfigPath, findUp, getGlobalConfigPath, loadConfig, loadLocalConfig, readConfigFile, resetGlobalConfig, writeConfig, writeGlobalConfig, writeLocalConfig, } from "../lib/config.js";
+describe("config", () => {
+    let testDir;
+    beforeEach(async () => {
+        testDir = await fs.mkdtemp(join(tmpdir(), "config-test-"));
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+    describe("findUp", () => {
+        test("should find file in current directory", async () => {
+            const testFile = "test-config.json";
+            await fs.writeFile(join(testDir, testFile), "{}");
+            const result = await findUp(testFile, testDir);
+            expect(result).toBe(join(testDir, testFile));
+        });
+        test("should find file in parent directory", async () => {
+            const testFile = "test-config.json";
+            const subDir = join(testDir, "subdir");
+            await fs.mkdir(subDir);
+            await fs.writeFile(join(testDir, testFile), "{}");
+            const result = await findUp(testFile, subDir);
+            expect(result).toBe(join(testDir, testFile));
+        });
+        test("should return null when file is not found", async () => {
+            const subDir = join(process.cwd(), "src", "tests");
+            const result = await findUp("nonexistent-file-that-should-not-exist.json", subDir);
+            expect(result).toBeNull();
+        });
+        test("should find file in nested parent directories", async () => {
+            const testFile = "test-config.json";
+            const deepDir = join(testDir, "a", "b", "c");
+            await fs.mkdir(deepDir, { recursive: true });
+            await fs.writeFile(join(testDir, testFile), "{}");
+            const result = await findUp(testFile, deepDir);
+            expect(result).toBe(join(testDir, testFile));
+        });
+    });
+    describe("readConfigFile", () => {
+        test("should read and parse valid JSON config file", async () => {
+            const configPath = join(testDir, "config.json");
+            const config = { key: "value", number: 42 };
+            await fs.writeFile(configPath, JSON.stringify(config));
+            const validate = (c) => c;
+            const result = await readConfigFile(configPath, validate);
+            expect(result).toEqual(config);
+        });
+        test("should return null for non-existent file", async () => {
+            const validate = (c) => c;
+            const result = await readConfigFile(join(testDir, "nonexistent.json"), validate);
+            expect(result).toBeNull();
+        });
+        test("should throw error for invalid JSON", async () => {
+            const configPath = join(testDir, "invalid.json");
+            await fs.writeFile(configPath, "{ invalid json }");
+            const validate = (c) => c;
+            await expect(readConfigFile(configPath, validate)).rejects.toThrow();
+        });
+    });
+    describe("writeConfig", () => {
+        test("should write config to file", async () => {
+            const configPath = join(testDir, "config.json");
+            const config = { key: "value", nested: { prop: 123 } };
+            await writeConfig(configPath, config);
+            const content = await fs.readFile(configPath, "utf-8");
+            expect(JSON.parse(content)).toEqual(config);
+        });
+        test("should create parent directories if they don't exist", async () => {
+            const configPath = join(testDir, "nested", "deep", "config.json");
+            const config = { key: "value" };
+            await writeConfig(configPath, config);
+            const content = await fs.readFile(configPath, "utf-8");
+            expect(JSON.parse(content)).toEqual(config);
+        });
+        test("should format JSON with 2-space indentation", async () => {
+            const configPath = join(testDir, "config.json");
+            const config = { key: "value" };
+            await writeConfig(configPath, config);
+            const content = await fs.readFile(configPath, "utf-8");
+            expect(content).toBe('{\n  "key": "value"\n}');
+        });
+        test("should throw error when write fails", async () => {
+            const invalidPath = "/invalid/path/that/cannot/be/created/config.json";
+            const config = { key: "value" };
+            expect(writeConfig(invalidPath, config)).rejects.toThrow("Failed to write config file");
+        });
+    });
+    describe("loadConfig", () => {
+        test("should return default config when no config files exist", async () => {
+            const defaultConfig = { option1: "default", option2: 42 };
+            const validate = (c) => c;
+            const cwdDir = join(process.cwd(), "src", "tests");
+            const result = await loadConfig({
+                toolName: "test-tool-nonexistent",
+                configFile: "config-nonexistent.json",
+                localConfigFile: ".testrc-nonexistent",
+                defaultConfig,
+                validate,
+            }, cwdDir);
+            expect(result.config).toEqual(defaultConfig);
+            expect(result.sources.option1).toBe("default");
+            expect(result.sources.option2).toBe("default");
+        });
+        test("should merge local config over default", async () => {
+            const defaultConfig = { option1: "default", option2: 42 };
+            const localConfig = { option1: "local" };
+            const validate = (c) => c;
+            await fs.writeFile(join(testDir, ".testrc"), JSON.stringify(localConfig));
+            const result = await loadConfig({
+                toolName: "test-tool",
+                configFile: "config.json",
+                localConfigFile: ".testrc",
+                defaultConfig,
+                validate,
+            }, testDir);
+            expect(result.config.option1).toBe("local");
+            expect(result.config.option2).toBe(42);
+            expect(result.sources.option1).toBe("local");
+            expect(result.sources.option2).toBe("default");
+        });
+        test("should merge global config over default", async () => {
+            const defaultConfig = { option1: "default", option2: 42 };
+            const globalConfig = { option1: "global" };
+            const validate = (c) => c;
+            const globalConfigPath = getGlobalConfigPath("test-tool-global", "config.json");
+            try {
+                await writeGlobalConfig(globalConfig, "test-tool-global", "config.json");
+                const cwdDir = join(process.cwd(), "src", "tests");
+                const result = await loadConfig({
+                    toolName: "test-tool-global",
+                    configFile: "config.json",
+                    localConfigFile: ".testrc-nonexistent",
+                    defaultConfig,
+                    validate,
+                }, cwdDir);
+                expect(result.config.option1).toBe("global");
+                expect(result.config.option2).toBe(42);
+                expect(result.sources.option1).toBe("global");
+                expect(result.sources.option2).toBe("default");
+            }
+            finally {
+                fs.rm(globalConfigPath, { force: true });
+                const dir = join(globalConfigPath, "..");
+                fs.rm(dir, { force: true, recursive: true });
+            }
+        });
+    });
+    describe("getGlobalConfigPath", () => {
+        test("should return correct global config path", () => {
+            const path = getGlobalConfigPath("my-tool", "config.json");
+            expect(path).toContain(".config");
+            expect(path).toContain("my-tool");
+            expect(path).toContain("config.json");
+        });
+    });
+    describe("findLocalConfigPath", () => {
+        test("should find local config file", async () => {
+            await fs.writeFile(join(testDir, ".testrc"), "{}");
+            const result = await findLocalConfigPath(".testrc", testDir);
+            expect(result).toBe(join(testDir, ".testrc"));
+        });
+        test("should return null when local config doesn't exist", async () => {
+            const cwdDir = join(process.cwd(), "src", "tests");
+            const result = await findLocalConfigPath(".testrc-nonexistent", cwdDir);
+            expect(result).toBeNull();
+        });
+    });
+    describe("writeLocalConfig", () => {
+        test("should write local config", async () => {
+            const configPath = join(testDir, ".testrc");
+            const config = { key: "value" };
+            await writeLocalConfig(configPath, config);
+            const content = await fs.readFile(configPath, "utf-8");
+            expect(JSON.parse(content)).toEqual(config);
+        });
+    });
+    describe("loadLocalConfig", () => {
+        test("should load existing local config", async () => {
+            const config = { key: "value" };
+            const configPath = join(testDir, ".testrc");
+            await fs.writeFile(configPath, JSON.stringify(config));
+            const validate = (c) => c;
+            const result = await loadLocalConfig(".testrc", validate, testDir);
+            expect(result.exists).toBe(true);
+            expect(result.config).toEqual(config);
+            expect(result.path).toBe(configPath);
+        });
+        test("should return null config when file doesn't exist", async () => {
+            const validate = (c) => c;
+            const cwdDir = join(process.cwd(), "src", "tests");
+            const result = await loadLocalConfig(".testrc-nonexistent", validate, cwdDir);
+            expect(result.exists).toBe(false);
+            expect(result.config).toBeNull();
+            expect(result.path).toBe(join(cwdDir, ".testrc-nonexistent"));
+        });
+    });
+    describe("writeGlobalConfig", () => {
+        test("should write global config", async () => {
+            const config = { key: "value" };
+            const globalPath = getGlobalConfigPath("test-tool-temp", "config.json");
+            try {
+                await writeGlobalConfig(config, "test-tool-temp", "config.json");
+                const content = await fs.readFile(globalPath, "utf-8");
+                expect(JSON.parse(content)).toEqual(config);
+            }
+            finally {
+                fs.rm(globalPath, { force: true });
+                const dir = join(globalPath, "..");
+                fs.rm(dir, { force: true, recursive: true });
+            }
+        });
+    });
+    describe("resetGlobalConfig", () => {
+        test("should reset global config to defaults", async () => {
+            const defaultConfig = { key: "default" };
+            const globalPath = getGlobalConfigPath("test-tool-reset", "config.json");
+            try {
+                await writeGlobalConfig({ key: "modified" }, "test-tool-reset", "config.json");
+                await resetGlobalConfig(defaultConfig, "test-tool-reset", "config.json");
+                const content = await fs.readFile(globalPath, "utf-8");
+                expect(JSON.parse(content)).toEqual(defaultConfig);
+            }
+            finally {
+                fs.rm(globalPath, { force: true });
+                const dir = join(globalPath, "..");
+                fs.rm(dir, { force: true, recursive: true });
+            }
+        });
+    });
+});

package/dist/tests/format.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/format.test.js

@@ -0,0 +1,76 @@
+import { describe, expect, test } from "bun:test";
+import { formatConfigValue, formatDate } from "../lib/format.js";
+describe("formatDate", () => {
+    test("should format valid date to ISO date string", () => {
+        const date = new Date("2024-01-15T10:30:00Z");
+        expect(formatDate(date)).toBe("2024-01-15");
+    });
+    test("should handle different dates", () => {
+        expect(formatDate(new Date("2023-12-31T00:00:00Z"))).toBe("2023-12-31");
+        expect(formatDate(new Date("2024-06-15T23:59:59Z"))).toBe("2024-06-15");
+    });
+    test("should return '--' for null", () => {
+        expect(formatDate(null)).toBe("--");
+    });
+    test("should handle dates at year boundaries", () => {
+        expect(formatDate(new Date("2024-01-01T00:00:00Z"))).toBe("2024-01-01");
+        expect(formatDate(new Date("2024-12-31T23:59:59Z"))).toBe("2024-12-31");
+    });
+    test("should handle dates with different times on same day", () => {
+        expect(formatDate(new Date("2024-03-15T00:00:00Z"))).toBe("2024-03-15");
+        expect(formatDate(new Date("2024-03-15T12:00:00Z"))).toBe("2024-03-15");
+        expect(formatDate(new Date("2024-03-15T23:59:59Z"))).toBe("2024-03-15");
+    });
+});
+describe("formatConfigValue", () => {
+    describe("arrays", () => {
+        test("should join array elements with comma and space", () => {
+            expect(formatConfigValue(["item1", "item2", "item3"])).toBe("item1, item2, item3");
+            expect(formatConfigValue([1, 2, 3])).toBe("1, 2, 3");
+        });
+        test("should return '(not set)' for empty arrays", () => {
+            expect(formatConfigValue([])).toBe("(not set)");
+        });
+        test("should handle arrays with single element", () => {
+            expect(formatConfigValue(["single"])).toBe("single");
+        });
+        test("should handle arrays with mixed types", () => {
+            expect(formatConfigValue([1, "two", true])).toBe("1, two, true");
+        });
+    });
+    describe("null, undefined, and empty string", () => {
+        test("should return '(not set)' for undefined", () => {
+            expect(formatConfigValue(undefined)).toBe("(not set)");
+        });
+        test("should return '(not set)' for null", () => {
+            expect(formatConfigValue(null)).toBe("(not set)");
+        });
+        test("should return '(not set)' for empty string", () => {
+            expect(formatConfigValue("")).toBe("(not set)");
+        });
+    });
+    describe("other values", () => {
+        test("should convert strings to string", () => {
+            expect(formatConfigValue("test")).toBe("test");
+            expect(formatConfigValue("hello world")).toBe("hello world");
+        });
+        test("should convert numbers to string", () => {
+            expect(formatConfigValue(42)).toBe("42");
+            expect(formatConfigValue(0)).toBe("0");
+            expect(formatConfigValue(-10)).toBe("-10");
+            expect(formatConfigValue(3.14)).toBe("3.14");
+        });
+        test("should convert booleans to string", () => {
+            expect(formatConfigValue(true)).toBe("true");
+            expect(formatConfigValue(false)).toBe("false");
+        });
+        test("should convert objects to string", () => {
+            expect(formatConfigValue({ a: 1, b: 2 })).toBe("[object Object]");
+        });
+        test("should handle special numeric values", () => {
+            expect(formatConfigValue(Number.NaN)).toBe("NaN");
+            expect(formatConfigValue(Number.POSITIVE_INFINITY)).toBe("Infinity");
+            expect(formatConfigValue(Number.NEGATIVE_INFINITY)).toBe("-Infinity");
+        });
+    });
+});

package/dist/tests/isDeepEqual.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/isDeepEqual.test.js

@@ -0,0 +1,203 @@
+import { describe, expect, test } from "bun:test";
+import { isDeepEqual } from "../lib/isDeepEqual.js";
+describe("isDeepEqual", () => {
+    describe("primitive values", () => {
+        test("should return true for identical primitive values", () => {
+            expect(isDeepEqual(1, 1)).toBe(true);
+            expect(isDeepEqual("hello", "hello")).toBe(true);
+            expect(isDeepEqual(true, true)).toBe(true);
+            expect(isDeepEqual(null, null)).toBe(true);
+            expect(isDeepEqual(undefined, undefined)).toBe(true);
+        });
+        test("should return false for different primitive values", () => {
+            expect(isDeepEqual(1, 2)).toBe(false);
+            expect(isDeepEqual("hello", "world")).toBe(false);
+            expect(isDeepEqual(true, false)).toBe(false);
+            expect(isDeepEqual(null, undefined)).toBe(false);
+        });
+        test("should handle NaN correctly", () => {
+            expect(isDeepEqual(Number.NaN, Number.NaN)).toBe(true);
+        });
+        test("should handle +0 and -0 correctly", () => {
+            expect(isDeepEqual(0, 0)).toBe(true);
+            expect(isDeepEqual(+0, +0)).toBe(true);
+        });
+    });
+    describe("arrays", () => {
+        test("should return true for identical arrays with strictOrder", () => {
+            expect(isDeepEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+            expect(isDeepEqual(["a", "b", "c"], ["a", "b", "c"])).toBe(true);
+            expect(isDeepEqual([{ a: 1 }, { b: 2 }], [{ a: 1 }, { b: 2 }])).toBe(true);
+        });
+        test("should return false for arrays with different order when strictOrder is true", () => {
+            expect(isDeepEqual([1, 2, 3], [3, 2, 1])).toBe(false);
+            expect(isDeepEqual(["a", "b", "c"], ["c", "b", "a"])).toBe(false);
+        });
+        test("should return true for arrays with different order when strictOrder is false", () => {
+            expect(isDeepEqual([1, 2, 3], [3, 2, 1], { strictOrder: false })).toBe(true);
+            expect(isDeepEqual(["a", "b", "c"], ["c", "b", "a"], { strictOrder: false })).toBe(true);
+        });
+        test("should return false when array elements don't match with strictOrder false", () => {
+            expect(isDeepEqual([1, 2, 3], [1, 2, 4], { strictOrder: false })).toBe(false);
+            expect(isDeepEqual([1, 2, 3], [1, 4, 5], { strictOrder: false })).toBe(false);
+        });
+        test("should return false for arrays with different lengths", () => {
+            expect(isDeepEqual([1, 2], [1, 2, 3])).toBe(false);
+            expect(isDeepEqual([1, 2, 3], [1, 2])).toBe(false);
+        });
+        test("should return false for arrays with different elements", () => {
+            expect(isDeepEqual([1, 2, 3], [1, 2, 4])).toBe(false);
+            expect(isDeepEqual(["a", "b"], ["a", "c"])).toBe(false);
+        });
+        test("should handle nested arrays", () => {
+            expect(isDeepEqual([
+                [1, 2],
+                [3, 4],
+            ], [
+                [1, 2],
+                [3, 4],
+            ])).toBe(true);
+            expect(isDeepEqual([
+                [1, 2],
+                [3, 4],
+            ], [
+                [1, 2],
+                [3, 5],
+            ])).toBe(false);
+        });
+    });
+    describe("objects", () => {
+        test("should return true for identical objects", () => {
+            expect(isDeepEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
+            expect(isDeepEqual({ b: 2, a: 1 }, { a: 1, b: 2 })).toBe(true);
+        });
+        test("should return false for objects with different keys", () => {
+            expect(isDeepEqual({ a: 1 }, { b: 1 })).toBe(false);
+            expect(isDeepEqual({ a: 1, b: 2 }, { a: 1 })).toBe(false);
+        });
+        test("should return false for objects with different values", () => {
+            expect(isDeepEqual({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false);
+        });
+        test("should handle nested objects", () => {
+            expect(isDeepEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })).toBe(true);
+            expect(isDeepEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 2 } } })).toBe(false);
+        });
+        test("should handle objects with arrays", () => {
+            expect(isDeepEqual({ a: [1, 2, 3], b: "test" }, { a: [1, 2, 3], b: "test" })).toBe(true);
+        });
+    });
+    describe("Date objects", () => {
+        test("should return true for identical dates", () => {
+            const date1 = new Date("2024-01-01");
+            const date2 = new Date("2024-01-01");
+            expect(isDeepEqual(date1, date2)).toBe(true);
+        });
+        test("should return false for different dates", () => {
+            const date1 = new Date("2024-01-01");
+            const date2 = new Date("2024-01-02");
+            expect(isDeepEqual(date1, date2)).toBe(false);
+        });
+    });
+    describe("RegExp objects", () => {
+        test("should return true for identical regex patterns", () => {
+            expect(isDeepEqual(/test/g, /test/g)).toBe(true);
+            expect(isDeepEqual(/hello/i, /hello/i)).toBe(true);
+        });
+        test("should return false for different regex patterns", () => {
+            expect(isDeepEqual(/test/g, /test/i)).toBe(false);
+            expect(isDeepEqual(/hello/, /world/)).toBe(false);
+        });
+    });
+    describe("Set objects", () => {
+        test("should return true for identical sets", () => {
+            expect(isDeepEqual(new Set([1, 2, 3]), new Set([1, 2, 3]))).toBe(true);
+            expect(isDeepEqual(new Set([1, 2, 3]), new Set([3, 2, 1]))).toBe(true);
+        });
+        test("should return false for different sets", () => {
+            expect(isDeepEqual(new Set([1, 2, 3]), new Set([1, 2, 4]))).toBe(false);
+            expect(isDeepEqual(new Set([1, 2]), new Set([1, 2, 3]))).toBe(false);
+        });
+        test("should handle sets with objects", () => {
+            expect(isDeepEqual(new Set([{ a: 1 }, { b: 2 }]), new Set([{ a: 1 }, { b: 2 }]))).toBe(true);
+        });
+    });
+    describe("Map objects", () => {
+        test("should return true for identical maps", () => {
+            expect(isDeepEqual(new Map([
+                ["a", 1],
+                ["b", 2],
+            ]), new Map([
+                ["a", 1],
+                ["b", 2],
+            ]))).toBe(true);
+            expect(isDeepEqual(new Map([
+                ["a", 1],
+                ["b", 2],
+            ]), new Map([
+                ["b", 2],
+                ["a", 1],
+            ]))).toBe(true);
+        });
+        test("should return false for different maps", () => {
+            expect(isDeepEqual(new Map([
+                ["a", 1],
+                ["b", 2],
+            ]), new Map([
+                ["a", 1],
+                ["b", 3],
+            ]))).toBe(false);
+            expect(isDeepEqual(new Map([["a", 1]]), new Map([
+                ["a", 1],
+                ["b", 2],
+            ]))).toBe(false);
+        });
+    });
+    describe("TypedArray", () => {
+        test("should return true for identical typed arrays", () => {
+            expect(isDeepEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))).toBe(true);
+            expect(isDeepEqual(new Int16Array([10, 20, 30]), new Int16Array([10, 20, 30]))).toBe(true);
+        });
+        test("should return false for different typed arrays", () => {
+            expect(isDeepEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 4]))).toBe(false);
+        });
+        test("should return false for typed arrays with different types", () => {
+            expect(isDeepEqual(new Uint8Array([1, 2, 3]), new Int8Array([1, 2, 3]))).toBe(false);
+        });
+        test("should return false for typed arrays with different lengths", () => {
+            expect(isDeepEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2]))).toBe(false);
+            expect(isDeepEqual(new Uint8Array([1, 2]), new Uint8Array([1, 2, 3]))).toBe(false);
+        });
+    });
+    describe("circular references", () => {
+        test("should handle circular references", () => {
+            const obj1 = { a: 1 };
+            obj1.self = obj1;
+            const obj2 = { a: 1 };
+            obj2.self = obj2;
+            expect(isDeepEqual(obj1, obj2)).toBe(true);
+        });
+    });
+    describe("mixed types", () => {
+        test("should return false for different types", () => {
+            expect(isDeepEqual(1, "1")).toBe(false);
+            expect(isDeepEqual([1], { 0: 1 })).toBe(false);
+            expect(isDeepEqual(null, {})).toBe(false);
+            expect(isDeepEqual(undefined, null)).toBe(false);
+        });
+        test("should handle complex nested structures", () => {
+            const obj1 = {
+                a: [1, 2, { b: 3 }],
+                c: new Set([4, 5]),
+                d: new Map([["e", 6]]),
+                f: new Date("2024-01-01"),
+            };
+            const obj2 = {
+                a: [1, 2, { b: 3 }],
+                c: new Set([4, 5]),
+                d: new Map([["e", 6]]),
+                f: new Date("2024-01-01"),
+            };
+            expect(isDeepEqual(obj1, obj2)).toBe(true);
+        });
+    });
+});

package/dist/tests/isValidBranchName.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/isValidBranchName.test.js

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test";
+import { isValidBranchName } from "../lib/isValidBranchName.js";
+describe("isValidBranchName", () => {
+    describe("valid branch names", () => {
+        test("should return true for simple branch names", () => {
+            expect(isValidBranchName("main")).toBe(true);
+            expect(isValidBranchName("develop")).toBe(true);
+            expect(isValidBranchName("feature")).toBe(true);
+        });
+        test("should return true for branch names with hyphens", () => {
+            expect(isValidBranchName("feature-branch")).toBe(true);
+            expect(isValidBranchName("bug-fix")).toBe(true);
+        });
+        test("should return true for branch names with underscores", () => {
+            expect(isValidBranchName("feature_branch")).toBe(true);
+            expect(isValidBranchName("bug_fix")).toBe(true);
+        });
+        test("should return true for branch names with dots", () => {
+            expect(isValidBranchName("release.1.0")).toBe(true);
+            expect(isValidBranchName("v1.2.3")).toBe(true);
+        });
+        test("should return true for branch names with slashes", () => {
+            expect(isValidBranchName("feature/new-feature")).toBe(true);
+            expect(isValidBranchName("bugfix/issue-123")).toBe(true);
+            expect(isValidBranchName("release/v1.0.0")).toBe(true);
+        });
+        test("should return true for branch names with numbers", () => {
+            expect(isValidBranchName("feature123")).toBe(true);
+            expect(isValidBranchName("v1.2.3")).toBe(true);
+        });
+        test("should return true for mixed valid characters", () => {
+            expect(isValidBranchName("feature/ABC-123_test.v1")).toBe(true);
+            expect(isValidBranchName("release/2024.01.01")).toBe(true);
+        });
+    });
+    describe("invalid branch names", () => {
+        test("should return false for empty strings", () => {
+            expect(isValidBranchName("")).toBe(false);
+        });
+        test("should return false for branch names with invalid characters", () => {
+            expect(isValidBranchName("feature@branch")).toBe(false);
+            expect(isValidBranchName("bug#fix")).toBe(false);
+            expect(isValidBranchName("test branch")).toBe(false);
+            expect(isValidBranchName("feature:branch")).toBe(false);
+        });
+        test("should return false for branch names with double dots", () => {
+            expect(isValidBranchName("feature..branch")).toBe(false);
+            expect(isValidBranchName("test..test")).toBe(false);
+        });
+        test("should return false for branch names starting with slash", () => {
+            expect(isValidBranchName("/feature")).toBe(false);
+            expect(isValidBranchName("/main")).toBe(false);
+        });
+        test("should return false for branch names ending with slash", () => {
+            expect(isValidBranchName("feature/")).toBe(false);
+            expect(isValidBranchName("main/")).toBe(false);
+        });
+        test("should return false for branch names with double slashes", () => {
+            expect(isValidBranchName("feature//branch")).toBe(false);
+            expect(isValidBranchName("test//test")).toBe(false);
+        });
+        test("should return false for branch names ending with dot", () => {
+            expect(isValidBranchName("feature.")).toBe(false);
+            expect(isValidBranchName("branch.")).toBe(false);
+        });
+        test("should return false for components starting with dot", () => {
+            expect(isValidBranchName("feature/.hidden")).toBe(false);
+            expect(isValidBranchName(".hidden/branch")).toBe(false);
+        });
+        test("should return false for components ending with .lock", () => {
+            expect(isValidBranchName("feature/branch.lock")).toBe(false);
+            expect(isValidBranchName("test.lock")).toBe(false);
+        });
+    });
+    describe("edge cases", () => {
+        test("should handle single character branch names", () => {
+            expect(isValidBranchName("a")).toBe(true);
+            expect(isValidBranchName("1")).toBe(true);
+        });
+        test("should handle very long branch names", () => {
+            const longName = "a".repeat(255);
+            expect(isValidBranchName(longName)).toBe(true);
+        });
+        test("should handle branch names with multiple slashes", () => {
+            expect(isValidBranchName("feature/sub/branch")).toBe(true);
+            expect(isValidBranchName("a/b/c/d/e")).toBe(true);
+        });
+    });
+});

package/dist/tests/match.test.d.ts

@@ -0,0 +1 @@
+export {};