@reliverse/relifso 1.4.0 → 1.4.1

package/bin/impl/extras.js

@@ -1,15 +1,80 @@
 import { ensuredir } from "@reliverse/relifso";
 import { exec } from "node:child_process";
+import { statSync, lstatSync } from "node:fs";
 import { readdir } from "node:fs/promises";
+import { stat, lstat } from "node:fs/promises";
 import { promisify } from "node:util";
 import { pathExists } from "./path-exists.js";
 import { remove } from "./remove.js";
+import { readFile, readFileSync } from "./read-file.js";
+export async function readText(filePath, options = "utf8") {
+  const effectiveOptions = typeof options === "string" ? { encoding: options } : { ...options, encoding: options.encoding || "utf8" };
+  return readFile(filePath, effectiveOptions);
+}
+export function readTextSync(filePath, options = "utf8") {
+  const effectiveOptions = typeof options === "string" ? { encoding: options } : { ...options, encoding: options.encoding || "utf8" };
+  return readFileSync(filePath, effectiveOptions);
+}
+export async function readLines(filePath, options = { encoding: "utf8" }) {
+  const effectiveOptions = typeof options === "string" ? { encoding: options } : options;
+  const contentBuffer = await readFile(filePath, { ...effectiveOptions, encoding: null });
+  return contentBuffer.toString().split(/\r?\n/);
+}
+export function readLinesSync(filePath, options = { encoding: "utf8" }) {
+  const effectiveOptions = typeof options === "string" ? { encoding: options } : options;
+  const contentBuffer = readFileSync(filePath, { ...effectiveOptions, encoding: null });
+  return contentBuffer.toString().split(/\r?\n/);
+}
+export async function isDirectory(filePath) {
+  try {
+    const stats = await stat(filePath);
+    return stats.isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+      return false;
+    }
+    throw error;
+  }
+}
+export function isDirectorySync(filePath) {
+  try {
+    const stats = statSync(filePath);
+    return stats.isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+      return false;
+    }
+    throw error;
+  }
+}
+export async function isSymlink(filePath) {
+  try {
+    const stats = await lstat(filePath);
+    return stats.isSymbolicLink();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+export function isSymlinkSync(filePath) {
+  try {
+    const stats = lstatSync(filePath);
+    return stats.isSymbolicLink();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
 export const execAsync = promisify(exec);
-export async function setHiddenAttributeOnWindows(folderPath) {
+export async function setHiddenAttribute(folderPath) {
   if (process.platform === "win32") {
     try {
       if (await pathExists(folderPath)) {
-        const isAlreadyHidden = await isHidden(folderPath);
+        const isAlreadyHidden = await isHiddenAttribute(folderPath);
         if (!isAlreadyHidden) {
           await execAsync(`attrib +h "${folderPath}"`);
         }
@@ -19,7 +84,7 @@ export async function setHiddenAttributeOnWindows(folderPath) {
     }
   }
 }
-export async function isHidden(filePath) {
+export async function isHiddenAttribute(filePath) {
   if (process.platform === "win32") {
     const attributes = await execAsync(`attrib "${filePath}"`);
     return attributes.stdout.includes("H");

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

@@ -0,0 +1,30 @@
+import type { WriteJsonOptions } from "./write-json.js";
+export interface JsonUtilsOptions extends WriteJsonOptions {
+    /**
+     * Whether to preserve comments when reading JSONC files
+     * @default false
+     */
+    preserveComments?: boolean;
+    /**
+     * Whether to include comments when writing JSONC files
+     * @default false
+     */
+    includeComments?: boolean;
+}
+/**
+ * Validates and repairs JSON/JSONC data if necessary.
+ * @param data - The JSON/JSONC data to validate and repair
+ * @param options - Options for validation and repair
+ * @returns The repaired JSON/JSONC data if needed, or the original data if valid
+ */
+export declare function validateAndRepairJson(data: unknown, options?: JsonUtilsOptions): unknown;
+/**
+ * Ensures that the directory for the JSON/JSONC file exists and then writes the data to the file.
+ * This is a utility function to avoid circular dependencies.
+ */
+export declare function ensureJsonFileSync(file: string, data: unknown, options?: JsonUtilsOptions): void;
+/**
+ * Ensures that the directory for the JSON/JSONC file exists and then asynchronously writes the data to the file.
+ * This is a utility function to avoid circular dependencies.
+ */
+export declare function ensureJsonFile(file: string, data: unknown, options?: JsonUtilsOptions): Promise<void>;

package/bin/impl/json-utils.js

@@ -0,0 +1,46 @@
+import { dirname } from "node:path";
+import { extname } from "node:path";
+import { parseJsonc, isValidJsonc } from "../utils/json/regular/jsonc.js";
+import { jsonrepair } from "../utils/json/regular/jsonrepair.js";
+import { mkdirsSync } from "./mkdirs.js";
+import { mkdirs } from "./mkdirs.js";
+import { writeJsonSync } from "./write-json.js";
+import { writeJson } from "./write-json.js";
+export function validateAndRepairJson(data, options = {}) {
+  if (typeof data === "string") {
+    try {
+      JSON.parse(data);
+      return data;
+    } catch {
+      const isJsonc = extname(data).toLowerCase() === ".jsonc" || isValidJsonc(data);
+      if (isJsonc) {
+        try {
+          return parseJsonc(data, { preserveComments: options.preserveComments });
+        } catch {
+          return jsonrepair(data);
+        }
+      } else {
+        return jsonrepair(data);
+      }
+    }
+  }
+  return data;
+}
+export function ensureJsonFileSync(file, data, options) {
+  const dir = dirname(file);
+  mkdirsSync(dir);
+  const repairedData = validateAndRepairJson(data, options);
+  writeJsonSync(file, repairedData, {
+    ...options,
+    spaces: 2
+  });
+}
+export async function ensureJsonFile(file, data, options) {
+  const dir = dirname(file);
+  await mkdirs(dir);
+  const repairedData = validateAndRepairJson(data, options);
+  await writeJson(file, repairedData, {
+    ...options,
+    spaces: 2
+  });
+}

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

@@ -1,3 +1,4 @@
+import type { WriteFileOptions } from "./write-file.js";
 /**
  * Ensures that the directory for the file exists and then writes the data to the file.
  *
@@ -5,7 +6,7 @@
  * @param data - The data to write.
  * @param options - Options for writing the file (e.g., encoding, mode, flag).
  */
-export declare function outputFileSync(file: string, data: string | Uint8Array, options?: unknown): void;
+export declare function outputFileSync(file: string, data: string | Uint8Array, options?: WriteFileOptions): void;
 /**
  * Ensures that the directory for the file exists and then asynchronously writes the data to the file.
  *
@@ -13,4 +14,4 @@ export declare function outputFileSync(file: string, data: string | Uint8Array,
  * @param data - The data to write.
  * @param options - Options for writing the file (e.g., encoding, mode, flag).
  */
-export declare function outputFile(file: string, data: string | Uint8Array, options?: unknown): Promise<void>;
+export declare function outputFile(file: string, data: string | Uint8Array, options?: WriteFileOptions): Promise<void>;

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

@@ -1,3 +1,8 @@
+import type { WriteJsonOptions } from "./write-json.js";
+import { type JsonUtilsOptions } from "./json-utils.js";
+export interface OutputJsonOptions extends WriteJsonOptions {
+    useStreaming?: boolean;
+}
 /**
  * Ensures that the directory for the JSON file exists and then writes the JSON data to the file.
  *
@@ -5,7 +10,7 @@
  * @param data - The JSON data to write.
  * @param options - Options for writing the JSON file (e.g., replacer, spaces).
  */
-export declare function outputJsonSync(file: string, data: unknown, options?: unknown): void;
+export declare function outputJsonSync(file: string, data: unknown, options?: BufferEncoding | OutputJsonOptions): void;
 /**
  * Ensures that the directory for the JSON file exists and then asynchronously writes the JSON data to the file.
  *
@@ -13,4 +18,4 @@ export declare function outputJsonSync(file: string, data: unknown, options?: un
  * @param data - The JSON data to write.
  * @param options - Options for writing the JSON file (e.g., replacer, spaces).
  */
-export declare function outputJson(file: string, data: unknown, options?: unknown): Promise<void>;
+export declare function outputJson(file: string, data: unknown, options?: BufferEncoding | OutputJsonOptions | JsonUtilsOptions): Promise<void>;

package/bin/impl/output-json.js

@@ -1,15 +1,77 @@
-import { dirname } from "node:path";
-import { mkdirsSync } from "./mkdirs.js";
-import { mkdirs } from "./mkdirs.js";
-import { writeJsonSync } from "./write-json.js";
-import { writeJson } from "./write-json.js";
+import { createWriteStream } from "node:fs";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { logInternal } from "../utils/log.js";
+import { ensureJsonFileSync, ensureJsonFile } from "./json-utils.js";
 export function outputJsonSync(file, data, options) {
-  const dir = dirname(file);
-  mkdirsSync(dir);
-  writeJsonSync(file, data, options);
+  const jsonOptions = typeof options === "string" ? { encoding: options } : options ?? {};
+  ensureJsonFileSync(file, data, jsonOptions);
 }
 export async function outputJson(file, data, options) {
-  const dir = dirname(file);
-  await mkdirs(dir);
-  await writeJson(file, data, options);
+  let useStreaming = false;
+  let encoding = "utf8";
+  let replacer;
+  let spaces;
+  let flag;
+  let mode;
+  let throws = true;
+  if (typeof options === "string") {
+    encoding = options;
+  } else if (options) {
+    if ("encoding" in options) {
+      encoding = options.encoding ?? encoding;
+    }
+    if ("replacer" in options) {
+      replacer = options.replacer;
+    }
+    if ("spaces" in options) {
+      spaces = options.spaces;
+    }
+    if ("flag" in options) {
+      flag = options.flag;
+    }
+    if ("mode" in options) {
+      mode = options.mode ? Number(options.mode) : void 0;
+    }
+    if ("useStreaming" in options) {
+      useStreaming = options.useStreaming ?? useStreaming;
+    }
+    if ("throws" in options && options.throws !== void 0) {
+      throws = options.throws;
+    }
+  }
+  try {
+    if (useStreaming) {
+      try {
+        const writeStream = createWriteStream(file, { encoding, mode, flags: flag });
+        const jsonString = JSON.stringify(data, replacer, spaces);
+        if (jsonString === void 0) {
+          throw new Error("Failed to stringify JSON object");
+        }
+        const transform = new Transform({
+          transform(chunk, _encoding, callback) {
+            callback(null, chunk);
+          }
+        });
+        transform.write(jsonString);
+        transform.end();
+        await pipeline(transform, writeStream);
+        return;
+      } catch (streamError) {
+      }
+    }
+    await ensureJsonFile(file, data, {
+      encoding,
+      replacer,
+      spaces,
+      flag,
+      mode,
+      throws,
+      useStreaming
+    });
+  } catch (err) {
+    if (throws) {
+      throw err;
+    }
+  }
 }

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

@@ -1,6 +1,9 @@
 export interface ReadFileOptions {
     encoding?: BufferEncoding | null;
     flag?: string;
+    isJson?: boolean;
+    useStreaming?: boolean;
+    reviver?: (key: string, value: unknown) => unknown;
 }
 /**
  * Synchronously reads the entire contents of a file.
@@ -10,6 +13,10 @@ export interface ReadFileOptions {
  * @returns The contents of the file.
  */
 export declare function readFileSync(path: string, options?: BufferEncoding | ReadFileOptions): string | Buffer;
+export declare function readFileSync(path: string, encoding: BufferEncoding): string;
+export declare function readFileSync(path: string, options: {
+    encoding: BufferEncoding;
+}): string;
 /**
  * Asynchronously reads the entire contents of a file.
  *
@@ -18,3 +25,7 @@ export declare function readFileSync(path: string, options?: BufferEncoding | Re
  * @returns A promise that resolves with the contents of the file.
  */
 export declare function readFile(path: string, options?: BufferEncoding | ReadFileOptions): Promise<string | Buffer>;
+export declare function readFile(path: string, encoding: BufferEncoding): Promise<string>;
+export declare function readFile(path: string, options: {
+    encoding: BufferEncoding;
+}): Promise<string>;

package/bin/impl/read-file.js

@@ -1,7 +1,11 @@
 import { readFileSync as nodeReadFileSync } from "node:fs";
+import { createReadStream } from "node:fs";
 import { readFile as nodeReadFileAsync } from "node:fs/promises";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+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";
 export function readFileSync(path, options) {
   let encoding;
   let flag;
@@ -53,35 +57,109 @@ export function readFileSync(path, options) {
 export async function readFile(path, options) {
   let encoding;
   let flag;
+  let isJson = false;
+  let useStreaming = false;
+  let reviver;
   if (typeof options === "string") {
     encoding = options;
   } else if (options) {
     encoding = options.encoding;
     flag = options.flag;
+    isJson = options.isJson ?? isJson;
+    useStreaming = options.useStreaming ?? useStreaming;
+    reviver = options.reviver;
   }
   if (isBun) {
     try {
       const file = getFileBun(path);
       if (encoding) {
         try {
-          return await file.text();
+          const result = await file.text();
+          if (isJson) {
+            try {
+              return JSON.parse(result, reviver);
+            } catch (_parseError) {
+              const repaired = jsonrepair(result);
+              return JSON.parse(repaired, reviver);
+            }
+          }
+          return result;
         } catch (_error) {
           const buffer = await file.arrayBuffer();
-          return Buffer.from(buffer).toString(encoding);
+          const text = Buffer.from(buffer).toString(encoding);
+          if (isJson) {
+            try {
+              return JSON.parse(text, reviver);
+            } catch (_parseError) {
+              const repaired = jsonrepair(text);
+              return JSON.parse(repaired, reviver);
+            }
+          }
+          return text;
         }
       }
       try {
         const buffer = await file.arrayBuffer();
+        if (isJson) {
+          const text = Buffer.from(buffer).toString();
+          try {
+            return JSON.parse(text, reviver);
+          } catch (_parseError) {
+            const repaired = jsonrepair(text);
+            return JSON.parse(repaired, reviver);
+          }
+        }
         return Buffer.from(buffer);
       } catch (_error) {
         const text = await file.text();
+        if (isJson) {
+          try {
+            return JSON.parse(text, reviver);
+          } catch (_parseError) {
+            const repaired = jsonrepair(text);
+            return JSON.parse(repaired, reviver);
+          }
+        }
         return Buffer.from(text);
       }
     } catch (error) {
     }
   }
+  if (useStreaming && encoding) {
+    try {
+      const chunks = [];
+      const transform = new Transform({
+        transform(chunk, _encoding, callback) {
+          chunks.push(chunk.toString());
+          callback();
+        }
+      });
+      const readStream = createReadStream(path, { encoding, flags: flag });
+      await pipeline(readStream, transform);
+      const text = chunks.join("");
+      if (isJson) {
+        try {
+          return JSON.parse(text, reviver);
+        } catch (_parseError) {
+          const repaired = jsonrepair(text);
+          return JSON.parse(repaired, reviver);
+        }
+      }
+      return text;
+    } catch (streamError) {
+    }
+  }
   if (encoding) {
-    return nodeReadFileAsync(path, { encoding, flag });
+    const text = await nodeReadFileAsync(path, { encoding, flag });
+    if (isJson) {
+      try {
+        return JSON.parse(text, reviver);
+      } catch (_parseError) {
+        const repaired = jsonrepair(text);
+        return JSON.parse(repaired, reviver);
+      }
+    }
+    return text;
   }
   return nodeReadFileAsync(path, { encoding: null, flag });
 }

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

@@ -5,6 +5,12 @@ export interface ReadJsonOptions {
     throws?: boolean;
     defaultValue?: unknown;
     ensure?: boolean;
+    useStreaming?: boolean;
+    /**
+     * Whether to preserve comments when reading JSONC files
+     * @default false
+     */
+    preserveComments?: boolean;
 }
 /**
  * Reads a JSON file and then parses it into an object.

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) {