@naturalcycles/nodejs-lib 12.90.4 → 12.91.0

package/dist/csv/csvReader.js

@@ -41,7 +41,7 @@ function csvStringToArray(str) {
         if (matches[1].length && matches[1] !== ',') {
             arr.push([]);
         }
-        arr[arr.length - 1].push(matches[2] ? matches[2].replace(new RegExp('""', 'g'), '"') : matches[3]);
+        arr[arr.length - 1].push(matches[2] ? matches[2].replaceAll(new RegExp('""', 'g'), '"') : matches[3]);
     }
     return arr;
 }

package/dist/csv/csvWriter.js

@@ -34,7 +34,7 @@ class CSVWriter {
         return this.shouldQuote(s) ? this.quote(s) : s;
     }
     quote(s) {
-        return `"${s.replace(/"/g, '""')}"`;
+        return `"${s.replaceAll('"', '""')}"`;
     }
     shouldQuote(s) {
         return s.includes(this.cfg.delimiter) || s.includes('"') || s.includes('\n') || s.includes('\r');

package/dist/fs/fs.util.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import type { CopyOptions, CopyOptionsSync, MoveOptions } from 'fs-extra';
+export interface JsonOptions {
+    spaces?: number;
+}
+/**
+ * Convenience wrapper that defaults to utf-8 string output.
+ */
+export declare function _readFile(filePath: string): Promise<string>;
+/**
+ * Convenience wrapper that defaults to utf-8 string output.
+ */
+export declare function _readFileSync(filePath: string): string;
+export declare function _readJsonFile<T = unknown>(filePath: string): Promise<T>;
+export declare function _readJsonFileSync<T = unknown>(filePath: string): T;
+export declare function _writeFile(filePath: string, data: string | Buffer): Promise<void>;
+export declare function _writeFileSync(filePath: string, data: string | Buffer): void;
+export declare function _outputFile(filePath: string, data: string | Buffer): Promise<void>;
+export declare function _outputFileSync(filePath: string, data: string | Buffer): void;
+export declare function _writeJsonFile(filePath: string, data: any, opt?: JsonOptions): Promise<void>;
+export declare function _writeJsonFileSync(filePath: string, data: any, opt?: JsonOptions): void;
+export declare function _outputJsonFile(filePath: string, data: any, opt?: JsonOptions): Promise<void>;
+export declare function _outputJsonFileSync(filePath: string, data: any, opt?: JsonOptions): void;
+export declare function _pathExists(filePath: string): Promise<boolean>;
+export declare function _pathExistsSync(filePath: string): boolean;
+export declare function _ensureDir(dirPath: string): Promise<void>;
+export declare function _ensureDirSync(dirPath: string): void;
+export declare function _ensureFileSync(filePath: string): void;
+export declare function _removePath(fileOrDirPath: string): Promise<void>;
+export declare function _removePathSync(fileOrDirPath: string): void;
+export declare function _emptyDir(dirPath: string): Promise<void>;
+export declare function _emptyDirSync(dirPath: string): void;
+export declare function _copyPath(src: string, dest: string, opt?: CopyOptions): Promise<void>;
+export declare function _copyPathSync(src: string, dest: string, opt?: CopyOptionsSync): void;
+export declare function _movePath(src: string, dest: string, opt?: MoveOptions): Promise<void>;
+export declare function _movePathSync(src: string, dest: string, opt?: MoveOptions): void;

package/dist/fs/fs.util.js

@@ -0,0 +1,192 @@
+"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._movePathSync = exports._movePath = exports._copyPathSync = exports._copyPath = exports._emptyDirSync = exports._emptyDir = exports._removePathSync = exports._removePath = exports._ensureFileSync = exports._ensureDirSync = exports._ensureDir = exports._pathExistsSync = exports._pathExists = exports._outputJsonFileSync = exports._outputJsonFile = exports._writeJsonFileSync = exports._writeJsonFile = exports._outputFileSync = exports._outputFile = exports._writeFileSync = exports._writeFile = exports._readJsonFileSync = exports._readJsonFile = exports._readFileSync = exports._readFile = void 0;
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
+const path = require("node:path");
+const js_lib_1 = require("@naturalcycles/js-lib");
+const fse = require("fs-extra");
+/**
+ * Convenience wrapper that defaults to utf-8 string output.
+ */
+async function _readFile(filePath) {
+    return await fsp.readFile(filePath, 'utf8');
+}
+exports._readFile = _readFile;
+/**
+ * Convenience wrapper that defaults to utf-8 string output.
+ */
+function _readFileSync(filePath) {
+    return fs.readFileSync(filePath, 'utf8');
+}
+exports._readFileSync = _readFileSync;
+async function _readJsonFile(filePath) {
+    const str = await fsp.readFile(filePath, 'utf8');
+    return (0, js_lib_1._jsonParse)(str);
+}
+exports._readJsonFile = _readJsonFile;
+function _readJsonFileSync(filePath) {
+    const str = fs.readFileSync(filePath, 'utf8');
+    return (0, js_lib_1._jsonParse)(str);
+}
+exports._readJsonFileSync = _readJsonFileSync;
+async function _writeFile(filePath, data) {
+    await fsp.writeFile(filePath, data);
+}
+exports._writeFile = _writeFile;
+function _writeFileSync(filePath, data) {
+    fs.writeFileSync(filePath, data);
+}
+exports._writeFileSync = _writeFileSync;
+async function _outputFile(filePath, data) {
+    const dirPath = path.dirname(filePath);
+    if (!(await _pathExists(dirPath))) {
+        await _ensureDir(dirPath);
+    }
+    await fsp.writeFile(filePath, data);
+}
+exports._outputFile = _outputFile;
+function _outputFileSync(filePath, data) {
+    const dirPath = path.dirname(filePath);
+    if (!fs.existsSync(dirPath)) {
+        _ensureDirSync(dirPath);
+    }
+    fs.writeFileSync(filePath, data);
+}
+exports._outputFileSync = _outputFileSync;
+async function _writeJsonFile(filePath, data, opt) {
+    const str = JSON.stringify(data, null, opt?.spaces);
+    await fsp.writeFile(filePath, str);
+}
+exports._writeJsonFile = _writeJsonFile;
+function _writeJsonFileSync(filePath, data, opt) {
+    const str = JSON.stringify(data, null, opt?.spaces);
+    fs.writeFileSync(filePath, str);
+}
+exports._writeJsonFileSync = _writeJsonFileSync;
+async function _outputJsonFile(filePath, data, opt) {
+    const str = JSON.stringify(data, null, opt?.spaces);
+    await _outputFile(filePath, str);
+}
+exports._outputJsonFile = _outputJsonFile;
+function _outputJsonFileSync(filePath, data, opt) {
+    const str = JSON.stringify(data, null, opt?.spaces);
+    _outputFileSync(filePath, str);
+}
+exports._outputJsonFileSync = _outputJsonFileSync;
+async function _pathExists(filePath) {
+    try {
+        await fsp.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+exports._pathExists = _pathExists;
+function _pathExistsSync(filePath) {
+    return fs.existsSync(filePath);
+}
+exports._pathExistsSync = _pathExistsSync;
+async function _ensureDir(dirPath) {
+    await fsp.mkdir(dirPath, {
+        mode: 0o777,
+        recursive: true,
+    });
+}
+exports._ensureDir = _ensureDir;
+function _ensureDirSync(dirPath) {
+    fs.mkdirSync(dirPath, {
+        mode: 0o777,
+        recursive: true,
+    });
+}
+exports._ensureDirSync = _ensureDirSync;
+// Skipping `_ensureFile` (async), until it's needed
+function _ensureFileSync(filePath) {
+    let stats;
+    try {
+        stats = fs.statSync(filePath);
+    }
+    catch { }
+    if (stats?.isFile())
+        return;
+    const dir = path.dirname(filePath);
+    try {
+        if (!fs.statSync(dir).isDirectory()) {
+            // parent is not a directory
+            // This is just to cause an internal ENOTDIR error to be thrown
+            fs.readdirSync(dir);
+        }
+    }
+    catch (err) {
+        // If the stat call above failed because the directory doesn't exist, create it
+        if (err?.code === 'ENOENT')
+            return _ensureDirSync(dir);
+        throw err;
+    }
+    fs.writeFileSync(filePath, '');
+}
+exports._ensureFileSync = _ensureFileSync;
+async function _removePath(fileOrDirPath) {
+    await fsp.rm(fileOrDirPath, { recursive: true, force: true });
+}
+exports._removePath = _removePath;
+function _removePathSync(fileOrDirPath) {
+    fs.rmSync(fileOrDirPath, { recursive: true, force: true });
+}
+exports._removePathSync = _removePathSync;
+async function _emptyDir(dirPath) {
+    let items;
+    try {
+        items = await fsp.readdir(dirPath);
+    }
+    catch {
+        return await _ensureDir(dirPath);
+    }
+    await Promise.all(items.map(item => _removePath(path.join(dirPath, item))));
+}
+exports._emptyDir = _emptyDir;
+function _emptyDirSync(dirPath) {
+    let items;
+    try {
+        items = fs.readdirSync(dirPath);
+    }
+    catch {
+        return _ensureDirSync(dirPath);
+    }
+    items.forEach(item => _removePathSync(path.join(dirPath, item)));
+}
+exports._emptyDirSync = _emptyDirSync;
+// copyFile/moveFile - let's keep using fs-extra for now
+async function _copyPath(src, dest, opt) {
+    await fse.copy(src, dest, opt);
+}
+exports._copyPath = _copyPath;
+function _copyPathSync(src, dest, opt) {
+    fse.copySync(src, dest, opt);
+}
+exports._copyPathSync = _copyPathSync;
+async function _movePath(src, dest, opt) {
+    await fse.move(src, dest, opt);
+}
+exports._movePath = _movePath;
+function _movePathSync(src, dest, opt) {
+    fse.moveSync(src, dest, opt);
+}
+exports._movePathSync = _movePathSync;

package/dist/fs/kpy.js

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.kpySync = exports.kpy = void 0;
 const path = require("node:path");
 const js_lib_1 = require("@naturalcycles/js-lib");
-const cpFile = require("cp-file");
-const fs = require("fs-extra");
-const moveFile = require("move-file");
 const colors_1 = require("../colors");
 const index_1 = require("../index");
 async function kpy(opt) {
@@ -23,10 +20,10 @@ async function kpy(opt) {
         const destFilename = path.resolve(opt.outputDir, opt.flat ? basename : filename);
         if (!opt.dry) {
             if (opt.move) {
-                await moveFile(srcFilename, destFilename, { overwrite });
+                await (0, index_1._movePath)(srcFilename, destFilename, { overwrite });
             }
             else {
-                await cpFile(srcFilename, destFilename, { overwrite });
+                await (0, index_1._copyPath)(srcFilename, destFilename, { overwrite });
             }
         }
         if (opt.verbose) {
@@ -51,10 +48,10 @@ function kpySync(opt) {
         const destFilename = path.resolve(opt.outputDir, opt.flat ? basename : filename);
         if (!opt.dry) {
             if (opt.move) {
-                moveFile.sync(srcFilename, destFilename, { overwrite });
+                (0, index_1._movePathSync)(srcFilename, destFilename, { overwrite });
             }
             else {
-                cpFile.sync(srcFilename, destFilename, { overwrite });
+                (0, index_1._copyPathSync)(srcFilename, destFilename, { overwrite });
             }
         }
         if (opt.verbose) {
@@ -71,11 +68,11 @@ function kpyPrepare(opt) {
     // default to cwd
     opt.baseDir ||= '.';
     opt.outputDir ||= '.';
-    if (!fs.existsSync(opt.baseDir)) {
+    if (!(0, index_1._pathExistsSync)(opt.baseDir)) {
         console.log(`kpy: baseDir doesn't exist: ${(0, colors_1.boldWhite)(opt.baseDir)}`);
         return;
     }
-    fs.ensureDirSync(opt.outputDir);
+    (0, index_1._ensureDirSync)(opt.outputDir);
 }
 function kpyLogFilenames(opt, filenames) {
     if (opt.silent)

package/dist/index.d.ts

@@ -76,5 +76,6 @@ export * from './validation/joi/joi.validation.error';
 export * from './validation/joi/joi.validation.util';
 export * from './script';
 export * from './jwt/jwt.service';
+export * from './fs/fs.util';
 export type { GlobbyOptions, FastGlobOptions, ValidationErrorItem, AnySchema, Got, AfterResponseHook, BeforeErrorHook, BeforeRequestHook, };
 export { globby, fastGlob, RequestError, TimeoutError, Ajv };

package/dist/index.js

@@ -81,3 +81,4 @@ 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"), exports);
 tslib_1.__exportStar(require("./jwt/jwt.service"), exports);
+tslib_1.__exportStar(require("./fs/fs.util"), exports);

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readAjvSchemas = exports.readJsonSchemas = void 0;
-const fs = require("node:fs");
 const __1 = require("../..");
 const ajvSchema_1 = require("./ajvSchema");
 /**
@@ -13,7 +12,7 @@ const ajvSchema_1 = require("./ajvSchema");
  * @experimental
  */
 function readJsonSchemas(patterns, opt) {
-    return __1.fastGlob.sync(patterns, opt).map(fileName => JSON.parse(fs.readFileSync(fileName, 'utf8')));
+    return __1.fastGlob.sync(patterns, opt).map(fileName => (0, __1._readJsonFileSync)(fileName));
 }
 exports.readJsonSchemas = readJsonSchemas;
 /**

package/dist/validation/ajv/ajvSchema.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AjvSchema = void 0;
-const fs = require("node:fs");
 const js_lib_1 = require("@naturalcycles/js-lib");
 const index_1 = require("../../index");
 const ajvValidationError_1 = require("./ajvValidationError");
@@ -60,7 +59,7 @@ class AjvSchema {
      */
     static readJsonSync(filePath, cfg = {}) {
         (0, index_1.requireFileToExist)(filePath);
-        const schema = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        const schema = (0, index_1._readJsonFileSync)(filePath);
         return new AjvSchema(schema, cfg);
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/nodejs-lib",
-  "version": "12.90.4",
+  "version": "12.91.0",
   "scripts": {
     "prepare": "husky install",
     "docs-serve": "vuepress dev docs",
@@ -23,7 +23,6 @@
     "ajv-merge-patch": "^5.0.1",
     "binary-split": "^1.0.5",
     "chalk": "^4.0.0",
-    "cp-file": "^9.0.0",
     "debug": "^4.1.1",
     "dotenv": "^16.0.0",
     "execa": "^5.0.0",
@@ -34,18 +33,16 @@
     "joi": "17.4.2",
     "jsonwebtoken": "^9.0.0",
     "lru-cache": "^9.0.2",
-    "move-file": "^2.0.0",
     "through2-concurrent": "^2.0.0",
     "yargs": "^17.0.0"
   },
   "devDependencies": {
     "@naturalcycles/bench-lib": "^1.0.7",
     "@naturalcycles/dev-lib": "^13.0.0",
-    "@types/node": "^18.0.0",
+    "@types/node": "^20.1.0",
     "@types/yargs": "^16.0.0",
     "jest": "^29.0.0",
     "nock": "^13.0.2",
-    "patch-package": "^6.2.1",
     "prettier": "^2.0.0",
     "vue-class-component": "^7.2.6",
     "vuepress": "^1.7.1",

package/src/csv/csvReader.ts

@@ -65,7 +65,7 @@ export function csvStringToArray(str: string): string[][] {
       arr.push([])
     }
     arr[arr.length - 1]!.push(
-      matches[2] ? matches[2].replace(new RegExp('""', 'g'), '"') : matches[3],
+      matches[2] ? matches[2].replaceAll(new RegExp('""', 'g'), '"') : matches[3],
     )
   }
   return arr

package/src/csv/csvWriter.ts

@@ -59,7 +59,7 @@ export class CSVWriter {
   }
 
   private quote(s: string): string {
-    return `"${s.replace(/"/g, '""')}"`
+    return `"${s.replaceAll('"', '""')}"`
   }
 
   private shouldQuote(s: string): boolean {

package/src/fs/fs.util.ts

@@ -0,0 +1,204 @@
+/*
+
+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)
+
+ */
+
+import * as fs from 'node:fs'
+import * as fsp from 'node:fs/promises'
+import * as path from 'node:path'
+import { _jsonParse } from '@naturalcycles/js-lib'
+import type { CopyOptions, CopyOptionsSync, MoveOptions } from 'fs-extra'
+import * as fse from 'fs-extra'
+
+export interface JsonOptions {
+  spaces?: number
+}
+
+/**
+ * Convenience wrapper that defaults to utf-8 string output.
+ */
+export async function _readFile(filePath: string): Promise<string> {
+  return await fsp.readFile(filePath, 'utf8')
+}
+
+/**
+ * Convenience wrapper that defaults to utf-8 string output.
+ */
+export function _readFileSync(filePath: string): string {
+  return fs.readFileSync(filePath, 'utf8')
+}
+
+export async function _readJsonFile<T = unknown>(filePath: string): Promise<T> {
+  const str = await fsp.readFile(filePath, 'utf8')
+  return _jsonParse(str)
+}
+
+export function _readJsonFileSync<T = unknown>(filePath: string): T {
+  const str = fs.readFileSync(filePath, 'utf8')
+  return _jsonParse(str)
+}
+
+export async function _writeFile(filePath: string, data: string | Buffer): Promise<void> {
+  await fsp.writeFile(filePath, data)
+}
+
+export function _writeFileSync(filePath: string, data: string | Buffer): void {
+  fs.writeFileSync(filePath, data)
+}
+
+export async function _outputFile(filePath: string, data: string | Buffer): Promise<void> {
+  const dirPath = path.dirname(filePath)
+  if (!(await _pathExists(dirPath))) {
+    await _ensureDir(dirPath)
+  }
+
+  await fsp.writeFile(filePath, data)
+}
+
+export function _outputFileSync(filePath: string, data: string | Buffer): void {
+  const dirPath = path.dirname(filePath)
+  if (!fs.existsSync(dirPath)) {
+    _ensureDirSync(dirPath)
+  }
+
+  fs.writeFileSync(filePath, data)
+}
+
+export async function _writeJsonFile(
+  filePath: string,
+  data: any,
+  opt?: JsonOptions,
+): Promise<void> {
+  const str = JSON.stringify(data, null, opt?.spaces)
+  await fsp.writeFile(filePath, str)
+}
+
+export function _writeJsonFileSync(filePath: string, data: any, opt?: JsonOptions): void {
+  const str = JSON.stringify(data, null, opt?.spaces)
+  fs.writeFileSync(filePath, str)
+}
+
+export async function _outputJsonFile(
+  filePath: string,
+  data: any,
+  opt?: JsonOptions,
+): Promise<void> {
+  const str = JSON.stringify(data, null, opt?.spaces)
+  await _outputFile(filePath, str)
+}
+
+export function _outputJsonFileSync(filePath: string, data: any, opt?: JsonOptions): void {
+  const str = JSON.stringify(data, null, opt?.spaces)
+  _outputFileSync(filePath, str)
+}
+
+export async function _pathExists(filePath: string): Promise<boolean> {
+  try {
+    await fsp.access(filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function _pathExistsSync(filePath: string): boolean {
+  return fs.existsSync(filePath)
+}
+
+export async function _ensureDir(dirPath: string): Promise<void> {
+  await fsp.mkdir(dirPath, {
+    mode: 0o777,
+    recursive: true,
+  })
+}
+
+export function _ensureDirSync(dirPath: string): void {
+  fs.mkdirSync(dirPath, {
+    mode: 0o777,
+    recursive: true,
+  })
+}
+
+// Skipping `_ensureFile` (async), until it's needed
+
+export function _ensureFileSync(filePath: string): void {
+  let stats
+  try {
+    stats = fs.statSync(filePath)
+  } catch {}
+  if (stats?.isFile()) return
+
+  const dir = path.dirname(filePath)
+  try {
+    if (!fs.statSync(dir).isDirectory()) {
+      // parent is not a directory
+      // This is just to cause an internal ENOTDIR error to be thrown
+      fs.readdirSync(dir)
+    }
+  } catch (err) {
+    // If the stat call above failed because the directory doesn't exist, create it
+    if ((err as any)?.code === 'ENOENT') return _ensureDirSync(dir)
+    throw err
+  }
+
+  fs.writeFileSync(filePath, '')
+}
+
+export async function _removePath(fileOrDirPath: string): Promise<void> {
+  await fsp.rm(fileOrDirPath, { recursive: true, force: true })
+}
+
+export function _removePathSync(fileOrDirPath: string): void {
+  fs.rmSync(fileOrDirPath, { recursive: true, force: true })
+}
+
+export async function _emptyDir(dirPath: string): Promise<void> {
+  let items
+  try {
+    items = await fsp.readdir(dirPath)
+  } catch {
+    return await _ensureDir(dirPath)
+  }
+
+  await Promise.all(items.map(item => _removePath(path.join(dirPath, item))))
+}
+
+export function _emptyDirSync(dirPath: string): void {
+  let items
+  try {
+    items = fs.readdirSync(dirPath)
+  } catch {
+    return _ensureDirSync(dirPath)
+  }
+
+  items.forEach(item => _removePathSync(path.join(dirPath, item)))
+}
+
+// copyFile/moveFile - let's keep using fs-extra for now
+
+export async function _copyPath(src: string, dest: string, opt?: CopyOptions): Promise<void> {
+  await fse.copy(src, dest, opt)
+}
+
+export function _copyPathSync(src: string, dest: string, opt?: CopyOptionsSync): void {
+  fse.copySync(src, dest, opt)
+}
+
+export async function _movePath(src: string, dest: string, opt?: MoveOptions): Promise<void> {
+  await fse.move(src, dest, opt)
+}
+
+export function _movePathSync(src: string, dest: string, opt?: MoveOptions): void {
+  fse.moveSync(src, dest, opt)
+}

package/src/fs/kpy.ts

@@ -1,10 +1,15 @@
 import * as path from 'node:path'
 import { _since } from '@naturalcycles/js-lib'
-import * as cpFile from 'cp-file'
-import * as fs from 'fs-extra'
-import * as moveFile from 'move-file'
 import { boldWhite, dimGrey, grey, yellow } from '../colors'
-import { globby } from '../index'
+import {
+  _copyPath,
+  _copyPathSync,
+  _ensureDirSync,
+  _movePath,
+  _movePathSync,
+  _pathExistsSync,
+  globby,
+} from '../index'
 
 /**
  * Everything defaults to `undefined`.
@@ -67,9 +72,9 @@ export async function kpy(opt: KpyOptions): Promise<void> {
 
       if (!opt.dry) {
         if (opt.move) {
-          await moveFile(srcFilename, destFilename, { overwrite })
+          await _movePath(srcFilename, destFilename, { overwrite })
         } else {
-          await cpFile(srcFilename, destFilename, { overwrite })
+          await _copyPath(srcFilename, destFilename, { overwrite })
         }
       }
 
@@ -103,9 +108,9 @@ export function kpySync(opt: KpyOptions): void {
 
     if (!opt.dry) {
       if (opt.move) {
-        moveFile.sync(srcFilename, destFilename, { overwrite })
+        _movePathSync(srcFilename, destFilename, { overwrite })
       } else {
-        cpFile.sync(srcFilename, destFilename, { overwrite })
+        _copyPathSync(srcFilename, destFilename, { overwrite })
       }
     }
 
@@ -125,12 +130,12 @@ function kpyPrepare(opt: KpyOptions): void {
   opt.baseDir ||= '.'
   opt.outputDir ||= '.'
 
-  if (!fs.existsSync(opt.baseDir)) {
+  if (!_pathExistsSync(opt.baseDir)) {
     console.log(`kpy: baseDir doesn't exist: ${boldWhite(opt.baseDir)}`)
     return
   }
 
-  fs.ensureDirSync(opt.outputDir)
+  _ensureDirSync(opt.outputDir)
 }
 
 function kpyLogFilenames(opt: KpyOptions, filenames: string[]): void {

package/src/index.ts

@@ -76,6 +76,7 @@ export * from './validation/joi/joi.validation.error'
 export * from './validation/joi/joi.validation.util'
 export * from './script'
 export * from './jwt/jwt.service'
+export * from './fs/fs.util'
 
 export type {
   GlobbyOptions,

package/src/security/secret.util.ts

@@ -122,7 +122,7 @@ export function secretOptional<T = string>(k: string, parseJson = false): T | un
   if (!v) return
 
   if (parseJson) {
-    v = _jsonParseIfPossible(v)
+    v = _jsonParseIfPossible(v) as any
   }
 
   return v as T

package/src/validation/ajv/ajv.util.ts

@@ -1,6 +1,5 @@
-import * as fs from 'node:fs'
 import { JsonSchema } from '@naturalcycles/js-lib'
-import { fastGlob } from '../..'
+import { _readJsonFileSync, fastGlob } from '../..'
 import type { FastGlobOptions } from '../..'
 import { AjvSchema, AjvSchemaCfg } from './ajvSchema'
 
@@ -13,7 +12,7 @@ import { AjvSchema, AjvSchemaCfg } from './ajvSchema'
  * @experimental
  */
 export function readJsonSchemas(patterns: string | string[], opt?: FastGlobOptions): JsonSchema[] {
-  return fastGlob.sync(patterns, opt).map(fileName => JSON.parse(fs.readFileSync(fileName, 'utf8')))
+  return fastGlob.sync(patterns, opt).map(fileName => _readJsonFileSync(fileName))
 }
 
 /**

package/src/validation/ajv/ajvSchema.ts

@@ -1,4 +1,3 @@
-import * as fs from 'node:fs'
 import {
   JsonSchema,
   JsonSchemaAnyBuilder,
@@ -9,7 +8,7 @@ import {
   CommonLogger,
 } from '@naturalcycles/js-lib'
 import Ajv, { ValidateFunction } from 'ajv'
-import { inspectAny, requireFileToExist } from '../../index'
+import { _readJsonFileSync, inspectAny, requireFileToExist } from '../../index'
 import { AjvValidationError } from './ajvValidationError'
 import { getAjv } from './getAjv'
 
@@ -132,7 +131,7 @@ export class AjvSchema<T = unknown> {
     cfg: Partial<AjvSchemaCfg> = {},
   ): AjvSchema<T> {
     requireFileToExist(filePath)
-    const schema = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+    const schema = _readJsonFileSync<JsonSchema<T>>(filePath)
     return new AjvSchema<T>(schema, cfg)
   }