@simplysm/sd-cli 13.0.100 → 14.0.1

package/tests/sd-cli.spec.ts

@@ -1,265 +0,0 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-import { consola, LogLevels } from "consola";
-
-// Mock runLint, runTypecheck, runWatch, runCheck
-vi.mock("../src/commands/lint", () => ({
-  runLint: vi.fn(),
-}));
-
-vi.mock("../src/commands/typecheck", () => ({
-  runTypecheck: vi.fn(),
-}));
-
-vi.mock("../src/commands/check", () => ({
-  runCheck: vi.fn(),
-}));
-
-vi.mock("../src/commands/watch", () => ({
-  runWatch: vi.fn(),
-}));
-
-vi.mock("../src/commands/build", () => ({
-  runBuild: vi.fn(),
-}));
-
-vi.mock("../src/commands/publish", () => ({
-  runPublish: vi.fn(),
-}));
-
-import { createCliParser } from "../src/sd-cli-entry";
-import { runLint } from "../src/commands/lint";
-import { runTypecheck } from "../src/commands/typecheck";
-import { runCheck } from "../src/commands/check";
-import { runWatch } from "../src/commands/watch";
-import { runBuild } from "../src/commands/build";
-import { runPublish } from "../src/commands/publish";
-
-describe("sd-cli", () => {
-  let originalConsolaLevel: number;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(runLint).mockResolvedValue(undefined);
-    vi.mocked(runTypecheck).mockResolvedValue(undefined);
-    vi.mocked(runCheck).mockResolvedValue(undefined);
-    vi.mocked(runWatch).mockResolvedValue(undefined);
-    vi.mocked(runBuild).mockResolvedValue(undefined);
-    vi.mocked(runPublish).mockResolvedValue(undefined);
-    originalConsolaLevel = consola.level;
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    consola.level = originalConsolaLevel;
-  });
-
-  describe("lint command", () => {
-    it("calls runLint with correct options", async () => {
-      await createCliParser(["lint", "packages/core-common", "--fix"]).parse();
-
-      expect(runLint).toHaveBeenCalledWith({
-        targets: ["packages/core-common"],
-        fix: true,
-        timing: false,
-      });
-    });
-
-    it("passes --timing option correctly", async () => {
-      await createCliParser(["lint", "--timing"]).parse();
-
-      expect(runLint).toHaveBeenCalledWith({
-        targets: [],
-        fix: false,
-        timing: true,
-      });
-    });
-
-  });
-
-  describe("typecheck command", () => {
-    it("calls runTypecheck with correct options", async () => {
-      await createCliParser(["typecheck", "packages/cli"]).parse();
-
-      expect(runTypecheck).toHaveBeenCalledWith({
-        targets: ["packages/cli"],
-        options: [],
-      });
-    });
-
-    it("passes multiple targets to typecheck command", async () => {
-      await createCliParser(["typecheck", "packages/core-common", "packages/core-node"]).parse();
-
-      expect(runTypecheck).toHaveBeenCalledWith({
-        targets: ["packages/core-common", "packages/core-node"],
-        options: [],
-      });
-    });
-
-    it("passes --options option correctly", async () => {
-      await createCliParser(["typecheck", "-o", "dev", "-o", "test"]).parse();
-
-      expect(runTypecheck).toHaveBeenCalledWith({
-        targets: [],
-        options: ["dev", "test"],
-      });
-    });
-  });
-
-  describe("check command", () => {
-    it("calls runCheck with correct options", async () => {
-      await createCliParser(["check", "packages/core-common", "--type", "typecheck,lint"]).parse();
-
-      expect(runCheck).toHaveBeenCalledWith({
-        targets: ["packages/core-common"],
-        types: ["typecheck", "lint"],
-      });
-    });
-
-    it("specifies single type using --type option", async () => {
-      await createCliParser(["check", "--type", "test"]).parse();
-
-      expect(runCheck).toHaveBeenCalledWith({
-        targets: [],
-        types: ["test"],
-      });
-    });
-  });
-
-  describe("watch command", () => {
-    it("calls runWatch with correct options", async () => {
-      await createCliParser(["watch", "solid"]).parse();
-
-      expect(runWatch).toHaveBeenCalledWith({
-        targets: ["solid"],
-        options: [],
-      });
-    });
-
-  });
-
-  describe("build command", () => {
-    it("calls runBuild with correct options", async () => {
-      await createCliParser(["build", "solid", "core-common"]).parse();
-
-      expect(runBuild).toHaveBeenCalledWith({
-        targets: ["solid", "core-common"],
-        options: [],
-      });
-    });
-
-  });
-
-  describe("publish command", () => {
-    it("calls runPublish with correct options", async () => {
-      await createCliParser(["publish", "solid", "core-common"]).parse();
-
-      expect(runPublish).toHaveBeenCalledWith({
-        targets: ["solid", "core-common"],
-        noBuild: false,
-        dryRun: false,
-        options: [],
-      });
-    });
-
-    it("passes --no-build option correctly", async () => {
-      await createCliParser(["publish", "--no-build"]).parse();
-
-      expect(runPublish).toHaveBeenCalledWith({
-        targets: [],
-        noBuild: true,
-        dryRun: false,
-        options: [],
-      });
-    });
-
-    it("passes --options option correctly", async () => {
-      await createCliParser(["publish", "-o", "prod", "-o", "test"]).parse();
-
-      expect(runPublish).toHaveBeenCalledWith({
-        targets: [],
-        noBuild: false,
-        dryRun: false,
-        options: ["prod", "test"],
-      });
-    });
-
-    it("passes all options together", async () => {
-      await createCliParser(["publish", "solid", "--no-build", "-o", "prod"]).parse();
-
-      expect(runPublish).toHaveBeenCalledWith({
-        targets: ["solid"],
-        noBuild: true,
-        dryRun: false,
-        options: ["prod"],
-      });
-    });
-
-    it("passes --dry-run option correctly", async () => {
-      await createCliParser(["publish", "--dry-run"]).parse();
-
-      expect(runPublish).toHaveBeenCalledWith({
-        targets: [],
-        noBuild: false,
-        dryRun: true,
-        options: [],
-      });
-    });
-
-  });
-
-  describe("global --debug option", () => {
-    it("sets consola.level to debug with --debug option", async () => {
-      await createCliParser(["--debug", "lint"]).parse();
-
-      expect(consola.level).toBe(LogLevels.debug);
-    });
-
-  });
-
-  describe("--help shows all commands", () => {
-    it("shows help for all commands", async () => {
-      const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-
-      await createCliParser(["--help"]).parse();
-
-      const output = logSpy.mock.calls.map((c) => c.join(" ")).join("\n");
-
-      // All command names are included in the output
-      for (const cmd of ["lint", "typecheck", "check", "watch", "dev", "build", "device", "init", "publish", "replace-deps"]) {
-        expect(output).toContain(cmd);
-      }
-
-      // Each command's unique options are included in the output
-      expect(output).toContain("--fix");
-      expect(output).toContain("--timing");
-      expect(output).toContain("--no-build");
-      expect(output).toContain("--dry-run");
-
-      logSpy.mockRestore();
-    });
-  });
-
-  describe("error handling", () => {
-    it("throws error on unknown command", async () => {
-      let errorMessage: string | undefined;
-      const parser = createCliParser(["unknown"]).fail((msg) => {
-        errorMessage = msg;
-      });
-
-      await parser.parse();
-
-      expect(errorMessage).toMatch(/Unknown argument|알 수 없는 인수/);
-    });
-
-    it("throws error when no command specified", async () => {
-      let errorMessage: string | undefined;
-      const parser = createCliParser([]).fail((msg) => {
-        errorMessage = msg;
-      });
-
-      await parser.parse();
-
-      expect(errorMessage).toMatch(/Please specify a command/);
-    });
-  });
-});

