style: formatting

Author: zardoy

src/index.ts

@@ -1,52 +1,52 @@
 import { PackageJson, TsConfigJson } from "type-fest";
-import detectIndent from "detect-indent"
-import stripBom from "strip-bom"
-import parseJson from "parse-json"
-import fs from "graceful-fs"
+import detectIndent from "detect-indent";
+import stripBom from "strip-bom";
+import parseJson from "parse-json";
+import fs from "graceful-fs";
 
 type MaybePromise<T> = T | Promise<T>;
 
 interface Options {
     /** @default utf-8 */
-    encoding: BufferEncoding
+    encoding: BufferEncoding;
     /** 
      * If `false`, FS or JSON errors will be ignored
      * @default true
      *  */
-    throws: boolean
+    throws: boolean;
     // ideally this lib should integrate with json validator
     /** @default "throw" (silent if throws: false) */
-    ifFieldIsMissing: "throw" | "skip" | "add"
+    ifFieldIsMissing: "throw" | "skip" | "add";
     /** 
      * - throw - throws (silent if throws: false) 
      *-  skip - won't call the function
      * - pass - pass the `undefined` value
      * @default "throw" 
      * */
-    ifFieldIsMissingForSetter: "throw" | "skip" | "pass"
+    ifFieldIsMissingForSetter: "throw" | "skip" | "pass";
     /** 
      * - null - disable formatting
      * - hard - one hard tab \t
      * - number - number of spaces
      * @default "preserve"
      *  */
-    tabSize: null | number | "preserve" | "hard"
+    tabSize: null | number | "preserve" | "hard";
 }
 
 type GettersDeep<T extends object> = {
     [K in keyof T]: (oldValue: T[K], json: T) => T[K]
     //T[K] extends object ? ((oldValue: T[K]) => unknown)/*  | GettersDeep<T[K]> */ : (oldValue: T[K]) => unknown
-}
+};
 
 export type ModifyJsonFileFunction<T extends object> = (
     path: string,
-    modifyFields: Partial<T | GettersDeep<T>> | ((oldJson: T) => MaybePromise<T>), 
+    modifyFields: Partial<T | GettersDeep<T>> | ((oldJson: T) => MaybePromise<T>),
     options?: Options
 ) => Promise<void>;
 
 type ModifyJsonFileGenericFunction = <T extends object>(
     path: string,
-    modifyFields: Partial<T | GettersDeep<T>> | ((oldJson: T) => MaybePromise<T>), 
+    modifyFields: Partial<T | GettersDeep<T>> | ((oldJson: T) => MaybePromise<T>),
     options?: Partial<Options>
 ) => Promise<void>;
 
@@ -57,11 +57,11 @@ const loadJsonFile = async (filePath: string, { encoding, tabSize }: Pick<Option
     );
     return {
         json: parseJson(contents, filePath),
-        indent: tabSize === "preserve" ? 
-            detectIndent(contents).indent : 
-                tabSize === "hard" ? "\t" : tabSize === null ? 
-                    undefined : " ".repeat(tabSize)
-    }
+        indent: tabSize === "preserve" ?
+            detectIndent(contents).indent :
+            tabSize === "hard" ? "\t" : tabSize === null ?
+                undefined : " ".repeat(tabSize)
+    };
 };
 
 /** It's just Error */
@@ -77,22 +77,22 @@ const loadJsonFile = async (filePath: string, { encoding, tabSize }: Pick<Option
  */
 export const modifyJsonFile: ModifyJsonFileGenericFunction = async (
     path,
-    modifyFields, 
+    modifyFields,
     options
 ) => {
-    const { 
+    const {
         encoding = "utf-8",
-        throws = true ,
+        throws = true,
         ifFieldIsMissing = "throw",
         ifFieldIsMissingForSetter = "throw",
         tabSize = "preserve"
     } = options || {};
     try {
-        let {json, indent} = await loadJsonFile(path, { encoding, tabSize });
+        let { json, indent } = await loadJsonFile(path, { encoding, tabSize });
         // todo remove restriction or not?
         if (!json || typeof json !== "object" || Array.isArray(json)) throw new TypeError(`${path}: JSON root type must be object`);
         if (typeof modifyFields === "function") {
-            json = await modifyFields(json)
+            json = await modifyFields(json);
         } else {
             for (const [name, value] of Object.entries(modifyFields)) {
                 if (!(name in json)) {
@@ -109,11 +109,11 @@ export const modifyJsonFile: ModifyJsonFileGenericFunction = async (
             path,
             JSON.stringify(json, undefined, indent)
         );
-    } catch(err) {
+    } catch (err) {
         // if (err.innerError) throw new Error(err.message);
         if (throws) throw err;
     }
-}
+};
 
 // todo: use read-pkg / write-pkg for normalization
 

tests/index.test.ts

@@ -1,16 +1,18 @@
 import test from "ava";
-
-import jsonfile from "jsonfile";
-import path from "path";
 import del from "del";
-import nanoid from "nanoid";
-import { modifyJsonFile, modifyPackageJsonFile } from "../build/"
 import fs from "fs/promises";
+import jsonfile from "jsonfile";
+import path from "path";
+
+import { modifyJsonFile, modifyPackageJsonFile } from "../build/";
 
 const jsonFilePath = path.join(__dirname, "testing-file.json");
 
+// that's fine until tests are running with --serial flag
+let dataToWrite;
+
 test.beforeEach(async () => {
-    await jsonfile.writeFile(jsonFilePath, {
+    await jsonfile.writeFile(jsonFilePath, dataToWrite ?? {
         "name": "package",
         "main": "index.js",
         "author": "eldar",
@@ -19,11 +21,11 @@ test.beforeEach(async () => {
             "fdir": ">=2"
         }
     }, { spaces: 4 });
-})
+});
 
 test.afterEach.always(async () => {
     await del(jsonFilePath);
-})
+});
 
 test("modifies JSON file", async t => {
     await modifyJsonFile(jsonFilePath, {
@@ -32,15 +34,16 @@ test("modifies JSON file", async t => {
         dependencies: {
             "type-fest": "^1.0.0"
         }
-    })
+    });
     const modifiedJsonFle = await fs.readFile(jsonFilePath, "utf8");
     t.snapshot(modifiedJsonFle);
-})
+});
 
 test("modifies package.json file with async function", async t => {
     await modifyPackageJsonFile(jsonFilePath, async ({ main }) => {
         return { types: main, name: "ahaha" };
-    })
+    });
     const modifiedJsonFle = await fs.readFile(jsonFilePath, "utf8");
     t.snapshot(modifiedJsonFle);
-})
+});
+