@reliverse/relifso 1.3.1 → 1.4.1

package/bin/utils/json/stream/jsonl.js

@@ -0,0 +1,55 @@
+import { Transform } from "node:stream";
+import { JsonStreamError } from "./JsonStreamError.js";
+export function createJsonlParser(options = {}) {
+  const {
+    chunkSize = 1024 * 1024,
+    // 1MB default chunk size
+    reviver
+  } = options;
+  let buffer = "";
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        const text = chunk.toString();
+        buffer += text;
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (line.trim()) {
+            try {
+              const parsed = JSON.parse(line, reviver);
+              this.push(parsed);
+            } catch (error) {
+              const parseError = error;
+              throw new JsonStreamError(`Failed to parse JSONL line: ${parseError.message}`);
+            }
+          }
+        }
+        if (buffer.length > chunkSize) {
+          throw new JsonStreamError("Chunk size exceeded without finding complete JSONL line");
+        }
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    }
+  });
+}
+export function createJsonlWriter(options = {}) {
+  const { replacer } = options;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        const jsonStr = JSON.stringify(chunk, replacer);
+        if (jsonStr === void 0) {
+          throw new JsonStreamError("Failed to stringify JSON object");
+        }
+        this.push(`${jsonStr}
+`);
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    }
+  });
+}

package/bin/utils/json/stream/parser.d.ts

@@ -0,0 +1,14 @@
+import { Transform } from "node:stream";
+interface ParserOptions {
+    chunkSize?: number;
+    maxDepth?: number;
+    reviver?: (key: string, value: unknown) => unknown;
+}
+/**
+ * Creates a transform stream that parses JSON data chunk by chunk.
+ *
+ * @param options - Parser options
+ * @returns A transform stream that emits parsed JSON objects
+ */
+export declare function createJsonStreamParser(options?: ParserOptions): Transform;
+export {};

package/bin/utils/json/stream/parser.js

@@ -0,0 +1,81 @@
+import { Transform } from "node:stream";
+import { JsonStreamError } from "./JsonStreamError.js";
+export function createJsonStreamParser(options = {}) {
+  const {
+    chunkSize = 1024 * 1024,
+    // 1MB default chunk size
+    maxDepth = 100,
+    reviver
+  } = options;
+  let buffer = "";
+  let depth = 0;
+  let inString = false;
+  let escapeNext = false;
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        const text = chunk.toString();
+        buffer += text;
+        while (buffer.length > 0) {
+          const start = buffer.indexOf("{");
+          if (start === -1) {
+            buffer = "";
+            break;
+          }
+          buffer = buffer.slice(start);
+          depth = 0;
+          inString = false;
+          escapeNext = false;
+          let end = -1;
+          for (let i = 0; i < buffer.length; i++) {
+            const char = buffer[i];
+            if (escapeNext) {
+              escapeNext = false;
+              continue;
+            }
+            if (char === "\\") {
+              escapeNext = true;
+              continue;
+            }
+            if (char === '"' && !escapeNext) {
+              inString = !inString;
+              continue;
+            }
+            if (!inString) {
+              if (char === "{") {
+                depth++;
+                if (depth > maxDepth) {
+                  throw new JsonStreamError(`Maximum nesting depth of ${maxDepth} exceeded`);
+                }
+              } else if (char === "}") {
+                depth--;
+                if (depth === 0) {
+                  end = i + 1;
+                  break;
+                }
+              }
+            }
+          }
+          if (end === -1) {
+            if (buffer.length > chunkSize) {
+              throw new JsonStreamError("Chunk size exceeded without finding complete JSON object");
+            }
+            break;
+          }
+          const jsonStr = buffer.slice(0, end);
+          try {
+            const parsed = JSON.parse(jsonStr, reviver);
+            this.push(parsed);
+          } catch (error) {
+            const parseError = error;
+            throw new JsonStreamError(`Failed to parse JSON: ${parseError.message}`);
+          }
+          buffer = buffer.slice(end);
+        }
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    }
+  });
+}

package/bin/utils/json/stream/stack.d.ts

