@reliverse/relifso 1.4.0 → 1.4.2

package/bin/impl/read-json.js

@@ -1,8 +1,13 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, createReadStream } from "node:fs";
 import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { parseJsonc, isValidJsonc } from "../utils/json/regular/jsonc.js";
+import { jsonrepair } from "../utils/json/regular/jsonrepair.js";
+import { logInternal } from "../utils/log.js";
 import { isBun, getFileBun } from "./bun.js";
-import { logInternal } from "./logger.js";
-import { outputJsonSync } from "./output-json.js";
+import { ensureJsonFileSync } from "./json-utils.js";
 import { pathExistsSync } from "./path-exists.js";
 export function readJsonSync(file, options) {
   let encoding = "utf8";
@@ -10,6 +15,7 @@ export function readJsonSync(file, options) {
   let throws = true;
   let defaultValue = { sync: true };
   let ensure = true;
+  let preserveComments = false;
   if (typeof options === "string") {
     encoding = options;
   } else if (options) {
@@ -24,30 +30,81 @@ export function readJsonSync(file, options) {
     if (options.ensure !== void 0) {
       ensure = options.ensure;
     }
+    if (options.preserveComments !== void 0) {
+      preserveComments = options.preserveComments;
+    }
   }
   try {
     if (!pathExistsSync(file) && ensure) {
-      outputJsonSync(file, defaultValue);
+      ensureJsonFileSync(file, defaultValue);
       return defaultValue;
     }
+    if (isBun) {
+      try {
+        const fileRef = getFileBun(file);
+        try {
+          const parsed = fileRef.json();
+          if (parsed instanceof Promise) {
+            throw new Error("Bun's json() returned a Promise in sync context");
+          }
+          if (parsed === null || typeof parsed !== "object") {
+            if (throws) {
+              throw new Error("Invalid JSON data: expected an object");
+            }
+            return defaultValue;
+          }
+          return parsed;
+        } catch (parseError) {
+          if (throws) {
+            throw parseError;
+          }
+          return defaultValue;
+        }
+      } catch (error) {
+      }
+    }
     const data = readFileSync(file, { encoding });
     if (!data || !data.trim()) {
       return defaultValue;
     }
+    const isJsonc = extname(file).toLowerCase() === ".jsonc" || isValidJsonc(data);
     try {
-      const parsed = JSON.parse(data, reviver);
-      if (parsed === null || typeof parsed !== "object") {
-        if (throws) {
-          throw new Error("Invalid JSON data: expected an object");
+      if (isJsonc) {
+        const parsed = parseJsonc(data, { preserveComments, throws });
+        if (parsed === null || typeof parsed !== "object") {
+          if (throws) {
+            throw new Error("Invalid JSONC data: expected an object");
+          }
+          return defaultValue;
         }
-        return defaultValue;
+        return parsed;
+      } else {
+        const parsed = JSON.parse(data, reviver);
+        if (parsed === null || typeof parsed !== "object") {
+          if (throws) {
+            throw new Error("Invalid JSON data: expected an object");
+          }
+          return defaultValue;
+        }
+        return parsed;
       }
-      return parsed;
     } catch (parseError) {
-      if (throws) {
-        throw parseError;
+      try {
+        const repaired = jsonrepair(data);
+        const parsed = JSON.parse(repaired, reviver);
+        if (parsed === null || typeof parsed !== "object") {
+          if (throws) {
+            throw parseError;
+          }
+          return defaultValue;
+        }
+        return parsed;
+      } catch (_repairError) {
+        if (throws) {
+          throw parseError;
+        }
+        return defaultValue;
       }
-      return defaultValue;
     }
   } catch (err) {
     if (throws) {
@@ -62,12 +119,14 @@ export async function readJson(file, options) {
   let throws = true;
   let flag;
   let defaultValue = {};
+  let useStreaming = false;
   if (typeof options === "string") {
     encoding = options;
   } else if (options) {
     encoding = options.encoding ?? encoding;
     reviver = options.reviver;
     flag = options.flag;
+    useStreaming = options.useStreaming ?? useStreaming;
     if (options.throws !== void 0) {
       throws = options.throws;
     }
@@ -80,11 +139,7 @@ export async function readJson(file, options) {
       try {
         const fileRef = getFileBun(file);
         try {
-          const content = await fileRef.text();
-          if (!content || !content.trim()) {
-            return defaultValue;
-          }
-          const parsed = JSON.parse(content, reviver);
+          const parsed = await fileRef.json();
           if (parsed === null || typeof parsed !== "object") {
             if (throws) {
               throw new Error("Invalid JSON data: expected an object");
@@ -101,6 +156,51 @@ export async function readJson(file, options) {
       } catch (error) {
       }
     }
+    if (useStreaming) {
+      try {
+        const chunks = [];
+        const transform = new Transform({
+          transform(chunk, _encoding, callback) {
+            chunks.push(chunk.toString());
+            callback();
+          }
+        });
+        const readStream = createReadStream(file, { encoding, flags: flag });
+        await pipeline(readStream, transform);
+        const data2 = chunks.join("");
+        if (!data2 || !data2.trim()) {
+          return defaultValue;
+        }
+        try {
+          const parsed = JSON.parse(data2, reviver);
+          if (parsed === null || typeof parsed !== "object") {
+            if (throws) {
+              throw new Error("Invalid JSON data: expected an object");
+            }
+            return defaultValue;
+          }
+          return parsed;
+        } catch (parseError) {
+          try {
+            const repaired = jsonrepair(data2);
+            const parsed = JSON.parse(repaired, reviver);
+            if (parsed === null || typeof parsed !== "object") {
+              if (throws) {
+                throw parseError;
+              }
+              return defaultValue;
+            }
+            return parsed;
+          } catch (_repairError) {
+            if (throws) {
+              throw parseError;
+            }
+            return defaultValue;
+          }
+        }
+      } catch (streamError) {
+      }
+    }
     const data = await readFile(file, { encoding, flag });
     if (!data || !data.trim()) {
       return defaultValue;
@@ -115,10 +215,22 @@ export async function readJson(file, options) {
       }
       return parsed;
     } catch (parseError) {
-      if (throws) {
-        throw parseError;
+      try {
+        const repaired = jsonrepair(data);
+        const parsed = JSON.parse(repaired, reviver);
+        if (parsed === null || typeof parsed !== "object") {
+          if (throws) {
+            throw parseError;
+          }
+          return defaultValue;
+        }
+        return parsed;
+      } catch (_repairError) {
+        if (throws) {
+          throw parseError;
+        }
+        return defaultValue;
       }
-      return defaultValue;
     }
   } catch (err) {
     if (throws) {

package/bin/impl/stats.d.ts

@@ -0,0 +1,31 @@
+import type { Stats } from "node:fs";
+/**
+ * Convert Bun file stats to Node.js Stats object
+ * Uses Bun's optimized API when available, falls back to Node.js
+ */
+export declare function toNodeStats(path: string): Promise<Stats>;
+/**
+ * Get file stats with fallback to Node.js
+ * Uses Bun's optimized API when available
+ */
+export declare function getStats(path: string): Promise<Stats>;
+/**
+ * Get file stats synchronously with fallback to Node.js
+ * Uses Bun's optimized API when available
+ */
+export declare function getStatsSync(path: string): Stats;
+/**
+ * Check if a file exists
+ * Uses Bun's optimized API when available, falls back to Node.js
+ */
+export declare function getFileExists(path: string): Promise<boolean>;
+/**
+ * Get file size
+ * Uses Bun's optimized API when available, falls back to Node.js
+ */
+export declare function getFileSize(path: string): Promise<number>;
+/**
+ * Get file last modified time
+ * Uses Bun's optimized API when available, falls back to Node.js
+ */
+export declare function getFileLastModified(path: string): Promise<Date>;

package/bin/impl/stats.js

@@ -0,0 +1,141 @@
+import { statSync } from "node:fs";
+import { stat } from "node:fs/promises";
+import { logInternal } from "../utils/log.js";
+import { isBun } from "./bun.js";
+export async function toNodeStats(path) {
+  if (!isBun) {
+    return stat(path);
+  }
+  try {
+    const file = Bun.file(path);
+    const size = file.size;
+    const lastModified = new Date(file.lastModified);
+    return {
+      dev: 0,
+      ino: 0,
+      mode: 0,
+      nlink: 0,
+      uid: 0,
+      gid: 0,
+      rdev: 0,
+      size,
+      blksize: 0,
+      blocks: 0,
+      atimeMs: lastModified.getTime(),
+      mtimeMs: lastModified.getTime(),
+      ctimeMs: lastModified.getTime(),
+      birthtimeMs: lastModified.getTime(),
+      atime: lastModified,
+      mtime: lastModified,
+      ctime: lastModified,
+      birthtime: lastModified,
+      isDirectory: () => false,
+      // Bun doesn't provide this info directly
+      isFile: () => true,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => false,
+      isFIFO: () => false,
+      isSocket: () => false
+    };
+  } catch (error) {
+    return stat(path);
+  }
+}
+export async function getStats(path) {
+  if (!isBun) {
+    return stat(path);
+  }
+  try {
+    return await toNodeStats(path);
+  } catch (error) {
+    return stat(path);
+  }
+}
+export function getStatsSync(path) {
+  if (!isBun) {
+    return statSync(path);
+  }
+  try {
+    const file = Bun.file(path);
+    const size = file.size;
+    const lastModified = new Date(file.lastModified);
+    return {
+      dev: 0,
+      ino: 0,
+      mode: 0,
+      nlink: 0,
+      uid: 0,
+      gid: 0,
+      rdev: 0,
+      size,
+      blksize: 0,
+      blocks: 0,
+      atimeMs: lastModified.getTime(),
+      mtimeMs: lastModified.getTime(),
+      ctimeMs: lastModified.getTime(),
+      birthtimeMs: lastModified.getTime(),
+      atime: lastModified,
+      mtime: lastModified,
+      ctime: lastModified,
+      birthtime: lastModified,
+      isDirectory: () => false,
+      isFile: () => true,
+      isBlockDevice: () => false,
+      isCharacterDevice: () => false,
+      isSymbolicLink: () => false,
+      isFIFO: () => false,
+      isSocket: () => false
+    };
+  } catch (error) {
+    return statSync(path);
+  }
+}
+export async function getFileExists(path) {
+  if (!isBun) {
+    try {
+      await stat(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  try {
+    const file = Bun.file(path);
+    return await file.exists();
+  } catch (error) {
+    return false;
+  }
+}
+export async function getFileSize(path) {
+  if (!isBun) {
+    try {
+      const stats = await stat(path);
+      return stats.size;
+    } catch (error) {
+      return 0;
+    }
+  }
+  try {
+    const file = Bun.file(path);
+    return file.size;
+  } catch (error) {
+    return 0;
+  }
+}
+export async function getFileLastModified(path) {
+  if (!isBun) {
+    try {
+      const stats = await stat(path);
+      return stats.mtime;
+    } catch (error) {
+      return /* @__PURE__ */ new Date(0);
+    }
+  }
+  try {
+    const file = Bun.file(path);
+    return new Date(file.lastModified);
+  } catch (error) {
+    return /* @__PURE__ */ new Date(0);
+  }
+}

package/bin/impl/write-file.d.ts

@@ -1,20 +1,31 @@
-import { type PathLike } from "node:fs";
-export type WriteFileOptions = import("node:fs").WriteFileOptions;
+import { type PathLike, type WriteStream } from "node:fs";
+import { URL } from "node:url";
+export interface WriteFileOptions {
+    encoding?: BufferEncoding | null;
+    mode?: number;
+    flag?: string;
+    isJson?: boolean;
+    useStreaming?: boolean;
+    replacer?: (key: string, value: unknown) => unknown;
+    spaces?: string | number;
+}
+type WriteTarget = PathLike | number | URL | WriteStream;
 /**
  * Synchronously writes data to a file, replacing the file if it already exists.
  * Ensures the directory exists before writing.
  *
- * @param file - Path to the file.
- * @param data - The data to write. If something other than a Buffer or Uint8Array is provided, it is converted to a string.
+ * @param file - Path to the file, file descriptor, URL, or special streams (stdout/stderr).
+ * @param data - The data to write. Will be converted to string if not already a string.
  * @param options - Options for writing the file. Can be an encoding string or an object.
  */
-export declare function writeFileSync(file: PathLike | number, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): void;
+export declare function writeFileSync(file: WriteTarget, data: string | NodeJS.ArrayBufferView | Blob | Response | unknown, options?: WriteFileOptions): void;
 /**
  * Asynchronously writes data to a file, replacing the file if it already exists.
  * Ensures the directory exists before writing.
  *
- * @param file - Path to the file.
- * @param data - The data to write. If something other than a Buffer or Uint8Array is provided, it is converted to a string.
+ * @param file - Path to the file, file descriptor, URL, or special streams (stdout/stderr).
+ * @param data - The data to write. Will be converted to string if not already a string.
  * @param options - Options for writing the file. Can be an encoding string or an object.
  */
-export declare function writeFile(file: PathLike | number, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<void>;
+export declare function writeFile(file: WriteTarget, data: string | NodeJS.ArrayBufferView | Blob | Response | unknown, options?: WriteFileOptions): Promise<void>;
+export {};

package/bin/impl/write-file.js

@@ -1,48 +1,177 @@
-import { writeFileSync as nodeWriteFileSync } from "node:fs";
-import { mkdir, writeFile as nodeWriteFileAsync, stat } from "node:fs/promises";
+import { writeFileSync as nodeWriteFileSync, createWriteStream } from "node:fs";
+import { mkdir, writeFile as nodeWriteFileAsync } from "node:fs/promises";
 import path from "node:path";
-import { isBun, getFileBun } from "./bun.js";
-import { logInternal } from "./logger.js";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { URL } from "node:url";
+import { logInternal } from "../utils/log.js";
+import { isBun } from "./bun.js";
 import { mkdirsSync } from "./mkdirs.js";
+function isStdStream(target) {
+  return typeof target === "object" && target !== null && "write" in target && typeof target.write === "function";
+}
+function isFileDescriptor(target) {
+  return typeof target === "number";
+}
+function isPathLike(target) {
+  return !isStdStream(target) && !isFileDescriptor(target) && !(target instanceof URL);
+}
 export function writeFileSync(file, data, options) {
+  let isJson = false;
+  let replacer;
+  let spaces;
+  let encoding;
+  let mode;
+  let flag;
+  if (options) {
+    isJson = options.isJson ?? isJson;
+    replacer = options.replacer;
+    spaces = options.spaces;
+    encoding = options.encoding;
+    mode = options.mode ? Number(options.mode) : void 0;
+    flag = options.flag;
+  }
+  let stringData;
+  if (typeof data === "string") {
+    stringData = data;
+  } else if (data instanceof Uint8Array) {
+    stringData = Buffer.from(data).toString(encoding || "utf8");
+  } else if (data instanceof Blob || data instanceof Response) {
+    throw new Error("Blob and Response are not supported in sync context");
+  } else if (data instanceof ArrayBuffer) {
+    stringData = Buffer.from(new Uint8Array(data)).toString(encoding || "utf8");
+  } else if (ArrayBuffer.isView(data)) {
+    stringData = Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString(encoding || "utf8");
+  } else if (isJson) {
+    try {
+      stringData = JSON.stringify(data, replacer, spaces);
+      if (stringData === void 0) {
+        throw new Error("Failed to stringify JSON object");
+      }
+    } catch (err) {
+      throw new Error(`Failed to stringify JSON data: ${err}`);
+    }
+  } else {
+    stringData = String(data);
+  }
+  if (isStdStream(file)) {
+    file.write(stringData);
+    return;
+  }
+  if (isFileDescriptor(file)) {
+    if (isBun) {
+      Bun.write(Bun.file(file), stringData);
+      return;
+    }
+    nodeWriteFileSync(file, stringData, { encoding: encoding || "utf8", mode, flag });
+    return;
+  }
+  if (file instanceof URL) {
+    if (file.protocol !== "file:") {
+      throw new Error("Only file:// URLs are supported");
+    }
+    file = file.pathname;
+  }
+  if (!isPathLike(file)) {
+    throw new Error("Invalid file target");
+  }
   const dir = path.dirname(file.toString());
   mkdirsSync(dir);
   if (isBun) {
     try {
-      nodeWriteFileSync(file, data, options);
+      const filePath = file.toString();
+      Bun.write(filePath, stringData);
       return;
     } catch (_error) {
     }
   }
-  nodeWriteFileSync(file, data, options);
+  nodeWriteFileSync(file, stringData, { encoding: encoding || "utf8", mode, flag });
 }
 export async function writeFile(file, data, options) {
+  let isJson = false;
+  let useStreaming = false;
+  let replacer;
+  let spaces;
+  let encoding;
+  let mode;
+  let flag;
+  if (options) {
+    isJson = options.isJson ?? isJson;
+    useStreaming = options.useStreaming ?? useStreaming;
+    replacer = options.replacer;
+    spaces = options.spaces;
+    encoding = options.encoding;
+    mode = options.mode ? Number(options.mode) : void 0;
+    flag = options.flag;
+  }
+  let stringData;
+  if (typeof data === "string") {
+    stringData = data;
+  } else if (data instanceof Uint8Array) {
+    stringData = Buffer.from(data).toString(encoding || "utf8");
+  } else if (data instanceof Blob) {
+    stringData = await data.text();
+  } else if (data instanceof Response) {
+    stringData = await data.text();
+  } else if (data instanceof ArrayBuffer) {
+    stringData = Buffer.from(new Uint8Array(data)).toString(encoding || "utf8");
+  } else if (ArrayBuffer.isView(data)) {
+    stringData = Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString(encoding || "utf8");
+  } else if (isJson) {
+    try {
+      stringData = JSON.stringify(data, replacer, spaces);
+      if (stringData === void 0) {
+        throw new Error("Failed to stringify JSON object");
+      }
+    } catch (err) {
+      throw new Error(`Failed to stringify JSON data: ${err}`);
+    }
+  } else {
+    stringData = String(data);
+  }
+  if (isStdStream(file)) {
+    file.write(stringData);
+    return;
+  }
+  if (isFileDescriptor(file)) {
+    if (isBun) {
+      await Bun.write(Bun.file(file), stringData);
+      return;
+    }
+    await nodeWriteFileAsync(file, stringData, { encoding: encoding || "utf8", mode, flag });
+    return;
+  }
+  if (file instanceof URL) {
+    if (file.protocol !== "file:") {
+      throw new Error("Only file:// URLs are supported");
+    }
+    file = file.pathname;
+  }
+  if (!isPathLike(file)) {
+    throw new Error("Invalid file target");
+  }
   const dir = path.dirname(file.toString());
-  try {
-    await stat(dir);
-  } catch (_error) {
-    if (_error.code === "ENOENT") {
-      await mkdir(dir, { recursive: true });
-    } else {
-      throw _error;
+  await mkdir(dir, { recursive: true });
+  if (useStreaming) {
+    try {
+      const writeStream = createWriteStream(file, { encoding: encoding || "utf8", mode, flags: flag });
+      const transform = new Transform({
+        transform(chunk, _encoding, callback) {
+          callback(null, chunk);
+        }
+      });
+      await pipeline(stringData, transform, writeStream);
+      return;
+    } catch (streamError) {
     }
   }
   if (isBun) {
     try {
       const filePath = file.toString();
-      const bunFile = getFileBun(filePath);
-      let writeData;
-      if (typeof data === "string") {
-        writeData = data;
-      } else if (data instanceof Uint8Array) {
-        writeData = data;
-      } else {
-        writeData = new Uint8Array(data.buffer);
-      }
-      await Bun.write(bunFile, writeData);
+      await Bun.write(filePath, stringData);
       return;
     } catch (_error) {
     }
   }
-  return nodeWriteFileAsync(file, data, options);
+  await nodeWriteFileAsync(file, stringData, { encoding: encoding || "utf8", mode, flag });
 }

package/bin/impl/write-json.d.ts

@@ -1,15 +1,26 @@
-import type { Mode } from "node:fs";
 export interface JsonStringifyOptions {
     replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
     spaces?: string | number;
+    /**
+     * Whether to include comments when writing JSONC files
+     * @default false
+     */
+    includeComments?: boolean;
 }
 export interface WriteJsonOptions {
     encoding?: BufferEncoding | null;
-    mode?: Mode;
+    mode?: number;
     flag?: string;
     replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
     spaces?: string | number;
     throws?: boolean;
+    useStreaming?: boolean;
+    chunkSize?: number;
+    /**
+     * Whether to include comments when writing JSONC files
+     * @default false
+     */
+    includeComments?: boolean;
 }
 /**
  * Synchronously writes a JSON file.