@naturalcycles/nodejs-lib 15.135.0 → 15.136.0

package/dist/fs/fs2.d.ts

@@ -45,8 +45,18 @@ declare class FS2 {
     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>;
+    /**
+     * Ensures that the directory exists and is empty.
+     * Creates it (recursively) if it doesn't exist, otherwise deletes all its contents.
+     * The directory itself is not deleted.
+     */
+    ensureEmptyDir(dirPath: string): void;
+    /**
+     * Ensures that the directory exists and is empty.
+     * Creates it (recursively) if it doesn't exist, otherwise deletes all its contents.
+     * The directory itself is not deleted.
+     */
+    ensureEmptyDirAsync(dirPath: string): Promise<void>;
     /**
      * Cautious, underlying Node function is currently Experimental.
      */

package/dist/fs/fs2.js

@@ -196,12 +196,19 @@ class FS2 {
     async removePathAsync(fileOrDirPath, opt) {
         await fsp.rm(fileOrDirPath, { recursive: true, force: true, ...opt });
     }
-    emptyDir(dirPath) {
+    /**
+     * Ensures that the directory exists and is empty.
+     * Creates it (recursively) if it doesn't exist, otherwise deletes all its contents.
+     * The directory itself is not deleted.
+     */
+    ensureEmptyDir(dirPath) {
         let items;
         try {
             items = fs.readdirSync(dirPath);
         }
-        catch {
+        catch (err) {
+            if (err?.code !== 'ENOENT')
+                throw err;
             this.ensureDir(dirPath);
             return;
         }
@@ -209,12 +216,19 @@ class FS2 {
             this.removePath(path.join(dirPath, item));
         }
     }
-    async emptyDirAsync(dirPath) {
+    /**
+     * Ensures that the directory exists and is empty.
+     * Creates it (recursively) if it doesn't exist, otherwise deletes all its contents.
+     * The directory itself is not deleted.
+     */
+    async ensureEmptyDirAsync(dirPath) {
         let items;
         try {
             items = await fsp.readdir(dirPath);
         }
-        catch {
+        catch (err) {
+            if (err?.code !== 'ENOENT')
+                throw err;
             return await this.ensureDirAsync(dirPath);
         }
         await Promise.all(items.map(item => this.removePathAsync(path.join(dirPath, item))));

package/dist/stream/writable/writableChunk.js

@@ -36,7 +36,7 @@ export function writableChunk(splitPredicate, fn, opt = {}) {
                 logger.debug(`WritableChunk(${splitIndex}): pause`);
             }
             if (splitPredicate(chunk, ++indexWritten)) {
-                logger.log(`WritableChunk(${splitIndex}): splitting to ${splitIndex + 1}`);
+                logger.debug(`WritableChunk(${splitIndex}): splitting to ${splitIndex + 1}`);
                 splitIndex++;
                 fork.push(null);
                 lock?.resolve();
@@ -47,7 +47,7 @@ export function writableChunk(splitPredicate, fn, opt = {}) {
             cb();
         },
         async final(cb) {
-            logger.log(`WritableChunk: final`);
+            logger.debug(`WritableChunk: final`);
             // Pushing null "closes"/ends the secondary pipeline correctly
             fork.push(null);
             // Acknowledge that we've received `null` and passed it through to the fork
@@ -67,7 +67,7 @@ export function writableChunk(splitPredicate, fn, opt = {}) {
             lockCopy.resolve();
         });
         void fn(Pipeline.from(readable), currentSplitIndex).then(() => {
-            logger.log(`WritableChunk(${currentSplitIndex}): done`);
+            logger.debug(`WritableChunk(${currentSplitIndex}): done`);
         });
         return readable;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/nodejs-lib",
   "type": "module",
-  "version": "15.135.0",
+  "version": "15.136.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@standard-schema/spec": "^1",
@@ -14,7 +14,7 @@
     "yaml": "^2"
   },
   "devDependencies": {
-    "@naturalcycles/dev-lib": "0.0.0",
+    "@naturalcycles/dev-lib": "20.69.0",
     "typescript": "^7"
   },
   "exports": {

package/src/fs/fs2.ts

@@ -230,11 +230,17 @@ class FS2 {
     await fsp.rm(fileOrDirPath, { recursive: true, force: true, ...opt })
   }
 
-  emptyDir(dirPath: string): void {
+  /**
+   * Ensures that the directory exists and is empty.
+   * Creates it (recursively) if it doesn't exist, otherwise deletes all its contents.
+   * The directory itself is not deleted.
+   */
+  ensureEmptyDir(dirPath: string): void {
     let items: string[]
     try {
       items = fs.readdirSync(dirPath)
-    } catch {
+    } catch (err) {
+      if ((err as any)?.code !== 'ENOENT') throw err
       this.ensureDir(dirPath)
       return
     }
@@ -244,11 +250,17 @@ class FS2 {
     }
   }
 
-  async emptyDirAsync(dirPath: string): Promise<void> {
+  /**
+   * Ensures that the directory exists and is empty.
+   * Creates it (recursively) if it doesn't exist, otherwise deletes all its contents.
+   * The directory itself is not deleted.
+   */
+  async ensureEmptyDirAsync(dirPath: string): Promise<void> {
     let items: string[]
     try {
       items = await fsp.readdir(dirPath)
-    } catch {
+    } catch (err) {
+      if ((err as any)?.code !== 'ENOENT') throw err
       return await this.ensureDirAsync(dirPath)
     }
 

package/src/stream/writable/writableChunk.ts

@@ -48,7 +48,7 @@ export function writableChunk<T>(
       }
 
       if (splitPredicate(chunk, ++indexWritten)) {
-        logger.log(`WritableChunk(${splitIndex}): splitting to ${splitIndex + 1}`)
+        logger.debug(`WritableChunk(${splitIndex}): splitting to ${splitIndex + 1}`)
         splitIndex++
         fork.push(null)
         lock?.resolve()
@@ -60,7 +60,7 @@ export function writableChunk<T>(
       cb()
     },
     async final(cb) {
-      logger.log(`WritableChunk: final`)
+      logger.debug(`WritableChunk: final`)
 
       // Pushing null "closes"/ends the secondary pipeline correctly
       fork.push(null)
@@ -84,7 +84,7 @@ export function writableChunk<T>(
     })
 
     void fn(Pipeline.from<T>(readable), currentSplitIndex).then(() => {
-      logger.log(`WritableChunk(${currentSplitIndex}): done`)
+      logger.debug(`WritableChunk(${currentSplitIndex}): done`)
     })
 
     return readable