@simplysm/core-node 13.0.75 → 13.0.77

package/tests/utils/path.spec.ts

@@ -1,89 +1,76 @@
 import { describe, expect, it } from "vitest";
 import path from "path";
 import {
-  pathPosix,
-  pathNorm,
-  pathIsChildPath,
-  pathChangeFileDirectory,
-  pathBasenameWithoutExt,
-  pathFilterByTargets,
+  posix,
+  norm,
+  isChildPath,
+  changeFileDirectory,
+  basenameWithoutExt,
+  filterByTargets,
   type NormPath,
 } from "../../src/utils/path";
 
 describe("path functions", () => {
   //#region posix
 
-  describe("pathPosix", () => {
+  describe("posix", () => {
     it("converts single path argument to POSIX style", () => {
-      const result = pathPosix("C:\\Users\\test\\file.txt");
+      const result = posix("C:\\Users\\test\\file.txt");
       expect(result).toBe("C:/Users/test/file.txt");
     });
 
     it("combines multiple path arguments and converts to POSIX style", () => {
-      const result = pathPosix("C:\\Users", "test", "file.txt");
+      const result = posix("C:\\Users", "test", "file.txt");
       expect(result).toBe("C:/Users/test/file.txt");
     });
 
-    it("keeps already POSIX-style path as is", () => {
-      const result = pathPosix("/usr/local/bin");
-      expect(result).toBe("/usr/local/bin");
-    });
-
-    it("handles mixed path separators", () => {
-      const result = pathPosix("C:/Users\\test/file.txt");
-      expect(result).toBe("C:/Users/test/file.txt");
-    });
   });
 
   //#endregion
 
   //#region norm
 
-  describe("pathNorm", () => {
+  describe("norm", () => {
     it("normalizes path and returns NormPath type", () => {
-      const result: NormPath = pathNorm("./test/../file.txt");
+      const result: NormPath = norm("./test/../file.txt");
       expect(result).toBe(path.resolve("./test/../file.txt"));
     });
 
     it("combines multiple path arguments and normalizes", () => {
       const basePath = path.resolve("/base");
-      const result = pathNorm(basePath, "sub", "file.txt");
+      const result = norm(basePath, "sub", "file.txt");
       expect(result).toBe(path.resolve(basePath, "sub", "file.txt"));
     });
 
-    it("converts relative path to absolute path", () => {
-      const result = pathNorm("relative/path");
-      expect(path.isAbsolute(result)).toBe(true);
-    });
   });
 
   //#endregion
 
   //#region isChildPath
 
-  describe("pathIsChildPath", () => {
+  describe("isChildPath", () => {
     it("returns true for child path", () => {
-      const parent = pathNorm("/parent/dir");
-      const child = pathNorm("/parent/dir/child/file.txt");
-      expect(pathIsChildPath(child, parent)).toBe(true);
+      const parent = norm("/parent/dir");
+      const child = norm("/parent/dir/child/file.txt");
+      expect(isChildPath(child, parent)).toBe(true);
     });
 
     it("returns false for same path", () => {
-      const parent = pathNorm("/parent/dir");
-      const child = pathNorm("/parent/dir");
-      expect(pathIsChildPath(child, parent)).toBe(false);
+      const parent = norm("/parent/dir");
+      const child = norm("/parent/dir");
+      expect(isChildPath(child, parent)).toBe(false);
     });
 
     it("returns false for non-child path", () => {
-      const parent = pathNorm("/parent/dir");
-      const child = pathNorm("/other/dir/file.txt");
-      expect(pathIsChildPath(child, parent)).toBe(false);
+      const parent = norm("/parent/dir");
+      const child = norm("/other/dir/file.txt");
+      expect(isChildPath(child, parent)).toBe(false);
     });
 
     it("returns false when only part of parent path matches", () => {
-      const parent = pathNorm("/parent/dir");
-      const child = pathNorm("/parent/directory/file.txt");
-      expect(pathIsChildPath(child, parent)).toBe(false);
+      const parent = norm("/parent/dir");
+      const child = norm("/parent/directory/file.txt");
+      expect(isChildPath(child, parent)).toBe(false);
     });
   });
 
@@ -91,39 +78,39 @@ describe("path functions", () => {
 
   //#region changeFileDirectory
 
-  describe("pathChangeFileDirectory", () => {
+  describe("changeFileDirectory", () => {
     it("changes file directory", () => {
-      const file = pathNorm("/source/sub/file.txt");
-      const from = pathNorm("/source");
-      const to = pathNorm("/target");
+      const file = norm("/source/sub/file.txt");
+      const from = norm("/source");
+      const to = norm("/target");
 
-      const result = pathChangeFileDirectory(file, from, to);
-      expect(result).toBe(pathNorm("/target/sub/file.txt"));
+      const result = changeFileDirectory(file, from, to);
+      expect(result).toBe(norm("/target/sub/file.txt"));
     });
 
     it("changes directory in nested path", () => {
-      const file = pathNorm("/a/b/c/d/file.txt");
-      const from = pathNorm("/a/b");
-      const to = pathNorm("/x/y");
+      const file = norm("/a/b/c/d/file.txt");
+      const from = norm("/a/b");
+      const to = norm("/x/y");
 
-      const result = pathChangeFileDirectory(file, from, to);
-      expect(result).toBe(pathNorm("/x/y/c/d/file.txt"));
+      const result = changeFileDirectory(file, from, to);
+      expect(result).toBe(norm("/x/y/c/d/file.txt"));
     });
 
     it("throws error when file is not inside fromDirectory", () => {
-      const file = pathNorm("/other/path/file.txt");
-      const from = pathNorm("/source");
-      const to = pathNorm("/target");
+      const file = norm("/other/path/file.txt");
+      const from = norm("/source");
+      const to = norm("/target");
 
-      expect(() => pathChangeFileDirectory(file, from, to)).toThrow();
+      expect(() => changeFileDirectory(file, from, to)).toThrow();
     });
 
     it("returns toDirectory when filePath and fromDirectory are the same", () => {
-      const file = pathNorm("/source");
-      const from = pathNorm("/source");
-      const to = pathNorm("/target");
+      const file = norm("/source");
+      const from = norm("/source");
+      const to = norm("/target");
 
-      const result = pathChangeFileDirectory(file, from, to);
+      const result = changeFileDirectory(file, from, to);
       expect(result).toBe(to);
     });
   });
@@ -132,24 +119,24 @@ describe("path functions", () => {
 
   //#region basenameWithoutExt
 
-  describe("pathBasenameWithoutExt", () => {
+  describe("basenameWithoutExt", () => {
     it("removes single extension (returns basename only)", () => {
-      const result = pathBasenameWithoutExt("/path/to/file.txt");
+      const result = basenameWithoutExt("/path/to/file.txt");
       expect(result).toBe("file");
     });
 
     it("removes only last extension in multiple extensions", () => {
-      const result = pathBasenameWithoutExt("/path/to/file.spec.ts");
+      const result = basenameWithoutExt("/path/to/file.spec.ts");
       expect(result).toBe("file.spec");
     });
 
     it("returns basename for file without extension", () => {
-      const result = pathBasenameWithoutExt("/path/to/file");
+      const result = basenameWithoutExt("/path/to/file");
       expect(result).toBe("file");
     });
 
     it("returns hidden file (starting with dot) as is", () => {
-      const result = pathBasenameWithoutExt("/path/to/.gitignore");
+      const result = basenameWithoutExt("/path/to/.gitignore");
       expect(result).toBe(".gitignore");
     });
   });
@@ -158,32 +145,32 @@ describe("path functions", () => {
 
   //#region filterByTargets
 
-  describe("pathFilterByTargets", () => {
+  describe("filterByTargets", () => {
     const cwd = "/proj";
     const files = ["/proj/src/a.ts", "/proj/src/b.ts", "/proj/tests/c.ts", "/proj/lib/d.ts"];
 
     it("returns all files if targets array is empty", () => {
-      const result = pathFilterByTargets(files, [], cwd);
+      const result = filterByTargets(files, [], cwd);
       expect(result).toEqual(files);
     });
 
     it("filters by single target", () => {
-      const result = pathFilterByTargets(files, ["src"], cwd);
+      const result = filterByTargets(files, ["src"], cwd);
       expect(result).toEqual(["/proj/src/a.ts", "/proj/src/b.ts"]);
     });
 
     it("filters by multiple targets", () => {
-      const result = pathFilterByTargets(files, ["src", "tests"], cwd);
+      const result = filterByTargets(files, ["src", "tests"], cwd);
       expect(result).toEqual(["/proj/src/a.ts", "/proj/src/b.ts", "/proj/tests/c.ts"]);
     });
 
     it("returns empty array when no matching file is found", () => {
-      const result = pathFilterByTargets(files, ["nonexistent"], cwd);
+      const result = filterByTargets(files, ["nonexistent"], cwd);
       expect(result).toEqual([]);
     });
 
     it("filters by exact file path", () => {
-      const result = pathFilterByTargets(files, ["src/a.ts"], cwd);
+      const result = filterByTargets(files, ["src/a.ts"], cwd);
       expect(result).toEqual(["/proj/src/a.ts"]);
     });
   });

package/tests/worker/sd-worker.spec.ts

@@ -154,21 +154,6 @@ describe("SdWorker", () => {
 
   //#endregion
 
-  //#region stdout/stderr
-
-  describe("stdout/stderr", () => {
-    it("forwards worker console.log output to main process", async () => {
-      worker = Worker.create<typeof TestWorkerModule>(workerPath);
-
-      const result = await worker.logMessage("test message");
-
-      // If method returns normally, stdout piping is working
-      expect(result).toBe("logged");
-    });
-  });
-
-  //#endregion
-
   //#region env option
 
   describe("env option", () => {