@nu-art/ts-common 0.400.3 → 0.400.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/ts-common",
-  "version": "0.400.3",
+  "version": "0.400.4",
   "description": "js and ts infra",
   "type": "module",
   "keywords": [

package/utils/FileSystemUtils.d.ts

@@ -2,7 +2,9 @@ import { StringMap } from './types.js';
 export declare const DEFAULT_TEMPLATE_PATTERN: RegExp;
 export declare const DEFAULT_OLD_TEMPLATE_PATTERN: RegExp;
 export declare const FileSystemUtils: {
+    exists: (pathToFile: string) => Promise<boolean>;
     file: {
+        isFile: (pathToFile: string) => Promise<boolean>;
         exists: (pathToFile: string) => Promise<boolean>;
         delete: (pathToFile: string, mustExist?: boolean) => Promise<void>;
         write: (pathToFile: string, content: string) => Promise<void>;
@@ -16,15 +18,17 @@ export declare const FileSystemUtils: {
         };
     };
     folder: {
+        isFolder: (pathToFile: string) => Promise<boolean>;
         delete: (pathToFolder: string, mustExist?: boolean) => Promise<void>;
         empty: (pathToFolder: string, mustExist?: boolean) => Promise<void>;
         create: (pathToFolder: string) => Promise<string | void>;
         list: ((pathToFolder: string) => Promise<string[]>) & {
-            forEach: ((pathToFolder: string, callback: (path: string) => Promise<any>) => Promise<void>) & {
+            forEach: ((pathToFolder: string, callback: (path: string) => Promise<any>) => Promise<any[]>) & {
                 file: (pathToFolder: string, callback: (path: string) => Promise<any>) => Promise<void>;
                 folder: (pathToFolder: string, callback: (path: string) => Promise<any>) => Promise<void>;
             };
         };
+        iterate: (pathToDir: string, options: FileIteratorOptions) => Promise<void>;
     };
     symlink: {
         create: (targetPath: string, linkPath: string) => Promise<void>;
@@ -32,3 +36,9 @@ export declare const FileSystemUtils: {
         read: (pathToLink: string) => Promise<string>;
     };
 };
+type FileIteratorOptions = {
+    filter: (path: string) => Promise<boolean>;
+    processor: (path: string) => Promise<any>;
+    followSymlinks?: boolean;
+};
+export {};

package/utils/FileSystemUtils.js

@@ -2,6 +2,7 @@ import { promises as _fs } from 'fs';
 import { resolve } from 'path';
 import { BadImplementationException } from '../core/exceptions/exceptions.js';
 import { exists } from './tools.js';
+import path from 'node:path';
 async function isFile(path) {
     return (await _fs.stat(path)).isFile();
 }
@@ -34,11 +35,16 @@ async function assertExists(path, mustExist, type) {
     }
     return true;
 }
-const escapeRegExp = (string) => string.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');
-export const DEFAULT_TEMPLATE_PATTERN = new RegExp(`\{\{([a-zA-Z]\\w{2,}?)\}\}`);
-export const DEFAULT_OLD_TEMPLATE_PATTERN = new RegExp(`(?<!\\\\)\\$([a-zA-Z]\\w{2,})`);
+export const DEFAULT_TEMPLATE_PATTERN = new RegExp(`\{\{(\\S*?)\}\}`);
+export const DEFAULT_OLD_TEMPLATE_PATTERN = new RegExp(`(?<!\\\\)\\$([a-zA-Z][\\w-_]{2,})`);
 export const FileSystemUtils = {
+    exists: async (pathToFile) => {
+        return await fileExists(pathToFile);
+    },
     file: {
+        isFile: async (pathToFile) => {
+            return isFile(pathToFile);
+        },
         exists: async (pathToFile) => {
             return await fileExists(pathToFile);
         },
@@ -73,8 +79,7 @@ export const FileSystemUtils = {
                     const value = params[match[1]];
                     if (!exists(value))
                         throw new BadImplementationException(`Missing template param: ${match[1]}`);
-                    const fullMatchRegex = new RegExp(escapeRegExp(match[0]), 'g');
-                    input = input.replace(fullMatchRegex, value);
+                    input = input.replace(match[0], value);
                 }
                 return input;
             },
@@ -90,6 +95,9 @@ export const FileSystemUtils = {
         },
     },
     folder: {
+        isFolder: async (pathToFile) => {
+            return isFolder(pathToFile);
+        },
         delete: async (pathToFolder, mustExist = false) => {
             if (!await assertExists(pathToFolder, mustExist, 'Folder'))
                 return;
@@ -113,8 +121,7 @@ export const FileSystemUtils = {
         }, {
             forEach: Object.assign(async (pathToFolder, callback) => {
                 const entries = await _fs.readdir(pathToFolder);
-                for (const entry of entries)
-                    await callback(resolve(pathToFolder, entry));
+                return Promise.all(entries.map(entry => callback(resolve(pathToFolder, entry))));
             }, {
                 file: async (pathToFolder, callback) => {
                     await FileSystemUtils.folder.list.forEach(pathToFolder, async (entry) => {
@@ -131,7 +138,21 @@ export const FileSystemUtils = {
                     });
                 }
             })
-        })
+        }),
+        iterate: async (pathToDir, options) => {
+            const pathToEntry = path.resolve(pathToDir);
+            if (await FileSystemUtils.file.isFile(pathToEntry)) {
+                (await options.filter(pathToEntry)) && (await options.processor(pathToEntry));
+                return;
+            }
+            if (await FileSystemUtils.folder.isFolder(pathToEntry)) {
+                await FileSystemUtils.folder.list.forEach(pathToEntry, async (entry) => {
+                    return (await options.filter(entry)) && (await FileSystemUtils.folder.iterate(entry, options));
+                });
+                return;
+            }
+            throw new BadImplementationException(`Expected file or folder but found something else: ${pathToEntry}`);
+        }
     },
     symlink: {
         create: async (targetPath, linkPath) => {