@somewhatabstract/x 0.1.0 → 0.1.1

package/biome.json

@@ -1,39 +0,0 @@
-{
-    "$schema": "https://biomejs.dev/schemas/2.4.3/schema.json",
-    "formatter": {
-        "enabled": true,
-        "indentStyle": "space",
-        "indentWidth": 4,
-        "bracketSpacing": false,
-        "includes": ["**", "!dist/**", "!coverage/**"]
-    },
-    "linter": {
-        "enabled": true,
-        "includes": ["**", "!dist/**", "!coverage/**"]
-    },
-    "assist": {
-        "enabled": true,
-        "includes": ["**", "!dist/**", "!coverage/**"]
-    },
-    "overrides": [
-        {
-            "includes": ["**/*.test.*"],
-            "linter": {
-                "rules": {
-                    "suspicious": {
-                        "noExplicitAny": "off"
-                    }
-                }
-            }
-        },
-        {
-            "includes": ["*.json", "*.jsonc"],
-            "json": {
-                "parser": {
-                    "allowComments": true,
-                    "allowTrailingCommas": true
-                }
-            }
-        }
-    ]
-}

package/src/__tests__/build-environment.test.ts

@@ -1,285 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import {beforeEach, describe, expect, it, vi} from "vitest";
-import {buildEnvironment} from "../build-environment";
-
-// Mock the fs module
-vi.mock("node:fs/promises", () => ({
-    readFile: vi.fn(),
-}));
-
-describe("buildEnvironment", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it("should preserve existing environment variables", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {
-            EXISTING_VAR: "existing-value",
-            PATH: "/usr/bin:/bin",
-        };
-
-        vi.mocked(fs.readFile).mockResolvedValue(
-            JSON.stringify({
-                name: "test-workspace",
-                version: "1.0.0",
-            }),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.EXISTING_VAR).toBe("existing-value");
-    });
-
-    it("should prepend workspace node_modules/.bin to PATH", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {
-            PATH: "/usr/bin:/bin",
-        };
-
-        vi.mocked(fs.readFile).mockResolvedValue(
-            JSON.stringify({
-                name: "test-workspace",
-            }),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        const expectedPath = path.join(workspaceRoot, "node_modules", ".bin");
-        expect(env.PATH).toContain(expectedPath);
-    });
-
-    it("should set npm_command to exec", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({}));
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_command).toBe("exec");
-    });
-
-    it("should set INIT_CWD to current working directory", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-        const expectedCwd = process.cwd();
-
-        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({}));
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.INIT_CWD).toBe(expectedCwd);
-    });
-
-    it("should set npm_package_name from workspace package.json", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(
-            JSON.stringify({
-                name: "my-workspace",
-                version: "2.5.0",
-            }),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_package_name).toBe("my-workspace");
-    });
-
-    it("should set npm_package_version from workspace package.json", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(
-            JSON.stringify({
-                name: "my-workspace",
-                version: "2.5.0",
-            }),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_package_version).toBe("2.5.0");
-    });
-
-    it("should set npm_execpath to node executable path", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({}));
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_execpath).toBe(process.execPath);
-    });
-
-    it("should include package name in npm_config_user_agent", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({}));
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_config_user_agent).toContain("x/");
-    });
-
-    it("should include node version in npm_config_user_agent", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({}));
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_config_user_agent).toContain("node/");
-    });
-
-    it("should set npm_command to exec when package.json is missing", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockRejectedValue(
-            new Error("ENOENT: no such file"),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_command).toBe("exec");
-    });
-
-    it("should set INIT_CWD when package.json is missing", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockRejectedValue(
-            new Error("ENOENT: no such file"),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.INIT_CWD).toBe(process.cwd());
-    });
-
-    it("should include npm_package_description if present", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(
-            JSON.stringify({
-                name: "my-workspace",
-                description: "A test workspace",
-            }),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_package_description).toBe("A test workspace");
-    });
-
-    it("should convert object fields to JSON strings", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(
-            JSON.stringify({
-                name: "my-workspace",
-                repository: {
-                    type: "git",
-                    url: "https://github.com/test/repo",
-                },
-            }),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_package_repository).toBe(
-            JSON.stringify({
-                type: "git",
-                url: "https://github.com/test/repo",
-            }),
-        );
-    });
-
-    it("should set npm_package_license from workspace package.json", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(
-            JSON.stringify({
-                name: "my-workspace",
-                license: "MIT",
-                author: "John Doe",
-            }),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_package_license).toBe("MIT");
-    });
-
-    it("should set npm_package_author from workspace package.json", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const currentEnv = {PATH: "/usr/bin"};
-
-        vi.mocked(fs.readFile).mockResolvedValue(
-            JSON.stringify({
-                name: "my-workspace",
-                license: "MIT",
-                author: "John Doe",
-            }),
-        );
-
-        // Act
-        const env = await buildEnvironment(workspaceRoot, currentEnv);
-
-        // Assert
-        expect(env.npm_package_author).toBe("John Doe");
-    });
-});

package/src/__tests__/discover-packages.test.ts