package/tests/sd-public-dev-plugin-mime.spec.ts

@@ -1,19 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getMimeType } from "../src/utils/vite-config";
-
-describe("getMimeType", () => {
-  it("returns correct MIME for common web types", () => {
-    expect(getMimeType(".html")).toBe("text/html");
-    expect(getMimeType(".css")).toBe("text/css");
-    expect(getMimeType(".js")).toBe("text/javascript");
-    expect(getMimeType(".json")).toBe("application/json");
-    expect(getMimeType(".png")).toBe("image/png");
-    expect(getMimeType(".svg")).toBe("image/svg+xml");
-    expect(getMimeType(".woff2")).toBe("font/woff2");
-  });
-
-  it("returns application/octet-stream for unknown extensions", () => {
-    expect(getMimeType(".xyz")).toBe("application/octet-stream");
-    expect(getMimeType("")).toBe("application/octet-stream");
-  });
-});

package/tests/tailwind-config-deps.spec.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from "vitest";
-import path from "path";
-import { getTailwindConfigDeps } from "../src/utils/tailwind-config-deps";
-
-const packagesDir = path.resolve(import.meta.dirname, "../..");
-
-describe("getTailwindConfigDeps", () => {
-  it("includes solid tailwind config in dependencies of solid-demo tailwind config", () => {
-    const configPath = path.join(packagesDir, "solid-demo/tailwind.config.ts");
-    const deps = getTailwindConfigDeps(configPath, ["@simplysm"]);
-
-    const solidConfig = path.join(packagesDir, "solid/tailwind.config.ts");
-    expect(deps).toContain(solidConfig);
-  });
-
-  it("includes the config itself in dependencies", () => {
-    const configPath = path.join(packagesDir, "solid-demo/tailwind.config.ts");
-    const deps = getTailwindConfigDeps(configPath, ["@simplysm"]);
-
-    expect(deps).toContain(path.resolve(configPath));
-  });
-
-  it("excludes packages outside @simplysm/ (like tailwindcss/colors)", () => {
-    const configPath = path.join(packagesDir, "solid/tailwind.config.ts");
-    const deps = getTailwindConfigDeps(configPath, ["@simplysm"]);
-
-    // solid/tailwind.config.ts imports tailwindcss/colors but does not track it
-    expect(deps).toHaveLength(1); // only itself
-  });
-});