@@ -0,0 +1,19 @@
+export declare enum Caret {
+    beforeValue = "beforeValue",
+    afterValue = "afterValue",
+    beforeKey = "beforeKey"
+}
+export declare enum StackType {
+    root = "root",
+    object = "object",
+    array = "array",
+    ndJson = "ndJson",
+    functionCall = "dataType"
+}
+export declare function createStack(): {
+    readonly type: StackType | undefined;
+    readonly caret: Caret;
+    pop(): true;
+    push(type: StackType, newCaret: Caret): true;
+    update(newCaret: Caret): true;
+};

package/bin/utils/json/stream/stack.js

@@ -0,0 +1,43 @@
+export var Caret = /* @__PURE__ */ ((Caret2) => {
+  Caret2["beforeValue"] = "beforeValue";
+  Caret2["afterValue"] = "afterValue";
+  Caret2["beforeKey"] = "beforeKey";
+  return Caret2;
+})(Caret || {});
+export var StackType = /* @__PURE__ */ ((StackType2) => {
+  StackType2["root"] = "root";
+  StackType2["object"] = "object";
+  StackType2["array"] = "array";
+  StackType2["ndJson"] = "ndJson";
+  StackType2["functionCall"] = "dataType";
+  return StackType2;
+})(StackType || {});
+export function createStack() {
+  const stack = ["root" /* root */];
+  let caret = "beforeValue" /* beforeValue */;
+  return {
+    get type() {
+      return last(stack);
+    },
+    get caret() {
+      return caret;
+    },
+    pop() {
+      stack.pop();
+      caret = "afterValue" /* afterValue */;
+      return true;
+    },
+    push(type, newCaret) {
+      stack.push(type);
+      caret = newCaret;
+      return true;
+    },
+    update(newCaret) {
+      caret = newCaret;
+      return true;
+    }
+  };
+}
+function last(array) {
+  return array[array.length - 1];
+}

package/bin/utils/json/stream/stream.d.ts

@@ -0,0 +1,6 @@
+import { Transform } from "node:stream";
+export interface JsonRepairTransformOptions {
+    chunkSize?: number;
+    bufferSize?: number;
+}
+export declare function jsonrepairTransform(options?: JsonRepairTransformOptions): Transform;

package/bin/utils/json/stream/stream.js

@@ -0,0 +1,30 @@
+import { Transform } from "node:stream";
+import { jsonrepairCore } from "./core.js";
+export function jsonrepairTransform(options) {
+  const repair = jsonrepairCore({
+    onData: (chunk) => transform.push(chunk),
+    bufferSize: options?.bufferSize,
+    chunkSize: options?.chunkSize
+  });
+  const transform = new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        repair.transform(chunk.toString());
+      } catch (err) {
+        this.emit("error", err);
+      } finally {
+        callback();
+      }
+    },
+    flush(callback) {
+      try {
+        repair.flush();
+      } catch (err) {
+        this.emit("error", err);
+      } finally {
+        callback();
+      }
+    }
+  });
+  return transform;
+}

package/bin/utils/json/stream/writer.d.ts

@@ -0,0 +1,14 @@
+import { Transform } from "node:stream";
+interface WriterOptions {
+    chunkSize?: number;
+    replacer?: (key: string, value: unknown) => unknown | (number | string)[] | null;
+    spaces?: string | number;
+}
+/**
+ * Creates a transform stream that writes JSON data chunk by chunk.
+ *
+ * @param options - Writer options
+ * @returns A transform stream that accepts objects and outputs JSON strings
+ */
+export declare function createJsonStreamWriter(options?: WriterOptions): Transform;
+export {};

package/bin/utils/json/stream/writer.js

@@ -0,0 +1,44 @@
+import { Transform } from "node:stream";
+import { JsonStreamError } from "./JsonStreamError.js";
+export function createJsonStreamWriter(options = {}) {
+  const {
+    chunkSize = 1024 * 1024,
+    // 1MB default chunk size
+    replacer,
+    spaces
+  } = options;
+  let isFirst = true;
+  let buffer = "";
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      try {
+        const jsonStr = JSON.stringify(chunk, replacer, spaces);
+        if (jsonStr === void 0) {
+          throw new JsonStreamError("Failed to stringify JSON object");
+        }
+        if (!isFirst) {
+          buffer += ",";
+        }
+        isFirst = false;
+        buffer += jsonStr;
+        if (buffer.length >= chunkSize) {
+          this.push(buffer);
+          buffer = "";
+        }
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    },
+    flush(callback) {
+      try {
+        if (buffer.length > 0) {
+          this.push(buffer);
+        }
+        callback();
+      } catch (error) {
+        callback(error instanceof Error ? error : new JsonStreamError(String(error)));
+      }
+    }
+  });
+}

