@simplysm/sd-cli 13.0.75 → 13.0.76

package/tests/run-typecheck.spec.ts

@@ -270,117 +270,6 @@ describe("runTypecheck", () => {
     expect(process.exitCode).toBeUndefined();
   });
 
-  it("uses default value when default export is not a function", async () => {
-    vi.mocked(ts.readConfigFile).mockReturnValue({
-      config: {},
-    });
-
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024"], types: [] },
-      fileNames: ["/project/packages/core-common/src/index.ts"],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
-
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
-
-    // When sd.config.ts's default export is an object, not a function
-    mockJitiImport.mockResolvedValue({
-      default: { packages: {} }, // object, not a function
-    });
-
-    vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
-    );
-
-    // Should proceed with default value without error
-    await runTypecheck({ targets: [], options: [] });
-
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it("uses default value when no default export in sd.config.ts", async () => {
-    vi.mocked(ts.readConfigFile).mockReturnValue({
-      config: {},
-    });
-
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024"], types: [] },
-      fileNames: ["/project/packages/core-common/src/index.ts"],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
-
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
-
-    // When sd.config.ts has no default export
-    mockJitiImport.mockResolvedValue({
-      someOtherExport: () => ({}),
-    });
-
-    const { Worker } = await import("@simplysm/core-node");
-    vi.mocked(Worker.create).mockReturnValue({
-      build: vi.fn(() =>
-        Promise.resolve({
-          success: true,
-          diagnostics: [],
-          errorCount: 0,
-          warningCount: 0,
-        }),
-      ),
-      terminate: vi.fn(() => Promise.resolve()),
-    } as unknown as ReturnType<typeof Worker.create>);
-
-    vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
-    );
-
-    // Should proceed with default value without error
-    await runTypecheck({ targets: [], options: [] });
-
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it("typecheck multiple packages", async () => {
-    vi.mocked(ts.readConfigFile).mockReturnValue({
-      config: {},
-    });
-
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024", "DOM"], types: [] },
-      fileNames: [
-        "/project/packages/core-node/src/index.ts",
-        "/project/packages/core-browser/src/index.ts",
-        "/project/packages/core-common/src/index.ts",
-      ],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
-
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
-
-    const { Worker } = await import("@simplysm/core-node");
-    vi.mocked(Worker.create).mockReturnValue({
-      build: vi.fn(() =>
-        Promise.resolve({
-          success: true,
-          diagnostics: [],
-          errorCount: 0,
-          warningCount: 0,
-        }),
-      ),
-      terminate: vi.fn(() => Promise.resolve()),
-    } as unknown as ReturnType<typeof Worker.create>);
-
-    vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
-    );
-
-    await runTypecheck({ targets: [], options: [] });
-
-    expect(process.exitCode).toBeUndefined();
-  });
-
   it("sets exitCode to 1 when typecheck errors occur", async () => {
     vi.mocked(ts.readConfigFile).mockReturnValue({ config: {} });
 
@@ -486,44 +375,6 @@ describe("runTypecheck", () => {
     expect(pkgCall).toBeDefined();
   });
 
-  it("does not create other task when only packages/ files exist", async () => {
-    vi.mocked(ts.readConfigFile).mockReturnValue({ config: {} });
-
-    vi.mocked(ts.parseJsonConfigFileContent).mockReturnValue({
-      options: { lib: ["ES2024"], types: [] },
-      fileNames: ["/project/packages/core-common/src/index.ts"],
-      errors: [],
-    } as unknown as ts.ParsedCommandLine);
-
-    vi.mocked(fsExists).mockResolvedValue(false);
-    vi.mocked(fsReadJson).mockResolvedValue({ devDependencies: {} });
-
-    vi.mocked(ts.sortAndDeduplicateDiagnostics).mockReturnValue(
-      [] as unknown as ts.SortedReadonlyArray<ts.Diagnostic>,
-    );
-
-    const { Worker } = await import("@simplysm/core-node");
-    const mockBuildDts = vi.fn(() =>
-      Promise.resolve({
-        success: true,
-        diagnostics: [],
-        errorCount: 0,
-        warningCount: 0,
-      }),
-    );
-    vi.mocked(Worker.create).mockReturnValue({
-      build: mockBuildDts,
-      terminate: vi.fn(() => Promise.resolve()),
-    } as unknown as ReturnType<typeof Worker.create>);
-
-    await runTypecheck({ targets: [], options: [] });
-
-    // Should have no call with name="root"
-    const nonPkgCall = (mockBuildDts.mock.calls as unknown[][]).find(
-      (call) => (call[0] as { name: string }).name === "root",
-    );
-    expect(nonPkgCall).toBeUndefined();
-  });
 });
 
 describe("executeTypecheck", () => {
@@ -631,23 +482,4 @@ describe("executeTypecheck", () => {
     expect(process.exitCode).toBeUndefined();
   });
 
-  it("returns failure result when tsconfig.json fails to load", async () => {
-    const { executeTypecheck } = await import("../src/commands/typecheck");
-
-    vi.mocked(ts.readConfigFile).mockReturnValue({
-      error: {
-        category: ts.DiagnosticCategory.Error,
-        messageText: "Failed to read tsconfig.json",
-      } as ts.Diagnostic,
-    });
-
-    vi.mocked(ts.formatDiagnosticsWithColorAndContext).mockReturnValue("");
-
-    const result = await executeTypecheck({ targets: [], options: [] });
-
-    expect(result.success).toBe(false);
-    expect(result.errorCount).toBe(1);
-    // executeTypecheck should not set process.exitCode
-    expect(process.exitCode).toBeUndefined();
-  });
 });

package/tests/run-watch.spec.ts

@@ -38,38 +38,4 @@ describe("filterPackagesByTargets", () => {
     expect(result["core-node"]).toEqual({ target: "node" });
   });
 
-  it("returns empty result when specifying non-existent package", () => {
-    const result = filterPackagesByTargets(mockPackages, ["non-existent"]);
-
-    expect(Object.keys(result)).toHaveLength(0);
-  });
-
-  it("ignores undefined package config", () => {
-    const result = filterPackagesByTargets(mockPackages, ["empty-pkg"]);
-
-    expect(Object.keys(result)).toHaveLength(0);
-  });
-
-  it("filters client target packages", () => {
-    const result = filterPackagesByTargets(mockPackages, ["solid-demo"]);
-
-    expect(Object.keys(result)).toHaveLength(1);
-    expect(result["solid-demo"]).toEqual({ target: "client", server: 3000 });
-  });
-
-  it("handles empty packages object", () => {
-    const result = filterPackagesByTargets({}, []);
-
-    expect(Object.keys(result)).toHaveLength(0);
-  });
-
-  it("handles case where all packages are scripts", () => {
-    const scriptsOnly: Record<string, SdPackageConfig> = {
-      pkg1: { target: "scripts" },
-      pkg2: { target: "scripts" },
-    };
-    const result = filterPackagesByTargets(scriptsOnly, []);
-
-    expect(Object.keys(result)).toHaveLength(0);
-  });
 });