package/tests/template.spec.ts

@@ -1,70 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
-import path from "path";
-import os from "os";
-import fs from "fs";
-import { renderTemplateDir } from "../src/utils/template";
-
-describe("renderTemplateDir", () => {
-  let tmpDir: string;
-  let srcDir: string;
-  let destDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sd-template-test-"));
-    srcDir = path.join(tmpDir, "src");
-    destDir = path.join(tmpDir, "dest");
-    fs.mkdirSync(srcDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true });
-  });
-
-  test("renders .hbs files with context and removes .hbs extension", async () => {
-    fs.writeFileSync(path.join(srcDir, "hello.txt.hbs"), "Hello, {{name}}!");
-    await renderTemplateDir(srcDir, destDir, { name: "World" });
-    expect(fs.readFileSync(path.join(destDir, "hello.txt"), "utf-8")).toBe("Hello, World!");
-  });
-
-  test("copies non-.hbs files as-is (binary safe)", async () => {
-    const binaryData = Uint8Array.from([0x00, 0x01, 0xff, 0xfe]);
-    fs.writeFileSync(path.join(srcDir, "icon.bin"), binaryData);
-    await renderTemplateDir(srcDir, destDir, {});
-    const copied = fs.readFileSync(path.join(destDir, "icon.bin"));
-    expect(new Uint8Array(copied)).toEqual(binaryData);
-  });
-
-  test("replaces directory name placeholders", async () => {
-    const subDir = path.join(srcDir, "__CLIENT__");
-    fs.mkdirSync(subDir, { recursive: true });
-    fs.writeFileSync(path.join(subDir, "file.txt.hbs"), "pkg: {{clientName}}");
-    await renderTemplateDir(
-      srcDir,
-      destDir,
-      { clientName: "client-admin" },
-      { __CLIENT__: "client-admin" },
-    );
-    expect(fs.readFileSync(path.join(destDir, "client-admin", "file.txt"), "utf-8")).toBe(
-      "pkg: client-admin",
-    );
-  });
-
-  test("skips file when .hbs renders to empty/whitespace", async () => {
-    fs.writeFileSync(path.join(srcDir, "optional.ts.hbs"), "{{#if enabled}}content{{/if}}");
-    await renderTemplateDir(srcDir, destDir, { enabled: false });
-    expect(fs.existsSync(path.join(destDir, "optional.ts"))).toBe(false);
-  });
-
-  test("handles nested directories", async () => {
-    fs.mkdirSync(path.join(srcDir, "a", "b"), { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "a", "b", "deep.txt.hbs"), "{{value}}");
-    await renderTemplateDir(srcDir, destDir, { value: "nested" });
-    expect(fs.readFileSync(path.join(destDir, "a", "b", "deep.txt"), "utf-8")).toBe("nested");
-  });
-
-  test("preserves Handlebars {{#if}} conditional blocks", async () => {
-    fs.writeFileSync(path.join(srcDir, "test.txt.hbs"), "start\n{{#if flag}}included\n{{/if}}end");
-    await renderTemplateDir(srcDir, destDir, { flag: true });
-    expect(fs.readFileSync(path.join(destDir, "test.txt"), "utf-8")).toBe("start\nincluded\nend");
-  });
-});