package/bin/utils/log.d.ts

@@ -0,0 +1 @@
+export declare const logInternal: (msg: string | (() => string)) => void;

package/bin/utils/log.js

@@ -0,0 +1,7 @@
+const DEBUG_MODE = true;
+export const logInternal = (msg) => {
+  if (DEBUG_MODE) {
+    const message = typeof msg === "function" ? msg() : msg;
+    console.log(`\x1B[36;2m${message}\x1B[0m`);
+  }
+};

package/package.json

@@ -1,11 +1,11 @@
 {
   "dependencies": {},
-  "description": "@reliverse/relifso is a modern filesystem toolkit for builders. drop-in replacement for `node:fs` and `fs-extra` — powered by native promises, built with es modules, and packed with dx-focused utilities.",
+  "description": "@reliverse/relifso is a modern node and bun filesystem toolkit. drop-in replacement for `node:fs` and `fs-extra` — powered by native promises, built with es modules, and packed with dx-focused and bun-aware utilities.",
   "homepage": "https://docs.reliverse.org",
   "license": "MIT",
   "name": "@reliverse/relifso",
   "type": "module",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "keywords": [
     "fs",
     "file",
@@ -38,7 +38,8 @@
     "bin",
     "package.json",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "LICENSES"
   ],
   "main": "./bin/mod.js",
   "module": "./bin/mod.js",

package/bin/impl/node/copy.js

@@ -1,94 +0,0 @@
-import { copyFileSync, statSync, constants as fsConstants, readdirSync, rmSync } from "node:fs";
-import {
-  stat as statAsync,
-  copyFile as copyFileAsync,
-  constants as fsConstantsAsync,
-  readdir,
-  rm
-} from "node:fs/promises";
-import { dirname, join as joinPath, basename as basenamePath } from "node:path";
-import { mkdirsSync } from "./mkdirs.js";
-import { mkdirs } from "./mkdirs.js";
-export function copySync(src, dest, options = {}) {
-  const { overwrite = options.clobber || false, preserveTimestamps = false } = options;
-  const srcStat = statSync(src, { throwIfNoEntry: true });
-  if (!srcStat) {
-  }
-  let destFinal = dest;
-  const destStat = statSync(dest, { throwIfNoEntry: false });
-  if (!srcStat.isDirectory() && destStat?.isDirectory()) {
-    destFinal = joinPath(dest, basenamePath(src));
-  }
-  const destExists = statSync(destFinal, { throwIfNoEntry: false });
-  if (destExists && !overwrite) {
-    throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
-  }
-  const destDir = dirname(destFinal);
-  mkdirsSync(destDir);
-  if (srcStat.isDirectory()) {
-    if (overwrite && destExists) {
-      rmSync(destFinal, { recursive: true, force: true });
-    }
-    mkdirsSync(destFinal);
-    const entries = readdirSync(src);
-    for (const entry of entries) {
-      const srcEntry = joinPath(src, entry);
-      const destEntry = joinPath(destFinal, entry);
-      copySync(srcEntry, destEntry, options);
-    }
-  } else {
-    if (overwrite && destExists) {
-      rmSync(destFinal, { force: true });
-    }
-    copyFileSync(src, destFinal, preserveTimestamps ? fsConstants.COPYFILE_FICLONE : 0);
-    if (preserveTimestamps) {
-      console.warn("preserveTimestamps: utimesSync is not implemented for the moment.");
-    }
-  }
-}
-export async function copy(src, dest, options = {}) {
-  const { overwrite = options.clobber || false, preserveTimestamps = false } = options;
-  const srcStat = await statAsync(src).catch((e) => {
-    if (e.code === "ENOENT") return null;
-    throw e;
-  });
-  if (!srcStat) {
-  }
-  let destFinal = dest;
-  const destStat = await statAsync(dest).catch((e) => {
-    if (e.code === "ENOENT") return null;
-    throw e;
-  });
-  if (!srcStat?.isDirectory() && destStat?.isDirectory()) {
-    destFinal = joinPath(dest, basenamePath(src));
-  }
-  const destExists = await statAsync(destFinal).catch((e) => {
-    if (e.code === "ENOENT") return null;
-    throw e;
-  });
-  if (destExists && !overwrite) {
-    throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
-  }
-  const destDir = dirname(destFinal);
-  await mkdirs(destDir);
-  if (srcStat?.isDirectory()) {
-    if (overwrite && destExists) {
-      await rm(destFinal, { recursive: true, force: true });
-    }
-    await mkdirs(destFinal);
-    const entries = await readdir(src);
-    for (const entry of entries) {
-      const srcEntry = joinPath(src, entry);
-      const destEntry = joinPath(destFinal, entry);
-      await copy(srcEntry, destEntry, options);
-    }
-  } else {
-    if (overwrite && destExists) {
-      await rm(destFinal, { force: true });
-    }
-    await copyFileAsync(src, destFinal, preserveTimestamps ? fsConstantsAsync.COPYFILE_FICLONE : 0);
-    if (preserveTimestamps) {
-      console.warn("preserveTimestamps: utimes is not implemented for the moment.");
-    }
-  }
-}

package/bin/impl/node/create-file.d.ts

@@ -1,2 +0,0 @@
-export declare function createFileSync(file: string, content?: string): void;
-export declare function createFile(file: string, content?: string): Promise<void>;

package/bin/impl/node/create-file.js

@@ -1,21 +0,0 @@
-import { existsSync } from "node:fs";
-import { stat } from "node:fs/promises";
-import { writeFileSync } from "./write-file.js";
-import { writeFile } from "./write-file.js";
-export function createFileSync(file, content = "") {
-  if (existsSync(file)) {
-    return;
-  }
-  return writeFileSync(file, content);
-}
-export async function createFile(file, content = "") {
-  try {
-    await stat(file);
-    return;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return writeFile(file, content);
-    }
-    throw error;
-  }
-}

