@simplysm/core-node 13.0.75 → 13.0.77

package/src/utils/path.ts

@@ -7,7 +7,7 @@ const NORM = Symbol("NormPath");
 
 /**
  * Brand type representing a normalized path.
- * Can only be created through pathNorm().
+ * Can only be created through norm().
  */
 export type NormPath = string & {
   [NORM]: never;
@@ -21,10 +21,10 @@ export type NormPath = string & {
  * Converts to POSIX-style path (backslash → forward slash).
  *
  * @example
- * pathPosix("C:\\Users\\test"); // "C:/Users/test"
- * pathPosix("src", "index.ts"); // "src/index.ts"
+ * posix("C:\\Users\\test"); // "C:/Users/test"
+ * posix("src", "index.ts"); // "src/index.ts"
  */
-export function pathPosix(...args: string[]): string {
+export function posix(...args: string[]): string {
   const resolvedPath = path.join(...args);
   return resolvedPath.replace(/\\/g, "/");
 }
@@ -33,12 +33,12 @@ export function pathPosix(...args: string[]): string {
  * Changes the directory of a file path.
  *
  * @example
- * pathChangeFileDirectory("/a/b/c.txt", "/a", "/x");
+ * changeFileDirectory("/a/b/c.txt", "/a", "/x");
  * // → "/x/b/c.txt"
  *
  * @throws Error if the file is not inside fromDirectory
  */
-export function pathChangeFileDirectory(
+export function changeFileDirectory(
   filePath: string,
   fromDirectory: string,
   toDirectory: string,
@@ -47,7 +47,7 @@ export function pathChangeFileDirectory(
     return toDirectory;
   }
 
-  if (!pathIsChildPath(filePath, fromDirectory)) {
+  if (!isChildPath(filePath, fromDirectory)) {
     throw new ArgumentError(`'${filePath}' is not inside ${fromDirectory}.`, {
       filePath,
       fromDirectory,
@@ -61,10 +61,10 @@ export function pathChangeFileDirectory(
  * Returns the filename (basename) without extension.
  *
  * @example
- * pathBasenameWithoutExt("file.txt"); // "file"
- * pathBasenameWithoutExt("/path/to/file.spec.ts"); // "file.spec"
+ * basenameWithoutExt("file.txt"); // "file"
+ * basenameWithoutExt("/path/to/file.spec.ts"); // "file.spec"
  */
-export function pathBasenameWithoutExt(filePath: string): string {
+export function basenameWithoutExt(filePath: string): string {
   return path.basename(filePath, path.extname(filePath));
 }
 
@@ -72,17 +72,17 @@ export function pathBasenameWithoutExt(filePath: string): string {
  * Checks if childPath is a child path of parentPath.
  * Returns false if the paths are the same.
  *
- * Paths are internally normalized using `pathNorm()` and compared using
+ * Paths are internally normalized using `norm()` and compared using
  * platform-specific path separators (Windows: `\`, Unix: `/`).
  *
  * @example
- * pathIsChildPath("/a/b/c", "/a/b"); // true
- * pathIsChildPath("/a/b", "/a/b/c"); // false
- * pathIsChildPath("/a/b", "/a/b"); // false (same path)
+ * isChildPath("/a/b/c", "/a/b"); // true
+ * isChildPath("/a/b", "/a/b/c"); // false
+ * isChildPath("/a/b", "/a/b"); // false (same path)
  */
-export function pathIsChildPath(childPath: string, parentPath: string): boolean {
-  const normalizedChild = pathNorm(childPath);
-  const normalizedParent = pathNorm(parentPath);
+export function isChildPath(childPath: string, parentPath: string): boolean {
+  const normalizedChild = norm(childPath);
+  const normalizedParent = norm(parentPath);
 
   // Same path returns false
   if (normalizedChild === normalizedParent) {
@@ -102,10 +102,10 @@ export function pathIsChildPath(childPath: string, parentPath: string): boolean
  * Converts to absolute path and normalizes using platform-specific separators.
  *
  * @example
- * pathNorm("/some/path"); // NormPath
- * pathNorm("relative", "path"); // NormPath (converted to absolute path)
+ * norm("/some/path"); // NormPath
+ * norm("relative", "path"); // NormPath (converted to absolute path)
  */
-export function pathNorm(...paths: string[]): NormPath {
+export function norm(...paths: string[]): NormPath {
   return path.resolve(...paths) as NormPath;
 }
 
@@ -122,14 +122,14 @@ export function pathNorm(...paths: string[]): NormPath {
  *
  * @example
  * const files = ["/proj/src/a.ts", "/proj/src/b.ts", "/proj/tests/c.ts"];
- * pathFilterByTargets(files, ["src"], "/proj");
+ * filterByTargets(files, ["src"], "/proj");
  * // → ["/proj/src/a.ts", "/proj/src/b.ts"]
  */
-export function pathFilterByTargets(files: string[], targets: string[], cwd: string): string[] {
+export function filterByTargets(files: string[], targets: string[], cwd: string): string[] {
   if (targets.length === 0) return files;
-  const normalizedTargets = targets.map((t) => pathPosix(t));
+  const normalizedTargets = targets.map((t) => posix(t));
   return files.filter((file) => {
-    const relativePath = pathPosix(path.relative(cwd, file));
+    const relativePath = posix(path.relative(cwd, file));
     return normalizedTargets.some(
       (target) => relativePath === target || relativePath.startsWith(target + "/"),
     );

package/src/worker/create-worker.ts

@@ -1,5 +1,5 @@
 import { parentPort } from "worker_threads";
-import { SdError, transferableDecode, transferableEncode } from "@simplysm/core-common";
+import { SdError, transfer } from "@simplysm/core-common";
 import type { WorkerRequest, WorkerResponse } from "./types";
 
 //#region createWorker
@@ -27,7 +27,7 @@ export function createWorker<
 >(
   methods: TMethods,
 ): {
-  send<K extends keyof TEvents & string>(event: K, data?: TEvents[K]): void;
+  send<TEventName extends keyof TEvents & string>(event: TEventName, data?: TEvents[TEventName]): void;
   __methods: TMethods;
   __events: TEvents;
 } {
@@ -46,7 +46,7 @@ export function createWorker<
   ): boolean => {
     const body = typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
     const response: WorkerResponse = { type: "log", body };
-    const serialized = transferableEncode(response);
+    const serialized = transfer.encode(response);
     port.postMessage(serialized.result, serialized.transferList);
 
     const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
@@ -58,7 +58,7 @@ export function createWorker<
   };
 
   port.on("message", async (serializedRequest: unknown) => {
-    const decoded = transferableDecode(serializedRequest);
+    const decoded = transfer.decode(serializedRequest);
 
     // Validate request structure
     if (
@@ -79,7 +79,7 @@ export function createWorker<
         request: { id: "unknown", method: "unknown", params: [] },
         body: new SdError(`Invalid worker request format: ${decodedStr}`),
       };
-      const serialized = transferableEncode(errorResponse);
+      const serialized = transfer.encode(errorResponse);
       port.postMessage(serialized.result, serialized.transferList);
       return;
     }
@@ -94,7 +94,7 @@ export function createWorker<
         body: new SdError(`Unknown method: ${request.method}`),
       };
 
-      const serialized = transferableEncode(response);
+      const serialized = transfer.encode(response);
       port.postMessage(serialized.result, serialized.transferList);
       return;
     }
@@ -108,7 +108,7 @@ export function createWorker<
         body: result,
       };
 
-      const serialized = transferableEncode(response);
+      const serialized = transfer.encode(response);
       port.postMessage(serialized.result, serialized.transferList);
     } catch (err) {
       const response: WorkerResponse = {
@@ -117,7 +117,7 @@ export function createWorker<
         body: err instanceof Error ? err : new Error(String(err)),
       };
 
-      const serialized = transferableEncode(response);
+      const serialized = transfer.encode(response);
       port.postMessage(serialized.result, serialized.transferList);
     }
   });
@@ -132,7 +132,7 @@ export function createWorker<
         body: data,
       };
 
-      const serialized = transferableEncode(response);
+      const serialized = transfer.encode(response);
       port.postMessage(serialized.result, serialized.transferList);
     },
   };

package/src/worker/types.ts

@@ -35,17 +35,17 @@ export type WorkerProxy<TModule extends WorkerModule> = PromisifyMethods<
   /**
    * Registers a worker event listener.
    */
-  on<K extends keyof TModule["default"]["__events"] & string>(
-    event: K,
-    listener: (data: TModule["default"]["__events"][K]) => void,
+  on<TEventName extends keyof TModule["default"]["__events"] & string>(
+    event: TEventName,
+    listener: (data: TModule["default"]["__events"][TEventName]) => void,
   ): void;
 
   /**
    * Unregisters a worker event listener.
    */
-  off<K extends keyof TModule["default"]["__events"] & string>(
-    event: K,
-    listener: (data: TModule["default"]["__events"][K]) => void,
+  off<TEventName extends keyof TModule["default"]["__events"] & string>(
+    event: TEventName,
+    listener: (data: TModule["default"]["__events"][TEventName]) => void,
   ): void;
 
   /**

package/src/worker/worker.ts

@@ -1,4 +1,4 @@
-import { EventEmitter, transferableDecode, transferableEncode, Uuid } from "@simplysm/core-common";
+import { EventEmitter, transfer, Uuid } from "@simplysm/core-common";
 import consola from "consola";
 import path from "path";
 import { fileURLToPath } from "url";
@@ -85,7 +85,7 @@ class WorkerInternal extends EventEmitter<Record<string, unknown>> {
     });
 
     this._worker.on("message", (serializedResponse: unknown) => {
-      const decoded = transferableDecode(serializedResponse);
+      const decoded = transfer.decode(serializedResponse);
 
       // Validate response structure
       if (decoded == null || typeof decoded !== "object" || !("type" in decoded)) {
@@ -131,14 +131,14 @@ class WorkerInternal extends EventEmitter<Record<string, unknown>> {
   call(method: string, params: unknown[]): Promise<unknown> {
     return new Promise((resolve, reject) => {
       const request: WorkerRequest = {
-        id: Uuid.new().toString(),
+        id: Uuid.generate().toString(),
         method,
         params,
       };
 
       this._pendingRequests.set(request.id, { method, resolve, reject });
 
-      const serialized = transferableEncode(request);
+      const serialized = transfer.encode(request);
       this._worker.postMessage(serialized.result, serialized.transferList);
     });
   }

package/tests/utils/fs-watcher.spec.ts

@@ -28,22 +28,6 @@ describe("SdFsWatcher", () => {
       expect(watcher).toBeDefined();
     });
 
-    it("starts watching files with options", async () => {
-      watcher = await FsWatcher.watch([path.join(testDir, "**/*")], {
-        ignoreInitial: false,
-      });
-      expect(watcher).toBeDefined();
-    });
-
-    it("logs errors when error events occur", async () => {
-      // chokidar starts watching non-existent paths without issue
-      // Error events only occur on actual filesystem errors
-      const nonExistentPath = path.join(testDir, "non-existent-dir-" + Date.now());
-      watcher = await FsWatcher.watch([nonExistentPath]);
-
-      // Error handler is registered so it doesn't crash even if an error occurs
-      expect(watcher).toBeDefined();
-    });
   });
 
   //#endregion
@@ -75,43 +59,6 @@ describe("SdFsWatcher", () => {
 
       expect(result).toBe(watcher);
     });
-
-    it("can specify delay option with various values", async () => {
-      watcher = await FsWatcher.watch([path.join(testDir, "**/*")]);
-
-      const fn = vi.fn();
-      // delay option should be specifiable with various values
-      expect(() => watcher!.onChange({ delay: 0 }, fn)).not.toThrow();
-      expect(() => watcher!.onChange({ delay: 500 }, fn)).not.toThrow();
-      expect(() => watcher!.onChange({ delay: 1000 }, fn)).not.toThrow();
-    });
-  });
-
-  //#endregion
-
-  //#region Types
-
-  describe("Types", () => {
-    it("verifies FsWatcherEvent type definition", () => {
-      // Verify that event types are correctly defined
-      const validEvents = ["add", "addDir", "change", "unlink", "unlinkDir"];
-      expect(validEvents).toContain("add");
-      expect(validEvents).toContain("addDir");
-      expect(validEvents).toContain("change");
-      expect(validEvents).toContain("unlink");
-      expect(validEvents).toContain("unlinkDir");
-    });
-
-    it("verifies FsWatcherChangeInfo structure", () => {
-      // Type check to verify interface structure
-      const mockChangeInfo = {
-        event: "add" as const,
-        path: "/test/path",
-      };
-
-      expect(mockChangeInfo.event).toBe("add");
-      expect(mockChangeInfo.path).toBe("/test/path");
-    });
   });
 
   //#endregion