package/tests/vite-config-exclude.spec.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createViteConfig } from "../src/utils/vite-config";
-import path from "path";
-
-describe("createViteConfig exclude option", () => {
-  const baseOptions = {
-    pkgDir: path.resolve(__dirname, ".."),
-    name: "test-app",
-    tsconfigPath: path.resolve(__dirname, "../../..", "tsconfig.json"),
-    compilerOptions: {},
-    mode: "build" as const,
-  };
-
-  it("should set optimizeDeps.exclude when exclude option is provided", () => {
-    const config = createViteConfig({ ...baseOptions, exclude: ["jeep-sqlite"] });
-
-    expect(config.optimizeDeps?.exclude).toContain("jeep-sqlite");
-  });
-
-  it("should not set optimizeDeps.exclude when exclude option is not provided", () => {
-    const config = createViteConfig(baseOptions);
-
-    expect(config.optimizeDeps?.exclude).toBeUndefined();
-  });
-
-  it("should handle multiple exclude packages", () => {
-    const config = createViteConfig({
-      ...baseOptions,
-      exclude: ["jeep-sqlite", "electron"],
-    });
-
-    expect(config.optimizeDeps?.exclude).toContain("jeep-sqlite");
-    expect(config.optimizeDeps?.exclude).toContain("electron");
-  });
-});

package/tests/vite-config-outdir.spec.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createViteConfig } from "../src/utils/vite-config";
-import path from "path";
-
-describe("createViteConfig capacitor overrides", () => {
-  const baseOptions = {
-    pkgDir: path.resolve(__dirname, ".."),
-    name: "test-app",
-    tsconfigPath: path.resolve(__dirname, "../../..", "tsconfig.json"),
-    compilerOptions: {},
-    mode: "build" as const,
-  };
-
-  it("should set build.outDir when outDir option is provided", () => {
-    const outDir = path.join(baseOptions.pkgDir, ".capacitor", "www");
-    const config = createViteConfig({ ...baseOptions, outDir });
-
-    expect(config.build?.outDir).toBe(outDir);
-  });
-
-  it("should not set build.outDir when outDir option is not provided", () => {
-    const config = createViteConfig(baseOptions);
-
-    expect(config.build?.outDir).toBeUndefined();
-  });
-
-  it("should override base when base option is provided", () => {
-    const config = createViteConfig({ ...baseOptions, base: "./" });
-
-    expect(config.base).toBe("./");
-  });
-
-  it("should use /{name}/ as base when base option is not provided", () => {
-    const config = createViteConfig(baseOptions);
-
-    expect(config.base).toBe("/test-app/");
-  });
-});