package/bin/impl/node/dive.js

@@ -1,56 +0,0 @@
-import { readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
-export function* diveSync(dir, callbackOrOptions, options) {
-  const currentDepth = 0;
-  let actualOptions = {
-    recursive: true,
-    files: true,
-    directories: false
-    // fs-extra's dive by default only yields files
-  };
-  let callback;
-  if (typeof callbackOrOptions === "function") {
-    callback = callbackOrOptions;
-    if (options) {
-      actualOptions = { ...actualOptions, ...options };
-    }
-  } else if (typeof callbackOrOptions === "object") {
-    actualOptions = { ...actualOptions, ...callbackOrOptions };
-  }
-  function* walk(currentPath, depth) {
-    if (actualOptions.depth !== void 0 && depth > actualOptions.depth) {
-      return;
-    }
-    const entries = readdirSync(currentPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const entryPath = join(currentPath, entry.name);
-      if (!actualOptions.all && entry.name.startsWith(".")) {
-        continue;
-      }
-      if (actualOptions.ignore) {
-        if (Array.isArray(actualOptions.ignore) && actualOptions.ignore.includes(entry.name)) {
-          continue;
-        }
-        if (actualOptions.ignore instanceof RegExp && actualOptions.ignore.test(entryPath)) {
-          continue;
-        }
-      }
-      const stat = statSync(entryPath);
-      if (entry.isFile()) {
-        if (actualOptions.files) {
-          if (callback) callback(entryPath, stat);
-          yield entryPath;
-        }
-      } else if (entry.isDirectory()) {
-        if (actualOptions.directories) {
-          if (callback) callback(entryPath, stat);
-          yield entryPath;
-        }
-        if (actualOptions.recursive) {
-          yield* walk(entryPath, depth + 1);
-        }
-      }
-    }
-  }
-  yield* walk(dir, currentDepth);
-}

package/bin/impl/node/empty-dir.d.ts

@@ -1,2 +0,0 @@
-export declare function emptyDirSync(dir: string): void;
-export declare function emptyDir(dir: string): Promise<void>;

package/bin/impl/node/empty-dir.js

@@ -1,24 +0,0 @@
-import { existsSync, readdirSync, rmSync } from "node:fs";
-import { readdir, rm, stat } from "node:fs/promises";
-import path from "node:path";
-export function emptyDirSync(dir) {
-  if (!existsSync(dir)) {
-    return;
-  }
-  for (const file of readdirSync(dir)) {
-    rmSync(path.resolve(dir, file), { recursive: true, force: true });
-  }
-}
-export async function emptyDir(dir) {
-  try {
-    await stat(dir);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return;
-    }
-    throw error;
-  }
-  for (const file of await readdir(dir)) {
-    await rm(path.resolve(dir, file), { recursive: true, force: true });
-  }
-}

