@simplysm/sd-cli 13.0.75 → 13.0.77

package/tests/get-compiler-options-for-package.spec.ts

@@ -3,12 +3,16 @@ import type ts from "typescript";
 
 // Mock core-node functions
 vi.mock("@simplysm/core-node", () => ({
-  fsExists: vi.fn(),
-  fsReadJson: vi.fn(),
-  pathPosix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+  fsx: {
+    exists: vi.fn(),
+    readJson: vi.fn(),
+  },
+  pathx: {
+    posix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+  },
 }));
 
-import { fsExists, fsReadJson } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 import { getCompilerOptionsForPackage } from "../src/utils/tsconfig";
 
 describe("getCompilerOptionsForPackage", () => {
@@ -28,8 +32,8 @@ describe("getCompilerOptionsForPackage", () => {
 
   it("node target: removes DOM lib, includes node in types", async () => {
     const packageDir = "/project/packages/core-node";
-    vi.mocked(fsExists).mockResolvedValue(true);
-    vi.mocked(fsReadJson).mockResolvedValue({
+    vi.mocked(fsx.exists).mockResolvedValue(true);
+    vi.mocked(fsx.readJson).mockResolvedValue({
       devDependencies: {
         "@types/express": "^4.17.0",
       },
@@ -46,8 +50,8 @@ describe("getCompilerOptionsForPackage", () => {
 
   it("browser target: keeps lib, removes node from types", async () => {
     const packageDir = "/project/packages/core-browser";
-    vi.mocked(fsExists).mockResolvedValue(true);
-    vi.mocked(fsReadJson).mockResolvedValue({
+    vi.mocked(fsx.exists).mockResolvedValue(true);
+    vi.mocked(fsx.readJson).mockResolvedValue({
       devDependencies: {
         "@types/node": "^20.0.0",
         "@types/react": "^18.0.0",
@@ -63,42 +67,9 @@ describe("getCompilerOptionsForPackage", () => {
     expect(result.types).toContain("react");
   });
 
-  it("neutral target: keeps lib, includes node in types", async () => {
-    const packageDir = "/project/packages/core-common";
-    vi.mocked(fsExists).mockResolvedValue(true);
-    vi.mocked(fsReadJson).mockResolvedValue({
-      devDependencies: {
-        "@types/lodash": "^4.0.0",
-      },
-    });
-
-    const result = await getCompilerOptionsForPackage(baseOptions, "neutral", packageDir);
-
-    // lib is preserved (includes DOM)
-    expect(result.lib).toEqual(["ES2024", "DOM", "DOM.Iterable", "WebWorker"]);
-    // types includes node and lodash
-    expect(result.types).toContain("node");
-    expect(result.types).toContain("lodash");
-  });
-
-  it("node target: removes duplicate node types", async () => {
-    const packageDir = "/project/packages/core-node";
-    vi.mocked(fsExists).mockResolvedValue(true);
-    vi.mocked(fsReadJson).mockResolvedValue({
-      devDependencies: {
-        "@types/node": "^20.0.0",
-      },
-    });
-
-    const result = await getCompilerOptionsForPackage(baseOptions, "node", packageDir);
-
-    // node type is included only once without duplicates
-    expect(result.types?.filter((t) => t === "node")).toHaveLength(1);
-  });
-
   it("handles missing package.json with empty types", async () => {
     const packageDir = "/project/packages/unknown";
-    vi.mocked(fsExists).mockResolvedValue(false);
+    vi.mocked(fsx.exists).mockResolvedValue(false);
 
     const result = await getCompilerOptionsForPackage(baseOptions, "node", packageDir);
 
@@ -106,34 +77,4 @@ describe("getCompilerOptionsForPackage", () => {
     expect(result.types).toEqual(["node"]);
   });
 
-  it("handles undefined lib correctly", async () => {
-    const optionsWithoutLib: ts.CompilerOptions = {
-      strict: true,
-    };
-    const packageDir = "/project/packages/core-node";
-    vi.mocked(fsExists).mockResolvedValue(false);
-
-    const result = await getCompilerOptionsForPackage(optionsWithoutLib, "node", packageDir);
-
-    // handles undefined lib without error
-    expect(result.lib).toBeUndefined();
-    expect(result.types).toEqual(["node"]);
-  });
-
-  it("does not mutate original baseOptions (immutability)", async () => {
-    const originalOptions: ts.CompilerOptions = {
-      lib: ["ES2024", "DOM"],
-      types: ["original"],
-      strict: true,
-    };
-    const packageDir = "/project/packages/core-node";
-    vi.mocked(fsExists).mockResolvedValue(false);
-
-    await getCompilerOptionsForPackage(originalOptions, "node", packageDir);
-
-    // original options are not changed
-    expect(originalOptions.lib).toEqual(["ES2024", "DOM"]);
-    expect(originalOptions.types).toEqual(["original"]);
-    expect(originalOptions.noEmit).toBeUndefined();
-  });
 });

package/tests/get-package-source-files.spec.ts

@@ -4,8 +4,6 @@ import type ts from "typescript";
 import { getPackageSourceFiles, getPackageFiles } from "../src/utils/tsconfig";
 
 describe("getPackageSourceFiles", () => {
-  const sep = path.sep;
-
   it("filters files within package src directory only", () => {
     const pkgDir = `/project/packages/core-common`;
     const parsedConfig = {
@@ -60,35 +58,6 @@ describe("getPackageSourceFiles", () => {
     ]);
   });
 
-  it("returns empty array if no files", () => {
-    const pkgDir = `/project/packages/empty`;
-    const parsedConfig = {
-      fileNames: [
-        `/project/packages/core/src/index.ts`,
-        `/project/packages/core-common/src/index.ts`,
-      ],
-    } as ts.ParsedCommandLine;
-
-    const result = getPackageSourceFiles(pkgDir, parsedConfig);
-
-    expect(result).toEqual([]);
-  });
-
-  it("handles path separators correctly", () => {
-    // use path.sep for platform-independent test
-    const pkgDir = `${sep}project${sep}packages${sep}core`;
-    const parsedConfig = {
-      fileNames: [
-        `${sep}project${sep}packages${sep}core${sep}src${sep}index.ts`,
-        `${sep}project${sep}packages${sep}core-common${sep}src${sep}index.ts`,
-      ],
-    } as ts.ParsedCommandLine;
-
-    const result = getPackageSourceFiles(pkgDir, parsedConfig);
-
-    expect(result).toEqual([`${sep}project${sep}packages${sep}core${sep}src${sep}index.ts`]);
-  });
-
   it("handles forward slash paths from TypeScript API correctly (Windows compatible)", () => {
     // TypeScript API returns forward slash paths even on Windows
     // pkgDir is created with path.join using OS-native separator
@@ -152,17 +121,6 @@ describe("getPackageFiles", () => {
     ]);
   });
 
-  it("returns empty array if no files", () => {
-    const pkgDir = `/project/packages/empty`;
-    const parsedConfig = {
-      fileNames: [`/project/packages/core/src/index.ts`],
-    } as ts.ParsedCommandLine;
-
-    const result = getPackageFiles(pkgDir, parsedConfig);
-
-    expect(result).toEqual([]);
-  });
-
   it("handles forward slash paths from TypeScript API correctly (Windows compatible)", () => {
     const pkgDir = path.resolve("/project/packages/core-common");
     const parsedConfig = {

package/tests/get-types-from-package-json.spec.ts

@@ -3,12 +3,16 @@ import path from "path";
 
 // Mock core-node functions
 vi.mock("@simplysm/core-node", () => ({
-  fsExists: vi.fn(),
-  fsReadJson: vi.fn(),
-  pathPosix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+  fsx: {
+    exists: vi.fn(),
+    readJson: vi.fn(),
+  },
+  pathx: {
+    posix: vi.fn((p: string) => p.replace(/\\/g, "/")),
+  },
 }));
 
-import { fsExists, fsReadJson } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 import { getTypesFromPackageJson } from "../src/utils/tsconfig";
 
 describe("getTypesFromPackageJson", () => {
@@ -22,8 +26,8 @@ describe("getTypesFromPackageJson", () => {
 
   it("converts @types/* devDependencies to types list", async () => {
     const packageDir = "/project/packages/core-common";
-    const mockFsExists = vi.mocked(fsExists);
-    const mockFsReadJson = vi.mocked(fsReadJson);
+    const mockFsExists = vi.mocked(fsx.exists);
+    const mockFsReadJson = vi.mocked(fsx.readJson);
 
     mockFsExists.mockResolvedValue(true);
     mockFsReadJson.mockResolvedValue({
@@ -43,7 +47,7 @@ describe("getTypesFromPackageJson", () => {
 
   it("returns empty array if package.json does not exist", async () => {
     const packageDir = "/project/packages/unknown";
-    const mockFsExists = vi.mocked(fsExists);
+    const mockFsExists = vi.mocked(fsx.exists);
 
     mockFsExists.mockResolvedValue(false);
 
@@ -54,8 +58,8 @@ describe("getTypesFromPackageJson", () => {
 
   it("returns empty array if devDependencies does not exist", async () => {
     const packageDir = "/project/packages/core-common";
-    const mockFsExists = vi.mocked(fsExists);
-    const mockFsReadJson = vi.mocked(fsReadJson);
+    const mockFsExists = vi.mocked(fsx.exists);
+    const mockFsReadJson = vi.mocked(fsx.readJson);
 
     mockFsExists.mockResolvedValue(true);
     mockFsReadJson.mockResolvedValue({
@@ -68,29 +72,10 @@ describe("getTypesFromPackageJson", () => {
     expect(result).toEqual([]);
   });
 
-  it("filters out dependencies that are not @types/*", async () => {
-    const packageDir = "/project/packages/core-common";
-    const mockFsExists = vi.mocked(fsExists);
-    const mockFsReadJson = vi.mocked(fsReadJson);
-
-    mockFsExists.mockResolvedValue(true);
-    mockFsReadJson.mockResolvedValue({
-      devDependencies: {
-        typescript: "^5.0.0",
-        vitest: "^1.0.0",
-        eslint: "^9.0.0",
-      },
-    });
-
-    const result = await getTypesFromPackageJson(packageDir);
-
-    expect(result).toEqual([]);
-  });
-
   it("handles scoped @types packages correctly", async () => {
     const packageDir = "/project/packages/core-common";
-    const mockFsExists = vi.mocked(fsExists);
-    const mockFsReadJson = vi.mocked(fsReadJson);
+    const mockFsExists = vi.mocked(fsx.exists);
+    const mockFsReadJson = vi.mocked(fsx.readJson);
 
     mockFsExists.mockResolvedValue(true);
     mockFsReadJson.mockResolvedValue({

package/tests/infra/ResultCollector.spec.ts

@@ -27,13 +27,4 @@ describe("ResultCollector", () => {
     expect(collector.toMap().size).toBe(1);
   });
 
-  it("returns internal Map", () => {
-    const collector = new ResultCollector();
-    collector.add({ name: "pkg1", target: "node", type: "build", status: "success" });
-
-    const map = collector.toMap();
-
-    expect(map).toBeInstanceOf(Map);
-    expect(map.size).toBe(1);
-  });
 });

package/tests/infra/WorkerManager.spec.ts

@@ -26,12 +26,6 @@ describe("WorkerManager", () => {
     expect(manager.get("test-worker")).toBe(worker);
   });
 
-  it("returns undefined when retrieving a non-existent Worker", () => {
-    const manager = new WorkerManager();
-
-    expect(manager.get("nonexistent")).toBeUndefined();
-  });
-
   it("terminates all Workers", async () => {
     const manager = new WorkerManager();
     const worker1 = manager.create("worker1", "/path/to/worker.ts");
@@ -57,34 +51,6 @@ describe("WorkerManager", () => {
     expect(manager.get("worker2")).toBe(worker2);
   });
 
-  it("handles terminating a non-existent Worker without error", async () => {
-    const manager = new WorkerManager();
-
-    await expect(manager.terminate("nonexistent")).resolves.toBeUndefined();
-  });
-
-  it("retrieves the count of managed Workers", () => {
-    const manager = new WorkerManager();
-
-    expect(manager.size).toBe(0);
-
-    manager.create("worker1", "/path/to/worker.ts");
-    expect(manager.size).toBe(1);
-
-    manager.create("worker2", "/path/to/worker.ts");
-    expect(manager.size).toBe(2);
-  });
-
-  it("retrieves list of all Worker IDs", () => {
-    const manager = new WorkerManager();
-    manager.create("worker1", "/path/to/worker.ts");
-    manager.create("worker2", "/path/to/worker.ts");
-
-    const ids = manager.ids;
-
-    expect(ids).toEqual(["worker1", "worker2"]);
-  });
-
   it("overwrites existing Worker when creating with the same ID", () => {
     const manager = new WorkerManager();
     const worker1 = manager.create("same-id", "/path/to/worker1.ts");

package/tests/load-ignore-patterns.spec.ts

@@ -4,8 +4,12 @@ import path from "path";
 
 // Mock core-node functions and jiti
 vi.mock("@simplysm/core-node", () => ({
-  fsExists: vi.fn(),
-  pathPosix: vi.fn(),
+  fsx: {
+    exists: vi.fn(),
+  },
+  pathx: {
+    posix: vi.fn(),
+  },
 }));
 
 const mockJitiImportFn = vi.fn();
@@ -15,7 +19,7 @@ vi.mock("jiti", () => ({
   })),
 }));
 
-import { fsExists } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 
 describe("loadIgnorePatterns", () => {
   beforeEach(() => {
@@ -28,7 +32,7 @@ describe("loadIgnorePatterns", () => {
 
   it("extracts globalIgnores pattern from eslint.config.ts", async () => {
     const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
+    const mockExists = vi.mocked(fsx.exists);
 
     mockExists.mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
@@ -45,7 +49,7 @@ describe("loadIgnorePatterns", () => {
 
   it("does not extract as globalIgnores if files is present", async () => {
     const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
+    const mockExists = vi.mocked(fsx.exists);
 
     mockExists.mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
@@ -66,7 +70,7 @@ describe("loadIgnorePatterns", () => {
 
   it("throws error if config file not found", async () => {
     const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
+    const mockExists = vi.mocked(fsx.exists);
 
     mockExists.mockResolvedValue(false);
 
@@ -75,7 +79,7 @@ describe("loadIgnorePatterns", () => {
 
   it("throws error if config is not array", async () => {
     const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
+    const mockExists = vi.mocked(fsx.exists);
 
     mockExists.mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
@@ -90,7 +94,7 @@ describe("loadIgnorePatterns", () => {
 
   it("merges multiple globalIgnores settings", async () => {
     const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
+    const mockExists = vi.mocked(fsx.exists);
 
     mockExists.mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
@@ -107,7 +111,7 @@ describe("loadIgnorePatterns", () => {
 
   it("handles config that directly exports array", async () => {
     const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
+    const mockExists = vi.mocked(fsx.exists);
 
     mockExists.mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.js"));
@@ -122,7 +126,7 @@ describe("loadIgnorePatterns", () => {
 
   it("throws error if config has no default and is not array", async () => {
     const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
+    const mockExists = vi.mocked(fsx.exists);
 
     mockExists.mockImplementation((filePath: string) => {
       return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
@@ -139,7 +143,7 @@ describe("loadIgnorePatterns", () => {
 
   it("uses mts file if eslint.config.ts not found", async () => {
     const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
+    const mockExists = vi.mocked(fsx.exists);
 
     mockExists.mockImplementation((filePath: string) => {
       // eslint.config.ts does not exist, only eslint.config.mts
@@ -156,33 +160,4 @@ describe("loadIgnorePatterns", () => {
     expect(mockJitiImportFn).toHaveBeenCalledWith(expect.stringContaining("eslint.config.mts"));
   });
 
-  it("returns empty pattern array if empty array exported", async () => {
-    const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
-
-    mockExists.mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-
-    mockJitiImportFn.mockResolvedValue({
-      default: [],
-    });
-
-    const patterns = await loadIgnorePatterns(cwd);
-
-    expect(patterns).toEqual([]);
-  });
-
-  it("propagates error if jiti import fails", async () => {
-    const cwd = "/project";
-    const mockExists = vi.mocked(fsExists);
-
-    mockExists.mockImplementation((filePath: string) => {
-      return Promise.resolve(filePath === path.join(cwd, "eslint.config.ts"));
-    });
-
-    mockJitiImportFn.mockRejectedValue(new Error("Syntax error in config file"));
-
-    await expect(loadIgnorePatterns(cwd)).rejects.toThrow("Syntax error in config file");
-  });
 });

package/tests/load-sd-config.spec.ts

@@ -3,7 +3,9 @@ import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
 const mockJitiImport = vi.fn();
 
 vi.mock("@simplysm/core-node", () => ({
-  fsExists: vi.fn(),
+  fsx: {
+    exists: vi.fn(),
+  },
 }));
 
 vi.mock("jiti", () => ({
@@ -12,7 +14,7 @@ vi.mock("jiti", () => ({
   })),
 }));
 
-import { fsExists } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 import { loadSdConfig } from "../src/utils/sd-config";
 
 describe("loadSdConfig", () => {
@@ -25,70 +27,48 @@ describe("loadSdConfig", () => {
   });
 
   it("throws error if sd.config.ts file not found", async () => {
-    vi.mocked(fsExists).mockResolvedValue(false);
+    vi.mocked(fsx.exists).mockResolvedValue(false);
 
-    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+    await expect(loadSdConfig({ cwd: "/project", dev: false, options: [] })).rejects.toThrow(
       "sd.config.ts file not found",
     );
   });
 
   it("throws error if no default export", async () => {
-    vi.mocked(fsExists).mockResolvedValue(true);
+    vi.mocked(fsx.exists).mockResolvedValue(true);
     mockJitiImport.mockResolvedValue({
       someOtherExport: () => ({}),
     });
 
-    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+    await expect(loadSdConfig({ cwd: "/project", dev: false, options: [] })).rejects.toThrow(
       "sd.config.ts must export a function as default",
     );
   });
 
   it("throws error if default export is not function", async () => {
-    vi.mocked(fsExists).mockResolvedValue(true);
+    vi.mocked(fsx.exists).mockResolvedValue(true);
     mockJitiImport.mockResolvedValue({
       default: { packages: {} }, // object not function
     });
 
-    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+    await expect(loadSdConfig({ cwd: "/project", dev: false, options: [] })).rejects.toThrow(
       "sd.config.ts must export a function as default",
     );
   });
 
   it("throws error if return value is wrong format (missing packages)", async () => {
-    vi.mocked(fsExists).mockResolvedValue(true);
+    vi.mocked(fsx.exists).mockResolvedValue(true);
     mockJitiImport.mockResolvedValue({
       default: () => ({}), // missing packages property
     });
 
-    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
-      /sd\.config\.ts return value is not in .* correct format/,
-    );
-  });
-
-  it("throws error if return value is wrong format (packages is array)", async () => {
-    vi.mocked(fsExists).mockResolvedValue(true);
-    mockJitiImport.mockResolvedValue({
-      default: () => ({ packages: [] }), // packages is array
-    });
-
-    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
-      /sd\.config\.ts return value is not in .* correct format/,
-    );
-  });
-
-  it("throws error if return value is wrong format (packages is null)", async () => {
-    vi.mocked(fsExists).mockResolvedValue(true);
-    mockJitiImport.mockResolvedValue({
-      default: () => ({ packages: null }),
-    });
-
-    await expect(loadSdConfig({ cwd: "/project", dev: false, opt: [] })).rejects.toThrow(
+    await expect(loadSdConfig({ cwd: "/project", dev: false, options: [] })).rejects.toThrow(
       /sd\.config\.ts return value is not in .* correct format/,
     );
   });
 
   it("returns correct config", async () => {
-    vi.mocked(fsExists).mockResolvedValue(true);
+    vi.mocked(fsx.exists).mockResolvedValue(true);
     mockJitiImport.mockResolvedValue({
       default: () => ({
         packages: {
@@ -98,7 +78,7 @@ describe("loadSdConfig", () => {
       }),
     });
 
-    const config = await loadSdConfig({ cwd: "/project", dev: false, opt: [] });
+    const config = await loadSdConfig({ cwd: "/project", dev: false, options: [] });
 
     expect(config.packages).toEqual({
       "core-common": { target: "neutral" },
@@ -107,31 +87,14 @@ describe("loadSdConfig", () => {
   });
 
   it("empty packages object is valid", async () => {
-    vi.mocked(fsExists).mockResolvedValue(true);
+    vi.mocked(fsx.exists).mockResolvedValue(true);
     mockJitiImport.mockResolvedValue({
       default: () => ({ packages: {} }),
     });
 
-    const config = await loadSdConfig({ cwd: "/project", dev: false, opt: [] });
+    const config = await loadSdConfig({ cwd: "/project", dev: false, options: [] });
 
     expect(config.packages).toEqual({});
   });
 
-  it("handles async function default export correctly", async () => {
-    vi.mocked(fsExists).mockResolvedValue(true);
-    mockJitiImport.mockResolvedValue({
-      // eslint-disable-next-line @typescript-eslint/require-await
-      default: async () => ({
-        packages: {
-          "core-common": { target: "neutral" },
-        },
-      }),
-    });
-
-    const config = await loadSdConfig({ cwd: "/project", dev: false, opt: [] });
-
-    expect(config.packages).toEqual({
-      "core-common": { target: "neutral" },
-    });
-  });
 });

package/tests/publish-config-narrowing.spec.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import type { SdPublishConfig, SdNpmPublishConfig } from "../src/sd-config.types";
+
+describe("SdPublishConfig", () => {
+  it("all variants have .type field for uniform narrowing", () => {
+    const configs: SdPublishConfig[] = [
+      { type: "npm" },
+      { type: "local-directory", path: "/deploy" },
+      { type: "ftp", host: "example.com" },
+    ];
+
+    const types = configs.map((c) => c.type);
+    expect(types).toEqual(["npm", "local-directory", "ftp"]);
+  });
+
+  it("npm config is an object with type field", () => {
+    const npmConfig: SdNpmPublishConfig = { type: "npm" };
+    expect(npmConfig.type).toBe("npm");
+  });
+});