@nu-art/ts-common 0.400.6 → 0.400.8

package/package.json

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

package/utils/FileSystemUtils.d.ts

@@ -7,8 +7,12 @@ export declare const FileSystemUtils: {
         isFile: (pathToFile: string) => Promise<boolean>;
         exists: (pathToFile: string) => Promise<boolean>;
         delete: (pathToFile: string, mustExist?: boolean) => Promise<void>;
-        write: (pathToFile: string, content: string) => Promise<void>;
-        read: (pathToFile: string) => Promise<string>;
+        write: ((pathToFile: string, content: string) => Promise<void>) & {
+            json: <T>(pathToFile: string, value: T) => Promise<void>;
+        };
+        read: ((pathToFile: string) => Promise<string>) & {
+            json: <T>(pathToFile: string, defaultValue?: T) => Promise<T>;
+        };
         copy: (sourcePath: string, targetPath: string) => Promise<void>;
         template: {
             read: (pathToFile: string, params: StringMap, pattern?: RegExp) => Promise<string>;

package/utils/FileSystemUtils.js

@@ -54,14 +54,29 @@ export const FileSystemUtils = {
             await assertFile(pathToFile);
             return _fs.rm(pathToFile);
         },
-        write: async (pathToFile, content) => {
+        write: Object.assign(async (pathToFile, content) => {
             await FileSystemUtils.folder.create(resolve(pathToFile, '..'));
             return _fs.writeFile(pathToFile, content, 'utf-8');
-        },
-        read: async (pathToFile) => {
+        }, {
+            json: async (pathToFile, value) => {
+                return await FileSystemUtils.file.write(pathToFile, JSON.stringify(value, null, 2));
+            }
+        }),
+        read: Object.assign(async (pathToFile) => {
             await assertFile(pathToFile);
             return _fs.readFile(pathToFile, 'utf-8');
-        },
+        }, {
+            json: async (pathToFile, defaultValue) => {
+                try {
+                    return JSON.parse(await FileSystemUtils.file.read(pathToFile));
+                }
+                catch (e) {
+                    if (!exists(defaultValue))
+                        throw e;
+                    return defaultValue;
+                }
+            }
+        }),
         copy: async (sourcePath, targetPath) => {
             await assertExists(targetPath, false, 'File');
             await assertFile(sourcePath);

package/utils/array-tools.d.ts

@@ -49,13 +49,7 @@ export declare function filterFalsy<T>(array?: (T | undefined | null | void)[]):
 /**
  * receives array and builds hashmap whom keys are decided via function and values are from array
  * */
-export declare function arrayToMap<T>(array: T[] | Readonly<T[]>, getKey: (item: T, index: number, map: {
-    [k: string]: T;
-}) => string | number | (string | number)[], map?: {
-    [k: string]: T;
-}): {
-    [k: string]: T;
-};
+export declare function arrayToMap<T>(array: T[] | Readonly<T[]>, getKey: (item: T, index: number, map: TypedMap<T>) => string | number | (string | number)[], map?: TypedMap<T>): TypedMap<T>;
 type KeyResolver<Input, Output = Input> = (item: Input, index: number, map: {
     [k: string]: Output;
 }) => string | number | (string | number)[];