package/tests/sd-cli.spec.ts

@@ -74,15 +74,6 @@ describe("sd-cli", () => {
       });
     });
 
-    it("runs lint command without targets", async () => {
-      await createCliParser(["lint"]).parse();
-
-      expect(runLint).toHaveBeenCalledWith({
-        targets: [],
-        fix: false,
-        timing: false,
-      });
-    });
   });
 
   describe("typecheck command", () => {
@@ -124,15 +115,6 @@ describe("sd-cli", () => {
       });
     });
 
-    it("runs check command without targets", async () => {
-      await createCliParser(["check"]).parse();
-
-      expect(runCheck).toHaveBeenCalledWith({
-        targets: [],
-        types: ["typecheck", "lint", "test"],
-      });
-    });
-
     it("specifies single type using --type option", async () => {
       await createCliParser(["check", "--type", "test"]).parse();
 
@@ -153,32 +135,6 @@ describe("sd-cli", () => {
       });
     });
 
-    it("passes multiple targets to watch command", async () => {
-      await createCliParser(["watch", "solid", "solid-demo"]).parse();
-
-      expect(runWatch).toHaveBeenCalledWith({
-        targets: ["solid", "solid-demo"],
-        options: [],
-      });
-    });
-
-    it("runs watch command without targets", async () => {
-      await createCliParser(["watch"]).parse();
-
-      expect(runWatch).toHaveBeenCalledWith({
-        targets: [],
-        options: [],
-      });
-    });
-
-    it("passes --options option correctly", async () => {
-      await createCliParser(["watch", "-o", "dev"]).parse();
-
-      expect(runWatch).toHaveBeenCalledWith({
-        targets: [],
-        options: ["dev"],
-      });
-    });
   });
 
   describe("build command", () => {
@@ -191,23 +147,6 @@ describe("sd-cli", () => {
       });
     });
 
-    it("runs build command without targets", async () => {
-      await createCliParser(["build"]).parse();
-
-      expect(runBuild).toHaveBeenCalledWith({
-        targets: [],
-        options: [],
-      });
-    });
-
-    it("passes --options option correctly", async () => {
-      await createCliParser(["build", "-o", "prod"]).parse();
-
-      expect(runBuild).toHaveBeenCalledWith({
-        targets: [],
-        options: ["prod"],
-      });
-    });
   });
 
   describe("publish command", () => {
@@ -222,17 +161,6 @@ describe("sd-cli", () => {
       });
     });
 
-    it("runs publish command without targets", async () => {
-      await createCliParser(["publish"]).parse();
-
-      expect(runPublish).toHaveBeenCalledWith({
-        targets: [],
-        noBuild: false,
-        dryRun: false,
-        options: [],
-      });
-    });
-
     it("passes --no-build option correctly", async () => {
       await createCliParser(["publish", "--no-build"]).parse();
 
@@ -277,16 +205,6 @@ describe("sd-cli", () => {
       });
     });
 
-    it("uses --dry-run with other options together", async () => {
-      await createCliParser(["publish", "solid", "--dry-run", "-o", "prod"]).parse();
-
-      expect(runPublish).toHaveBeenCalledWith({
-        targets: ["solid"],
-        noBuild: false,
-        dryRun: true,
-        options: ["prod"],
-      });
-    });
   });
 
   describe("global --debug option", () => {
@@ -296,12 +214,6 @@ describe("sd-cli", () => {
       expect(consola.level).toBe(LogLevels.debug);
     });
 
-    it("does not change consola.level without --debug", async () => {
-      const levelBefore = consola.level;
-      await createCliParser(["lint"]).parse();
-
-      expect(consola.level).toBe(levelBefore);
-    });
   });
 
   describe("error handling", () => {

package/templates/init/stylelint.config.ts

@@ -1 +0,0 @@
-export { default } from "@simplysm/lint/stylelint-recommended";