package/tests/write-changed-output-files.spec.ts

@@ -1,97 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import path from "path";
-import os from "os";
-import fs from "fs/promises";
-import type esbuild from "esbuild";
-import { writeChangedOutputFiles } from "../src/utils/esbuild-config";
-
-function makeOutputFile(filePath: string, text: string): esbuild.OutputFile {
-  const contents = new TextEncoder().encode(text);
-  return { path: filePath, contents, text, hash: "" };
-}
-
-describe("writeChangedOutputFiles", () => {
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "esbuild-write-"));
-  });
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true });
-  });
-
-  it("writes new files that don't exist on disk", async () => {
-    const outFile = makeOutputFile(path.join(tmpDir, "index.js"), "const x = 1;\n");
-    await writeChangedOutputFiles([outFile]);
-
-    const result = await fs.readFile(path.join(tmpDir, "index.js"), "utf-8");
-    expect(result).toBe("const x = 1;\n");
-  });
-
-  it("skips writing when content is identical", async () => {
-    const filePath = path.join(tmpDir, "index.js");
-    await fs.writeFile(filePath, "const x = 1;\n");
-    const statBefore = await fs.stat(filePath);
-
-    // Small delay to ensure mtime would differ if file were rewritten
-    await new Promise((r) => setTimeout(r, 50));
-
-    const outFile = makeOutputFile(filePath, "const x = 1;\n");
-    await writeChangedOutputFiles([outFile]);
-
-    const statAfter = await fs.stat(filePath);
-    expect(statAfter.mtimeMs).toBe(statBefore.mtimeMs);
-  });
-
-  it("writes when content differs", async () => {
-    const filePath = path.join(tmpDir, "index.js");
-    await fs.writeFile(filePath, "const x = 1;\n");
-
-    const outFile = makeOutputFile(filePath, "const x = 2;\n");
-    await writeChangedOutputFiles([outFile]);
-
-    const result = await fs.readFile(filePath, "utf-8");
-    expect(result).toBe("const x = 2;\n");
-  });
-
-  it("adds .js extension to relative imports in .js files", async () => {
-    const filePath = path.join(tmpDir, "index.js");
-    const outFile = makeOutputFile(filePath, 'import { foo } from "./utils";\nexport { foo };\n');
-    await writeChangedOutputFiles([outFile]);
-
-    const result = await fs.readFile(filePath, "utf-8");
-    expect(result).toBe('import { foo } from "./utils.js";\nexport { foo };\n');
-  });
-
-  it("does not add .js extension to imports that already have known extensions", async () => {
-    const filePath = path.join(tmpDir, "index.js");
-    const outFile = makeOutputFile(
-      filePath,
-      'import "./styles.css";\nimport data from "./data.json";\n',
-    );
-    await writeChangedOutputFiles([outFile]);
-
-    const result = await fs.readFile(filePath, "utf-8");
-    expect(result).toBe('import "./styles.css";\nimport data from "./data.json";\n');
-  });
-
-  it("does not rewrite imports in .js.map files", async () => {
-    const filePath = path.join(tmpDir, "index.js.map");
-    const content = '{"sources":["./utils"]}';
-    const outFile = makeOutputFile(filePath, content);
-    await writeChangedOutputFiles([outFile]);
-
-    const result = await fs.readFile(filePath, "utf-8");
-    expect(result).toBe(content);
-  });
-
-  it("creates parent directories if needed", async () => {
-    const filePath = path.join(tmpDir, "sub", "deep", "index.js");
-    const outFile = makeOutputFile(filePath, "export {};\n");
-    await writeChangedOutputFiles([outFile]);
-
-    const result = await fs.readFile(filePath, "utf-8");
-    expect(result).toBe("export {};\n");
-  });
-});