@@ -1,196 +0,0 @@
-import * as manypkg from "@manypkg/get-packages";
-import {beforeEach, describe, expect, it, vi} from "vitest";
-import {discoverPackages} from "../discover-packages";
-import {HandledError} from "../errors";
-
-// Mock @manypkg/get-packages
-vi.mock("@manypkg/get-packages", () => ({
-    getPackages: vi.fn(),
-}));
-
-describe("discoverPackages", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-
-    it("should return packages from @manypkg", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const mockPackages = {
-            packages: [
-                {
-                    packageJson: {name: "pkg1", version: "1.0.0"},
-                    dir: "/test/workspace/pkg1",
-                },
-                {
-                    packageJson: {name: "pkg2", version: "2.0.0"},
-                    dir: "/test/workspace/pkg2",
-                },
-            ],
-        };
-
-        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
-
-        // Act
-        const result = await discoverPackages(workspaceRoot);
-
-        // Assert
-        expect(result).toHaveLength(2);
-    });
-
-    it("should map package names correctly", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const mockPackages = {
-            packages: [
-                {
-                    packageJson: {name: "test-package", version: "1.0.0"},
-                    dir: "/test/workspace/pkg",
-                },
-            ],
-        };
-
-        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
-
-        // Act
-        const result = await discoverPackages(workspaceRoot);
-
-        // Assert
-        expect(result[0].name).toBe("test-package");
-    });
-
-    it("should map package paths correctly", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const mockPackages = {
-            packages: [
-                {
-                    packageJson: {name: "test-package", version: "1.0.0"},
-                    dir: "/test/workspace/packages/test",
-                },
-            ],
-        };
-
-        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
-
-        // Act
-        const result = await discoverPackages(workspaceRoot);
-
-        // Assert
-        expect(result[0].path).toBe("/test/workspace/packages/test");
-    });
-
-    it("should map package versions correctly", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const mockPackages = {
-            packages: [
-                {
-                    packageJson: {name: "test-package", version: "3.2.1"},
-                    dir: "/test/workspace/pkg",
-                },
-            ],
-        };
-
-        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
-
-        // Act
-        const result = await discoverPackages(workspaceRoot);
-
-        // Assert
-        expect(result[0].version).toBe("3.2.1");
-    });
-
-    it("should use 'unknown' for missing version", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const mockPackages = {
-            packages: [
-                {
-                    packageJson: {name: "test-package"},
-                    dir: "/test/workspace/pkg",
-                },
-            ],
-        };
-
-        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
-
-        // Act
-        const result = await discoverPackages(workspaceRoot);
-
-        // Assert
-        expect(result[0].version).toBe("unknown");
-    });
-
-    it("should call getPackages with workspace root", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const mockPackages = {
-            packages: [],
-        };
-
-        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
-
-        // Act
-        await discoverPackages(workspaceRoot);
-
-        // Assert
-        expect(manypkg.getPackages).toHaveBeenCalledWith(workspaceRoot);
-    });
-
-    it("should rethrow HandledError type as is", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const handledError = new HandledError("Test handled error");
-
-        vi.mocked(manypkg.getPackages).mockRejectedValue(handledError);
-
-        // Act
-        const underTest = () => discoverPackages(workspaceRoot);
-
-        // Assert
-        await expect(underTest).rejects.toThrow(HandledError);
-    });
-
-    it("should rethrow HandledError message as is", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const handledError = new HandledError("Test handled error");
-
-        vi.mocked(manypkg.getPackages).mockRejectedValue(handledError);
-
-        // Act
-        const underTest = () => discoverPackages(workspaceRoot);
-
-        // Assert
-        await expect(underTest).rejects.toThrow("Test handled error");
-    });
-
-    it("should wrap non-HandledError in HandledError type", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const error = new Error("Original error");
-
-        vi.mocked(manypkg.getPackages).mockRejectedValue(error);
-
-        // Act
-        const underTest = () => discoverPackages(workspaceRoot);
-
-        // Assert
-        await expect(underTest).rejects.toThrow(HandledError);
-    });
-
-    it("should use expected message when wrapping non-HandledError", async () => {
-        // Arrange
-        const workspaceRoot = "/test/workspace";
-        const error = new Error("Original error");
-
-        vi.mocked(manypkg.getPackages).mockRejectedValue(error);
-
-        // Act
-        const underTest = () => discoverPackages(workspaceRoot);
-
-        // Assert
-        await expect(underTest).rejects.toThrow("Failed to discover packages");
-    });
-});

package/src/__tests__/errors.test.ts

@@ -1,59 +0,0 @@
-import {describe, expect, it} from "vitest";
-import {HandledError} from "../errors";
-
-describe("HandledError", () => {
-    it("should be an instance of Error", () => {
-        // Arrange
-        const error = new HandledError("Test error message");
-
-        // Act
-        const isError = error instanceof Error;
-
-        // Assert
-        expect(isError).toBe(true);
-    });
-
-    it("should have name 'HandledError'", () => {
-        // Arrange
-        const error = new HandledError("Test error message");
-
-        // Act
-        const name = error.name;
-
-        // Assert
-        expect(name).toBe("HandledError");
-    });
-
-    it("should preserve the error message", () => {
-        // Arrange
-        const message = "Test error message";
-
-        // Act
-        const error = new HandledError(message);
-
-        // Assert
-        expect(error.message).toBe(message);
-    });
-
-    it("should be distinguishable from HandledError type", () => {
-        // Arrange
-        const handledError = new HandledError("Handled");
-
-        // Act
-        const isHandledError = handledError instanceof HandledError;
-
-        // Assert
-        expect(isHandledError).toBe(true);
-    });
-
-    it("should distinguish regular errors from HandledError type", () => {
-        // Arrange
-        const regularError = new Error("Regular");
-
-        // Act
-        const isHandledError = regularError instanceof HandledError;
-
-        // Assert
-        expect(isHandledError).toBe(false);
-    });
-});