@naturalcycles/nodejs-lib 13.5.0 → 13.6.0

package/dist/fs/del.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.delSync = exports.del = void 0;
-const tslib_1 = require("tslib");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const promises_1 = tslib_1.__importDefault(require("node:fs/promises"));
 const js_lib_1 = require("@naturalcycles/js-lib");
 const colors_1 = require("../colors/colors");
 const index_1 = require("../index");
@@ -44,9 +41,7 @@ async function del(_opt) {
     }
     if (dry)
         return;
-    await (0, js_lib_1.pMap)(filenames, filepath => promises_1.default.rm(filepath, {
-        force: true,
-    }), { concurrency });
+    await (0, js_lib_1.pMap)(filenames, filepath => index_1.fs2.removePath(filepath), { concurrency });
     // 2. glob only dirs, expand, delete only empty!
     let dirnames = await (0, index_1.globby)(patterns, {
         dot: true,
@@ -55,7 +50,7 @@ async function del(_opt) {
     });
     // Add original patterns (if any of them are dirs)
     dirnames = dirnames.concat(await (0, js_lib_1.pFilter)(patterns, async (pattern) => {
-        return (await (0, index_1._pathExists)(pattern)) && (await promises_1.default.lstat(pattern)).isDirectory();
+        return (await index_1.fs2.pathExistsAsync(pattern)) && (await index_1.fs2.lstatAsync(pattern)).isDirectory();
     }));
     const dirnamesSorted = dirnames.sort().reverse();
     // console.log({ dirnamesSorted })
@@ -63,7 +58,7 @@ async function del(_opt) {
     for await (const dirpath of dirnamesSorted) {
         if (await isEmptyDir(dirpath)) {
             // console.log(`empty dir: ${dirpath}`)
-            await promises_1.default.rm(dirpath, { force: true, recursive: true });
+            await index_1.fs2.removePathAsync(dirpath);
             deletedDirs.push(dirpath);
         }
     }
@@ -101,7 +96,7 @@ function delSync(_opt) {
     }
     if (dry)
         return;
-    filenames.forEach(filepath => node_fs_1.default.rmSync(filepath, { force: true }));
+    filenames.forEach(filepath => index_1.fs2.removePath(filepath));
     // 2. glob only dirs, expand, delete only empty!
     let dirnames = index_1.globby.sync(patterns, {
         dot: true,
@@ -109,14 +104,14 @@ function delSync(_opt) {
         onlyDirectories: true,
     });
     // Add original patterns (if any of them are dirs)
-    dirnames = dirnames.concat(patterns.filter(p => (0, index_1._pathExistsSync)(p) && node_fs_1.default.lstatSync(p).isDirectory()));
+    dirnames = dirnames.concat(patterns.filter(p => index_1.fs2.pathExists(p) && index_1.fs2.lstat(p).isDirectory()));
     const dirnamesSorted = dirnames.sort().reverse();
     // console.log({ dirnamesSorted })
     const deletedDirs = [];
     for (const dirpath of dirnamesSorted) {
         if (isEmptyDirSync(dirpath)) {
             // console.log(`empty dir: ${dirpath}`)
-            node_fs_1.default.rmSync(dirpath, { force: true, recursive: true });
+            index_1.fs2.removePath(dirpath);
             deletedDirs.push(dirpath);
         }
     }
@@ -132,8 +127,8 @@ exports.delSync = delSync;
 // 2. glob only dirs, expand, delete only empty!
 // 3. test each original pattern, if it exists and is directory and is empty - delete
 async function isEmptyDir(dir) {
-    return (await promises_1.default.readdir(dir)).length === 0;
+    return (await index_1.fs2.readdirAsync(dir)).length === 0;
 }
 function isEmptyDirSync(dir) {
-    return node_fs_1.default.readdirSync(dir).length === 0;
+    return index_1.fs2.readdir(dir).length === 0;
 }

package/dist/fs/fs2.d.ts

@@ -0,0 +1,79 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { RmOptions } from 'node:fs';
+import fs from 'node:fs';
+import { DumpOptions } from 'js-yaml';
+/**
+ * fs2 conveniently groups filesystem functions together.
+ * Supposed to be almost a drop-in replacement for these things together:
+ *
+ * 1. node:fs
+ * 2. node:fs/promises
+ * 3. fs-extra
+ */
+declare class FS2 {
+    /**
+     * Convenience wrapper that defaults to utf-8 string output.
+     */
+    readText(filePath: string): string;
+    /**
+     * Convenience wrapper that defaults to utf-8 string output.
+     */
+    readTextAsync(filePath: string): Promise<string>;
+    readBuffer(filePath: string): Buffer;
+    readBufferAsync(filePath: string): Promise<Buffer>;
+    readJson<T = unknown>(filePath: string): T;
+    readJsonAsync<T = unknown>(filePath: string): Promise<T>;
+    readYaml<T = unknown>(filePath: string): T;
+    readYamlAsync<T = unknown>(filePath: string): Promise<T>;
+    writeFile(filePath: string, data: string | Buffer): void;
+    writeFileAsync(filePath: string, data: string | Buffer): Promise<void>;
+    writeJson(filePath: string, data: any, opt?: JsonOptions): void;
+    writeJsonAsync(filePath: string, data: any, opt?: JsonOptions): Promise<void>;
+    writeYaml(filePath: string, data: any, opt?: DumpOptions): void;
+    writeYamlAsync(filePath: string, data: any, opt?: DumpOptions): Promise<void>;
+    outputJson(filePath: string, data: any, opt?: JsonOptions): void;
+    outputJsonAsync(filePath: string, data: any, opt?: JsonOptions): Promise<void>;
+    outputYaml(filePath: string, data: any, opt?: DumpOptions): void;
+    outputYamlAsync(filePath: string, data: any, opt?: DumpOptions): Promise<void>;
+    outputFile(filePath: string, data: string | Buffer): void;
+    outputFileAsync(filePath: string, data: string | Buffer): Promise<void>;
+    pathExists(filePath: string): boolean;
+    pathExistsAsync(filePath: string): Promise<boolean>;
+    ensureDir(dirPath: string): void;
+    ensureDirAsync(dirPath: string): Promise<void>;
+    ensureFile(filePath: string): void;
+    ensureFileAsync(filePath: string): Promise<void>;
+    removePath(fileOrDirPath: string, opt?: RmOptions): void;
+    removePathAsync(fileOrDirPath: string, opt?: RmOptions): Promise<void>;
+    emptyDir(dirPath: string): void;
+    emptyDirAsync(dirPath: string): Promise<void>;
+    /**
+     * Cautious, underlying Node function is currently Experimental.
+     */
+    copyPath(src: string, dest: string, opt?: fs.CopySyncOptions): void;
+    /**
+     * Cautious, underlying Node function is currently Experimental.
+     */
+    copyPathAsync(src: string, dest: string, opt?: fs.CopyOptions): Promise<void>;
+    movePath(src: string, dest: string, opt?: fs.CopySyncOptions): void;
+    movePathAsync(src: string, dest: string, opt?: fs.CopyOptions): Promise<void>;
+    fs: typeof fs;
+    fsp: typeof fs.promises;
+    lstat: fs.StatSyncFn;
+    lstatAsync: typeof fs.promises.lstat;
+    stat: fs.StatSyncFn;
+    statAsync: typeof fs.promises.stat;
+    mkdir: typeof fs.mkdirSync;
+    mkdirAsync: typeof fs.promises.mkdir;
+    readdir: typeof fs.readdirSync;
+    readdirAsync: typeof fs.promises.readdir;
+    createWriteStream: typeof fs.createWriteStream;
+    createReadStream: typeof fs.createReadStream;
+}
+export declare const fs2: FS2;
+export interface JsonOptions {
+    spaces?: number;
+}
+export {};

package/dist/fs/fs2.js

@@ -0,0 +1,267 @@
+"use strict";
+/*
+
+Why?
+
+Convenience re-export/re-implementation of most common fs functions from
+node:fs, node:fs/promises and fs-extra
+
+Defaults to string input/output, as it's used in 80% of time. For the rest - you can use native fs.
+
+Allows to import it easier, so you don't have to choose between the 3 import locations.
+That's why function names are slightly renamed, to avoid conflict.
+
+Credit to: fs-extra (https://github.com/jprichardson/node-fs-extra)
+
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fs2 = void 0;
+const tslib_1 = require("tslib");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const promises_1 = tslib_1.__importDefault(require("node:fs/promises"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const js_lib_1 = require("@naturalcycles/js-lib");
+const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
+/**
+ * fs2 conveniently groups filesystem functions together.
+ * Supposed to be almost a drop-in replacement for these things together:
+ *
+ * 1. node:fs
+ * 2. node:fs/promises
+ * 3. fs-extra
+ */
+class FS2 {
+    constructor() {
+        // Naming convention is:
+        // - async function has Async in the name, e.g readTextAsync
+        // - sync function has postfix in the name, e.g readText
+        // Re-export the whole fs/fsp, for the edge cases where they are needed
+        this.fs = node_fs_1.default;
+        this.fsp = promises_1.default;
+        // Re-export existing fs/fsp functions
+        // rm/rmAsync are replaced with removePath/removePathAsync
+        this.lstat = node_fs_1.default.lstatSync;
+        this.lstatAsync = promises_1.default.lstat;
+        this.stat = node_fs_1.default.statSync;
+        this.statAsync = promises_1.default.stat;
+        this.mkdir = node_fs_1.default.mkdirSync;
+        this.mkdirAsync = promises_1.default.mkdir;
+        this.readdir = node_fs_1.default.readdirSync;
+        this.readdirAsync = promises_1.default.readdir;
+        this.createWriteStream = node_fs_1.default.createWriteStream;
+        this.createReadStream = node_fs_1.default.createReadStream;
+    }
+    /**
+     * Convenience wrapper that defaults to utf-8 string output.
+     */
+    readText(filePath) {
+        return node_fs_1.default.readFileSync(filePath, 'utf8');
+    }
+    /**
+     * Convenience wrapper that defaults to utf-8 string output.
+     */
+    async readTextAsync(filePath) {
+        return await promises_1.default.readFile(filePath, 'utf8');
+    }
+    readBuffer(filePath) {
+        return node_fs_1.default.readFileSync(filePath);
+    }
+    async readBufferAsync(filePath) {
+        return await promises_1.default.readFile(filePath);
+    }
+    readJson(filePath) {
+        const str = node_fs_1.default.readFileSync(filePath, 'utf8');
+        return (0, js_lib_1._jsonParse)(str);
+    }
+    async readJsonAsync(filePath) {
+        const str = await promises_1.default.readFile(filePath, 'utf8');
+        return (0, js_lib_1._jsonParse)(str);
+    }
+    readYaml(filePath) {
+        return js_yaml_1.default.load(node_fs_1.default.readFileSync(filePath, 'utf8'));
+    }
+    async readYamlAsync(filePath) {
+        return js_yaml_1.default.load(await promises_1.default.readFile(filePath, 'utf8'));
+    }
+    writeFile(filePath, data) {
+        node_fs_1.default.writeFileSync(filePath, data);
+    }
+    async writeFileAsync(filePath, data) {
+        await promises_1.default.writeFile(filePath, data);
+    }
+    writeJson(filePath, data, opt) {
+        const str = stringify(data, opt);
+        node_fs_1.default.writeFileSync(filePath, str);
+    }
+    async writeJsonAsync(filePath, data, opt) {
+        const str = stringify(data, opt);
+        await promises_1.default.writeFile(filePath, str);
+    }
+    writeYaml(filePath, data, opt) {
+        const str = js_yaml_1.default.dump(data, opt);
+        node_fs_1.default.writeFileSync(filePath, str);
+    }
+    async writeYamlAsync(filePath, data, opt) {
+        const str = js_yaml_1.default.dump(data, opt);
+        await promises_1.default.writeFile(filePath, str);
+    }
+    outputJson(filePath, data, opt) {
+        const str = stringify(data, opt);
+        this.outputFile(filePath, str);
+    }
+    async outputJsonAsync(filePath, data, opt) {
+        const str = stringify(data, opt);
+        await this.outputFileAsync(filePath, str);
+    }
+    outputYaml(filePath, data, opt) {
+        const str = js_yaml_1.default.dump(data, opt);
+        this.outputFile(filePath, str);
+    }
+    async outputYamlAsync(filePath, data, opt) {
+        const str = js_yaml_1.default.dump(data, opt);
+        await this.outputFileAsync(filePath, str);
+    }
+    outputFile(filePath, data) {
+        const dirPath = node_path_1.default.dirname(filePath);
+        if (!node_fs_1.default.existsSync(dirPath)) {
+            this.ensureDir(dirPath);
+        }
+        node_fs_1.default.writeFileSync(filePath, data);
+    }
+    async outputFileAsync(filePath, data) {
+        const dirPath = node_path_1.default.dirname(filePath);
+        if (!(await this.pathExistsAsync(dirPath))) {
+            await this.ensureDirAsync(dirPath);
+        }
+        await promises_1.default.writeFile(filePath, data);
+    }
+    pathExists(filePath) {
+        return node_fs_1.default.existsSync(filePath);
+    }
+    async pathExistsAsync(filePath) {
+        try {
+            await promises_1.default.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    ensureDir(dirPath) {
+        node_fs_1.default.mkdirSync(dirPath, {
+            mode: 0o777,
+            recursive: true,
+        });
+    }
+    async ensureDirAsync(dirPath) {
+        await promises_1.default.mkdir(dirPath, {
+            mode: 0o777,
+            recursive: true,
+        });
+    }
+    ensureFile(filePath) {
+        let stats;
+        try {
+            stats = node_fs_1.default.statSync(filePath);
+        }
+        catch { }
+        if (stats?.isFile())
+            return;
+        const dir = node_path_1.default.dirname(filePath);
+        try {
+            if (!node_fs_1.default.statSync(dir).isDirectory()) {
+                // parent is not a directory
+                // This is just to cause an internal ENOTDIR error to be thrown
+                node_fs_1.default.readdirSync(dir);
+            }
+        }
+        catch (err) {
+            // If the stat call above failed because the directory doesn't exist, create it
+            if (err?.code === 'ENOENT')
+                return this.ensureDir(dir);
+            throw err;
+        }
+        node_fs_1.default.writeFileSync(filePath, '');
+    }
+    async ensureFileAsync(filePath) {
+        let stats;
+        try {
+            stats = await promises_1.default.stat(filePath);
+        }
+        catch { }
+        if (stats?.isFile())
+            return;
+        const dir = node_path_1.default.dirname(filePath);
+        try {
+            if (!(await promises_1.default.stat(dir)).isDirectory()) {
+                // parent is not a directory
+                // This is just to cause an internal ENOTDIR error to be thrown
+                await promises_1.default.readdir(dir);
+            }
+        }
+        catch (err) {
+            // If the stat call above failed because the directory doesn't exist, create it
+            if (err?.code === 'ENOENT')
+                return await this.ensureDirAsync(dir);
+            throw err;
+        }
+        await promises_1.default.writeFile(filePath, '');
+    }
+    removePath(fileOrDirPath, opt) {
+        node_fs_1.default.rmSync(fileOrDirPath, { recursive: true, force: true, ...opt });
+    }
+    async removePathAsync(fileOrDirPath, opt) {
+        await promises_1.default.rm(fileOrDirPath, { recursive: true, force: true, ...opt });
+    }
+    emptyDir(dirPath) {
+        let items;
+        try {
+            items = node_fs_1.default.readdirSync(dirPath);
+        }
+        catch {
+            return this.ensureDir(dirPath);
+        }
+        items.forEach(item => this.removePath(node_path_1.default.join(dirPath, item)));
+    }
+    async emptyDirAsync(dirPath) {
+        let items;
+        try {
+            items = await promises_1.default.readdir(dirPath);
+        }
+        catch {
+            return await this.ensureDirAsync(dirPath);
+        }
+        await Promise.all(items.map(item => this.removePathAsync(node_path_1.default.join(dirPath, item))));
+    }
+    /**
+     * Cautious, underlying Node function is currently Experimental.
+     */
+    copyPath(src, dest, opt) {
+        node_fs_1.default.cpSync(src, dest, {
+            recursive: true,
+            ...opt,
+        });
+    }
+    /**
+     * Cautious, underlying Node function is currently Experimental.
+     */
+    async copyPathAsync(src, dest, opt) {
+        await promises_1.default.cp(src, dest, {
+            recursive: true,
+            ...opt,
+        });
+    }
+    movePath(src, dest, opt) {
+        this.copyPath(src, dest, opt);
+        this.removePath(src);
+    }
+    async movePathAsync(src, dest, opt) {
+        await this.copyPathAsync(src, dest, opt);
+        await this.removePathAsync(src);
+    }
+}
+exports.fs2 = new FS2();
+function stringify(data, opt) {
+    // If pretty-printing is enabled (spaces) - also add a newline at the end (to match our prettier config)
+    return JSON.stringify(data, null, opt?.spaces) + (opt?.spaces ? '\n' : '');
+}

package/dist/fs/json2env.js

@@ -4,7 +4,7 @@ exports.objectToGithubActionsEnv = exports.objectToShellExport = exports.appendT
 const tslib_1 = require("tslib");
 const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
 const colors_1 = require("../colors/colors");
-const fs_util_1 = require("./fs.util");
+const fs2_1 = require("./fs2");
 const JSON2ENV_OPT_DEF = {
     saveEnvFile: true,
     bashEnv: true,
@@ -16,7 +16,7 @@ function json2env(opt) {
         ...JSON2ENV_OPT_DEF,
         ...opt,
     };
-    if (!(0, fs_util_1._pathExistsSync)(jsonPath)) {
+    if (!fs2_1.fs2.pathExists(jsonPath)) {
         if (fail) {
             throw new Error(`Path doesn't exist: ${jsonPath}`);
         }
@@ -29,14 +29,14 @@ function json2env(opt) {
         return;
     }
     // read file
-    const json = (0, fs_util_1._readJsonSync)(jsonPath);
+    const json = fs2_1.fs2.readJson(jsonPath);
     if (debug) {
         console.log(json);
     }
     if (saveEnvFile) {
         const shPath = `${jsonPath}.sh`;
         const exportStr = objectToShellExport(json, prefix);
-        (0, fs_util_1._writeFileSync)(shPath, exportStr);
+        fs2_1.fs2.writeFile(shPath, exportStr);
         if (!silent) {
             console.log(`json2env created ${(0, colors_1.dimGrey)(shPath)}:`);
             console.log(exportStr);

package/dist/fs/kpy.js

@@ -21,12 +21,12 @@ async function kpy(opt) {
         const destFilename = node_path_1.default.resolve(opt.outputDir, opt.flat ? basename : filename);
         if (!opt.dry) {
             if (opt.move) {
-                await (0, index_1._movePath)(srcFilename, destFilename, {
+                await index_1.fs2.movePathAsync(srcFilename, destFilename, {
                     force: overwrite,
                 });
             }
             else {
-                await (0, index_1._copyPath)(srcFilename, destFilename, { force: overwrite });
+                await index_1.fs2.copyPathAsync(srcFilename, destFilename, { force: overwrite });
             }
         }
         if (opt.verbose) {
@@ -51,10 +51,10 @@ function kpySync(opt) {
         const destFilename = node_path_1.default.resolve(opt.outputDir, opt.flat ? basename : filename);
         if (!opt.dry) {
             if (opt.move) {
-                (0, index_1._movePathSync)(srcFilename, destFilename, { force: overwrite });
+                index_1.fs2.movePath(srcFilename, destFilename, { force: overwrite });
             }
             else {
-                (0, index_1._copyPathSync)(srcFilename, destFilename, { force: overwrite });
+                index_1.fs2.copyPath(srcFilename, destFilename, { force: overwrite });
             }
         }
         if (opt.verbose) {
@@ -71,11 +71,11 @@ function kpyPrepare(opt) {
     // default to cwd
     opt.baseDir ||= '.';
     opt.outputDir ||= '.';
-    if (!(0, index_1._pathExistsSync)(opt.baseDir)) {
+    if (!index_1.fs2.pathExists(opt.baseDir)) {
         console.log(`kpy: baseDir doesn't exist: ${(0, colors_1.boldWhite)(opt.baseDir)}`);
         return;
     }
-    (0, index_1._ensureDirSync)(opt.outputDir);
+    index_1.fs2.ensureDir(opt.outputDir);
 }
 function kpyLogFilenames(opt, filenames) {
     if (opt.silent)

package/dist/index.d.ts

@@ -76,7 +76,7 @@ export * from './validation/joi/joi.validation.error';
 export * from './validation/joi/joi.validation.util';
 export * from './script/runScript';
 export * from './jwt/jwt.service';
-export * from './fs/fs.util';
+export * from './fs/fs2';
 export * from './fs/del';
 export * from './fs/json2env';
 export * from './fs/kpy';

package/dist/index.js

@@ -80,7 +80,7 @@ tslib_1.__exportStar(require("./validation/joi/joi.validation.error"), exports);
 tslib_1.__exportStar(require("./validation/joi/joi.validation.util"), exports);
 tslib_1.__exportStar(require("./script/runScript"), exports);
 tslib_1.__exportStar(require("./jwt/jwt.service"), exports);
-tslib_1.__exportStar(require("./fs/fs.util"), exports);
+tslib_1.__exportStar(require("./fs/fs2"), exports);
 tslib_1.__exportStar(require("./fs/del"), exports);
 tslib_1.__exportStar(require("./fs/json2env"), exports);
 tslib_1.__exportStar(require("./fs/kpy"), exports);

package/dist/secret/secrets-decrypt.util.js

@@ -27,8 +27,8 @@ function secretsDecrypt(dir, file, encKeyBuffer, del = false, jsonMode = false)
             (0, js_lib_1._assert)(filename.endsWith('.json'), `${node_path_1.default.basename(filename)} MUST end with '.json'`);
             (0, js_lib_1._assert)(!filename.endsWith('.plain.json'), `${node_path_1.default.basename(filename)} MUST NOT end with '.plain.json'`);
             plainFilename = filename.replace('.json', '.plain.json');
-            const json = (0, crypto_util_1.decryptObject)((0, index_1._readJsonSync)(filename), encKeyBuffer);
-            (0, index_1._writeJsonSync)(plainFilename, json, { spaces: 2 });
+            const json = (0, crypto_util_1.decryptObject)(index_1.fs2.readJson(filename), encKeyBuffer);
+            index_1.fs2.writeJson(plainFilename, json, { spaces: 2 });
         }
         else {
             const enc = node_fs_1.default.readFileSync(filename);

package/dist/secret/secrets-encrypt.util.js

@@ -25,8 +25,8 @@ function secretsEncrypt(pattern, file, encKeyBuffer, del = false, jsonMode = fal
         if (jsonMode) {
             (0, js_lib_1._assert)(filename.endsWith('.plain.json'), `${node_path_1.default.basename(filename)} MUST end with '.plain.json'`);
             encFilename = filename.replace('.plain', '');
-            const json = (0, crypto_util_1.encryptObject)((0, index_1._readJsonSync)(filename), encKeyBuffer);
-            (0, index_1._writeJsonSync)(encFilename, json, { spaces: 2 });
+            const json = (0, crypto_util_1.encryptObject)(index_1.fs2.readJson(filename), encKeyBuffer);
+            index_1.fs2.writeJson(encFilename, json, { spaces: 2 });
         }
         else {
             const plain = node_fs_1.default.readFileSync(filename);

package/dist/stream/ndjson/pipelineToNDJsonFile.js

@@ -16,12 +16,12 @@ const transformToNDJson_1 = require("./transformToNDJson");
  */
 async function pipelineToNDJsonFile(streams, opt) {
     const { filePath, gzip, protectFromOverwrite = false } = opt;
-    if (protectFromOverwrite && (0, __1._pathExistsSync)(filePath)) {
+    if (protectFromOverwrite && __1.fs2.pathExists(filePath)) {
         throw new js_lib_1.AppError(`pipelineToNDJsonFile: output file exists: ${filePath}`);
     }
     const started = Date.now();
     let rows = 0;
-    (0, __1._ensureFileSync)(filePath);
+    __1.fs2.ensureFile(filePath);
     console.log(`>> ${(0, colors_1.grey)(filePath)} started...`);
     await (0, __1._pipeline)([
         ...streams,

package/dist/util/buildInfo.util.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateBuildInfo = void 0;
 const js_lib_1 = require("@naturalcycles/js-lib");
-const fs_util_1 = require("../fs/fs.util");
+const fs2_1 = require("../fs/fs2");
 const git_util_1 = require("./git.util");
 function generateBuildInfo(opt = {}) {
     const now = (0, js_lib_1.localTimeOrNow)(opt.overrideTimestamp);
@@ -16,8 +16,8 @@ function generateBuildInfo(opt = {}) {
     if (!env) {
         // Attempt to read `envByBranch` from package.json root
         try {
-            if ((0, fs_util_1._pathExistsSync)('package.json')) {
-                const packageJson = (0, fs_util_1._readJsonSync)('package.json');
+            if (fs2_1.fs2.pathExists('package.json')) {
+                const packageJson = fs2_1.fs2.readJson('package.json');
                 env = packageJson?.['envByBranch']?.[branchName] || packageJson?.['envByBranch']?.['*'];
             }
         }

package/dist/validation/ajv/ajv.util.js

@@ -12,7 +12,7 @@ const ajvSchema_1 = require("./ajvSchema");
  * @experimental
  */
 function readJsonSchemas(patterns, opt) {
-    return __1.fastGlob.sync(patterns, opt).map(fileName => (0, __1._readJsonSync)(fileName));
+    return __1.fastGlob.sync(patterns, opt).map(fileName => __1.fs2.readJson(fileName));
 }
 exports.readJsonSchemas = readJsonSchemas;
 /**

package/dist/validation/ajv/ajvSchema.js

@@ -59,7 +59,7 @@ class AjvSchema {
      */
     static readJsonSync(filePath, cfg = {}) {
         (0, index_1.requireFileToExist)(filePath);
-        const schema = (0, index_1._readJsonSync)(filePath);
+        const schema = index_1.fs2.readJson(filePath);
         return new AjvSchema(schema, cfg);
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/nodejs-lib",
-  "version": "13.5.0",
+  "version": "13.6.0",
   "scripts": {
     "prepare": "husky install",
     "docs-serve": "vuepress dev docs",
@@ -15,6 +15,7 @@
   },
   "dependencies": {
     "@naturalcycles/js-lib": "^14.0.0",
+    "@types/js-yaml": "^4.0.9",
     "@types/jsonwebtoken": "^9.0.0",
     "@types/through2-concurrent": "^2.0.0",
     "ajv": "^8.6.2",
@@ -27,6 +28,7 @@
     "fast-glob": "^3.2.11",
     "globby": "^11.0.0",
     "joi": "^17.9.2",
+    "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.0",
     "lru-cache": "^10.0.0",
     "through2-concurrent": "^2.0.0",