package/bin/impl/node/move.js

@@ -1,93 +0,0 @@
-import { renameSync, statSync, unlinkSync, copyFileSync } from "node:fs";
-import { rename, stat, unlink, copyFile } from "node:fs/promises";
-import { dirname, basename, join as joinPath } from "node:path";
-import { mkdirsSync } from "./mkdirs.js";
-import { mkdirs } from "./mkdirs.js";
-export function moveSync(src, dest, options = {}) {
-  let overwrite;
-  if (options.overwrite !== void 0) {
-    overwrite = options.overwrite;
-  } else if (options.clobber !== void 0) {
-    console.warn(
-      "Warning: The 'clobber' option in moveSync is deprecated and will be removed in a future version. Please use 'overwrite' instead."
-    );
-    overwrite = options.clobber;
-  } else {
-    overwrite = false;
-  }
-  const srcStat = statSync(src, { throwIfNoEntry: true });
-  if (!srcStat) {
-  }
-  let destFinal = dest;
-  const destStat = statSync(dest, { throwIfNoEntry: false });
-  if (destStat?.isDirectory()) {
-    destFinal = joinPath(dest, basename(src));
-  }
-  if (statSync(destFinal, { throwIfNoEntry: false }) && !overwrite) {
-    throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
-  }
-  const destDir = dirname(destFinal);
-  mkdirsSync(destDir);
-  try {
-    renameSync(src, destFinal);
-  } catch (err) {
-    if (err.code === "EXDEV") {
-      copyFileSync(src, destFinal);
-      unlinkSync(src);
-    } else if (err.code === "EISDIR" || err.code === "EPERM") {
-      copyFileSync(src, destFinal);
-      unlinkSync(src);
-    } else {
-      throw err;
-    }
-  }
-}
-export async function move(src, dest, options = {}) {
-  let overwrite;
-  if (options.overwrite !== void 0) {
-    overwrite = options.overwrite;
-  } else if (options.clobber !== void 0) {
-    console.warn(
-      "Warning: The 'clobber' option in move is deprecated and will be removed in a future version. Please use 'overwrite' instead."
-    );
-    overwrite = options.clobber;
-  } else {
-    overwrite = false;
-  }
-  const srcStat = await stat(src).catch((e) => {
-    if (e.code === "ENOENT") return null;
-    throw e;
-  });
-  if (!srcStat) {
-  }
-  let destFinal = dest;
-  const destStat = await stat(dest).catch((e) => {
-    if (e.code === "ENOENT") return null;
-    throw e;
-  });
-  if (destStat?.isDirectory()) {
-    destFinal = joinPath(dest, basename(src));
-  }
-  const destFinalStat = await stat(destFinal).catch((e) => {
-    if (e.code === "ENOENT") return null;
-    throw e;
-  });
-  if (destFinalStat && !overwrite) {
-    throw new Error(`Destination ${destFinal} already exists and overwrite is false.`);
-  }
-  const destDir = dirname(destFinal);
-  await mkdirs(destDir);
-  try {
-    await rename(src, destFinal);
-  } catch (err) {
-    if (err.code === "EXDEV") {
-      await copyFile(src, destFinal);
-      await unlink(src);
-    } else if (err.code === "EISDIR" || err.code === "EPERM") {
-      await copyFile(src, destFinal);
-      await unlink(src);
-    } else {
-      throw err;
-    }
-  }
-}

package/bin/impl/node/output-json.js

@@ -1,15 +0,0 @@
-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";
-export function outputJsonSync(file, data, options) {
-  const dir = dirname(file);
-  mkdirsSync(dir);
-  writeJsonSync(file, data, options);
-}
-export async function outputJson(file, data, options) {
-  const dir = dirname(file);
-  await mkdirs(dir);
-  await writeJson(file, data, options);
-}