@thi.ng/file-io 1.0.4 → 1.0.5

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/delete.js

@@ -1,16 +1,10 @@
 import { unlinkSync } from "fs";
-/**
- * Deletes file at given path. If `dryRun` is true (default: false), the file
- * WON'T be deleted, however if a `logger` is provided then at least a dry-run
- * log message will be emitted.
- *
- * @param path
- * @param logger
- * @param dryRun
- */
-export const deleteFile = (path, logger, dryRun = false) => {
-    logger && logger.info(`${dryRun ? "[dryrun] " : ""}deleting file: ${path}`);
-    if (dryRun)
-        return;
-    unlinkSync(path);
+const deleteFile = (path, logger, dryRun = false) => {
+  logger && logger.info(`${dryRun ? "[dryrun] " : ""}deleting file: ${path}`);
+  if (dryRun)
+    return;
+  unlinkSync(path);
+};
+export {
+  deleteFile
 };

package/dir.js

@@ -1,24 +1,11 @@
 import { existsSync, mkdirSync, statSync } from "fs";
 import { sep } from "path";
-/**
- * Checks if the directory for given file `path` already exists, and if not the
- * case, creates it. Returns true if the latter case.
- *
- * @remarks
- * If `path` only contains a filename (without any directory structure), the
- * function does nothing.
- *
- * @param path
- */
-export const ensureDirForFile = (path) => {
-    const dir = path.substring(0, path.lastIndexOf(sep));
-    return dir.length > 0 && !existsSync(dir)
-        ? (mkdirSync(dir, { recursive: true }), true)
-        : false;
+const ensureDirForFile = (path) => {
+  const dir = path.substring(0, path.lastIndexOf(sep));
+  return dir.length > 0 && !existsSync(dir) ? (mkdirSync(dir, { recursive: true }), true) : false;
+};
+const isDirectory = (path) => statSync(path).isDirectory();
+export {
+  ensureDirForFile,
+  isDirectory
 };
-/**
- * Returns true if `path` is a directory (assumes path exists).
- *
- * @param path
- */
-export const isDirectory = (path) => statSync(path).isDirectory();

package/ext.js

@@ -1,9 +1,7 @@
-/**
- * Returns file extension of given file `path`.
- *
- * @param path
- */
-export const fileExt = (path) => {
-    const match = /\.(\w+)$/.exec(path);
-    return match ? match[1].toLowerCase() : "";
+const fileExt = (path) => {
+  const match = /\.(\w+)$/.exec(path);
+  return match ? match[1].toLowerCase() : "";
+};
+export {
+  fileExt
 };

package/file-chunks.js

@@ -1,48 +1,38 @@
 import { U32 } from "@thi.ng/hex";
 import { open } from "fs/promises";
-/**
- * Async iterator. Yields chunks of byte buffers from given file. User
- * configurable size and byte ranges.
- *
- * @example
- * ```ts
- * for await(let buf of fileChunks("file.bin", { start: 16*1024*1024 })) {
- *   // ...
- * }
- * ```
- *
- * @param path
- * @param opts
- */
-export async function* fileChunks(path, opts) {
-    let { logger, size, start, end } = {
-        size: 1024,
-        start: 0,
-        end: Infinity,
-        ...opts,
-    };
-    logger &&
-        logger.debug(`start reading file chunks (size: 0x${size}): ${path}`);
-    let fd = undefined;
-    try {
-        fd = await open(path, "r");
-        while (start < end) {
-            logger &&
-                logger.debug(`reading chunk: 0x${U32(start)} - 0x${U32(start + size - 1)} (${path})`);
-            const { buffer, bytesRead } = await fd.read({
-                buffer: Buffer.alloc(size),
-                length: size,
-                position: start,
-            });
-            if (bytesRead === 0)
-                break;
-            yield buffer;
-            if (bytesRead < size)
-                break;
-            start += bytesRead;
-        }
-    }
-    finally {
-        await fd?.close();
+async function* fileChunks(path, opts) {
+  let { logger, size, start, end } = {
+    size: 1024,
+    start: 0,
+    end: Infinity,
+    ...opts
+  };
+  logger && logger.debug(`start reading file chunks (size: 0x${size}): ${path}`);
+  let fd = void 0;
+  try {
+    fd = await open(path, "r");
+    while (start < end) {
+      logger && logger.debug(
+        `reading chunk: 0x${U32(start)} - 0x${U32(
+          start + size - 1
+        )} (${path})`
+      );
+      const { buffer, bytesRead } = await fd.read({
+        buffer: Buffer.alloc(size),
+        length: size,
+        position: start
+      });
+      if (bytesRead === 0)
+        break;
+      yield buffer;
+      if (bytesRead < size)
+        break;
+      start += bytesRead;
     }
+  } finally {
+    await fd?.close();
+  }
 }
+export {
+  fileChunks
+};

package/files.js

@@ -3,81 +3,45 @@ import { isString } from "@thi.ng/checks/is-string";
 import { readdirSync, statSync } from "fs";
 import { sep } from "path";
 import { isDirectory } from "./dir.js";
-/**
- * Recursively reads given directory (up to given max. depth, default: infinite)
- * and yields sequence of file names matching given extension (or regexp or
- * predicate).
- *
- * @remarks
- * Files will be matched using their _full_ relative sub-path (starting with
- * given `dir`). If NO `match` is given, all files will be matched. Directories
- * will *not* be tested and are always traversed (up to given `maxDepth`).
- *
- * The optional `logger` is only used to log errors for files which couldn't be
- * accessed.
- *
- * @param dir
- * @param match
- * @param maxDepth
- * @param logger
- */
-export const files = (dir, match = "", maxDepth = Infinity, logger) => __files(dir, match, logger, maxDepth, 0);
+const files = (dir, match = "", maxDepth = Infinity, logger) => __files(dir, match, logger, maxDepth, 0);
 function* __files(dir, match = "", logger, maxDepth = Infinity, depth = 0) {
-    if (depth >= maxDepth)
-        return;
-    const pred = __ensurePred(match);
-    for (let f of readdirSync(dir).sort()) {
-        const curr = dir + sep + f;
-        try {
-            if (isDirectory(curr)) {
-                yield* __files(curr, match, logger, maxDepth, depth + 1);
-            }
-            else if (pred(curr)) {
-                yield curr;
-            }
-        }
-        catch (e) {
-            logger &&
-                logger.warn(`ignoring file: ${f} (${e.message})`);
-        }
+  if (depth >= maxDepth)
+    return;
+  const pred = __ensurePred(match);
+  for (let f of readdirSync(dir).sort()) {
+    const curr = dir + sep + f;
+    try {
+      if (isDirectory(curr)) {
+        yield* __files(curr, match, logger, maxDepth, depth + 1);
+      } else if (pred(curr)) {
+        yield curr;
+      }
+    } catch (e) {
+      logger && logger.warn(`ignoring file: ${f} (${e.message})`);
     }
+  }
 }
-/**
- * Similar to {@link files}, however yields iterator of only matching
- * sub-directories in given `dir`. Normal files are being ignored.
- *
- * @remarks
- * Like the matcher in {@link files}, the regex or predicate will be applied to
- * the _full_ sub-path (starting with `dir`) in order to determine a match.
- *
- * @param dir
- * @param match
- * @param maxDepth
- * @param logger
- */
-export const dirs = (dir, match = "", maxDepth = Infinity, logger) => __dirs(dir, match, logger, maxDepth, 0);
+const dirs = (dir, match = "", maxDepth = Infinity, logger) => __dirs(dir, match, logger, maxDepth, 0);
 function* __dirs(dir, match = "", logger, maxDepth = Infinity, depth = 0) {
-    if (depth >= maxDepth)
-        return;
-    const pred = __ensurePred(match);
-    for (let f of readdirSync(dir).sort()) {
-        const curr = dir + sep + f;
-        try {
-            if (statSync(curr).isDirectory()) {
-                if (pred(curr))
-                    yield curr;
-                yield* __dirs(curr, match, logger, maxDepth, depth + 1);
-            }
-        }
-        catch (e) {
-            logger &&
-                logger.warn(`ignoring file/dir: ${f} (${e.message})`);
-        }
+  if (depth >= maxDepth)
+    return;
+  const pred = __ensurePred(match);
+  for (let f of readdirSync(dir).sort()) {
+    const curr = dir + sep + f;
+    try {
+      if (statSync(curr).isDirectory()) {
+        if (pred(curr))
+          yield curr;
+        yield* __dirs(curr, match, logger, maxDepth, depth + 1);
+      }
+    } catch (e) {
+      logger && logger.warn(`ignoring file/dir: ${f} (${e.message})`);
     }
+  }
 }
-/** @internal */
 const __ensureRegEx = (match) => isString(match) ? new RegExp(`${match.replace(/\./g, "\\.")}$`) : match;
-const __ensurePred = (match) => isFunction(match)
-    ? match
-    : ((match = __ensureRegEx(match)),
-        (x) => match.test(x));
+const __ensurePred = (match) => isFunction(match) ? match : (match = __ensureRegEx(match), (x) => match.test(x));
+export {
+  dirs,
+  files
+};

package/hash.js

@@ -1,16 +1,20 @@
 import { createHash } from "crypto";
 import { readFileSync } from "fs";
-export const fileHash = (path, logger, algo = "sha256") => {
-    const sum = createHash(algo);
-    sum.update(readFileSync(path));
-    const hash = sum.digest("hex");
-    logger && logger.info(`${algo} hash for ${path}: ${hash}`);
-    return hash;
+const fileHash = (path, logger, algo = "sha256") => {
+  const sum = createHash(algo);
+  sum.update(readFileSync(path));
+  const hash = sum.digest("hex");
+  logger && logger.info(`${algo} hash for ${path}: ${hash}`);
+  return hash;
 };
-export const stringHash = (src, logger, algo = "sha256") => {
-    const sum = createHash(algo);
-    sum.update(src);
-    const hash = sum.digest("hex");
-    logger && logger.info(`${algo} hash for string: ${hash}`);
-    return hash;
+const stringHash = (src, logger, algo = "sha256") => {
+  const sum = createHash(algo);
+  sum.update(src);
+  const hash = sum.digest("hex");
+  logger && logger.info(`${algo} hash for string: ${hash}`);
+  return hash;
+};
+export {
+  fileHash,
+  stringHash
 };

package/json.js

@@ -1,18 +1,12 @@
 import { readText, writeText } from "./text.js";
-export const readJSON = (path, logger) => JSON.parse(readText(path, logger));
-/**
- * Serializes `obj` to JSON and writes result to UTF-8 file `path`. See
- * {@link writeText} for more details.
- *
- * @remarks
- * The `replacer` and `space` args are the same as supported by
- * `JSON.stringify()`.
- *
- * @param path
- * @param obj
- * @param replacer
- * @param space
- * @param logger
- * @param dryRun
- */
-export const writeJSON = (path, obj, replacer, space, logger, dryRun = false) => writeText(path, JSON.stringify(obj, replacer, space) + "\n", logger, dryRun);
+const readJSON = (path, logger) => JSON.parse(readText(path, logger));
+const writeJSON = (path, obj, replacer, space, logger, dryRun = false) => writeText(
+  path,
+  JSON.stringify(obj, replacer, space) + "\n",
+  logger,
+  dryRun
+);
+export {
+  readJSON,
+  writeJSON
+};

package/mask.js

@@ -1,8 +1,4 @@
-/**
- * Replaces `home` (default: `process.env.HOME`) sub-path with given `mask`
- * (default: `~`).
- *
- * @param path
- * @param home
- */
-export const maskHomeDir = (path, home = process.env.HOME, mask = "~") => (home ? path.replace(home, mask) : path);
+const maskHomeDir = (path, home = process.env.HOME, mask = "~") => home ? path.replace(home, mask) : path;
+export {
+  maskHomeDir
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/file-io",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Assorted file I/O utils (with logging support) for NodeJS",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,14 +35,15 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/hex": "^2.3.23",
-    "@thi.ng/logger": "^2.0.1",
-    "@thi.ng/random": "^3.6.17"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/hex": "^2.3.24",
+    "@thi.ng/logger": "^2.0.2",
+    "@thi.ng/random": "^3.6.18"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -114,5 +117,5 @@
     "status": "stable",
     "year": 2022
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/read.js

@@ -1,12 +1,9 @@
 import { readFileSync } from "fs";
-/**
- * Reads given file `path` into a byte array.
- *
- * @param path
- * @param logger
- */
-export const readBinary = (path, logger) => {
-    logger && logger.debug("reading file:", path);
-    const buf = readFileSync(path);
-    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+const readBinary = (path, logger) => {
+  logger && logger.debug("reading file:", path);
+  const buf = readFileSync(path);
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+};
+export {
+  readBinary
 };

package/temp.js

@@ -4,11 +4,15 @@ import { realpathSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
 import { sep } from "path";
 import { ensureDirForFile } from "./dir.js";
-export const createTempFile = (body, logger, name) => {
-    const path = tempFilePath(name);
-    logger && logger.debug("creating temp file:", path);
-    ensureDirForFile(path);
-    writeFileSync(path, body, isString(body) ? "utf-8" : undefined);
-    return path;
+const createTempFile = (body, logger, name) => {
+  const path = tempFilePath(name);
+  logger && logger.debug("creating temp file:", path);
+  ensureDirForFile(path);
+  writeFileSync(path, body, isString(body) ? "utf-8" : void 0);
+  return path;
+};
+const tempFilePath = (name) => realpathSync(tmpdir()) + sep + (name || randomID(16, "tmp-"));
+export {
+  createTempFile,
+  tempFilePath
 };
-export const tempFilePath = (name) => realpathSync(tmpdir()) + sep + (name || randomID(16, "tmp-"));

package/text.js

@@ -1,26 +1,18 @@
 import { isArray } from "@thi.ng/checks/is-array";
 import { readFileSync } from "fs";
 import { writeFile } from "./write.js";
-/**
- * Reads text from given file `path`, optionally with custom encoding (default:
- * UTF-8).
- *
- * @param path
- * @param logger
- * @param encoding
- */
-export const readText = (path, logger, encoding = "utf-8") => {
-    logger && logger.debug("reading file:", path);
-    return readFileSync(path, encoding);
+const readText = (path, logger, encoding = "utf-8") => {
+  logger && logger.debug("reading file:", path);
+  return readFileSync(path, encoding);
+};
+const writeText = (path, body, logger, dryRun = false) => writeFile(
+  path,
+  isArray(body) ? body.join("\n") : body,
+  "utf-8",
+  logger,
+  dryRun
+);
+export {
+  readText,
+  writeText
 };
-/**
- * Writes `body` as UTF-8 file to given `path`. If `dryRun` is true (default:
- * false), the file WON'T be written, however if a `logger` is provided then at
- * least a dry-run log message will be emitted.
- *
- * @param path
- * @param body
- * @param logger
- * @param dryRun
- */
-export const writeText = (path, body, logger, dryRun = false) => writeFile(path, isArray(body) ? body.join("\n") : body, "utf-8", logger, dryRun);

package/write.js

@@ -1,21 +1,13 @@
 import { isString } from "@thi.ng/checks/is-string";
 import { writeFileSync } from "fs";
 import { ensureDirForFile } from "./dir.js";
-/**
- * Writes `body` as to given `path` (using optional `opts` to define encoding).
- * If `dryRun` is true (default: false), the file WON'T be written, however if a
- * `logger` is provided then at least a dry-run log message will be emitted.
- *
- * @param path
- * @param body
- * @param opts
- * @param logger
- * @param dryRun
- */
-export const writeFile = (path, body, opts, logger, dryRun = false) => {
-    logger && logger.info(`${dryRun ? "[dryrun] " : ""}writing file: ${path}`);
-    if (dryRun)
-        return;
-    ensureDirForFile(path);
-    writeFileSync(path, body, !opts && isString(body) ? "utf-8" : opts);
+const writeFile = (path, body, opts, logger, dryRun = false) => {
+  logger && logger.info(`${dryRun ? "[dryrun] " : ""}writing file: ${path}`);
+  if (dryRun)
+    return;
+  ensureDirForFile(path);
+  writeFileSync(path, body, !opts && isString(body) ? "utf-8" : opts);
+};
+export {
+  writeFile
 };