Linting

aneldev · Mar 8, 2022 · 1fe4727 · 1fe4727
1 parent 3b6b783
commit 1fe4727
Show file tree

Hide file tree

Showing 9 changed files with 186 additions and 106 deletions.
diff --git a/src/DynaDiskMemoryForBrowser.ts b/src/DynaDiskMemoryForBrowser.ts
@@ -1,6 +1,9 @@
 import * as md5 from 'md5';
 import {DynaJobQueue} from "dyna-job-queue";
-import {IDynaDiskMemory, IDynaDiskMemoryConfig} from './interfaces';
+import {
+  IDynaDiskMemory,
+  IDynaDiskMemoryConfig,
+} from './interfaces';
 
 interface IFolderFile {
   full: string;
@@ -13,7 +16,7 @@ export class DynaDiskMemory implements IDynaDiskMemory {
   constructor(settings: IDynaDiskMemoryConfig) {
     this._settings = {
       fragmentSize: 13,
-      ...settings
+      ...settings,
     };
 
     if (settings.diskPath[settings.diskPath.length - 1] !== '/') this._settings.diskPath += '/';
@@ -30,41 +33,43 @@ export class DynaDiskMemory implements IDynaDiskMemory {
   public _test_performDiskDelay: number = 0;
 
   public set<TData>(container: string, key: string, data: TData): Promise<void> {
-    return new Promise((resolve: Function, reject: (error: any) => void) => {
+    return new Promise<void>((resolve: () => void, reject: (error: any) => void) => {
       try {
         const names: IFolderFile = this._generateFilename(container, key);
         localStorage.setItem(names.full, JSON.stringify(data));
         setTimeout(resolve, this._test_performDiskDelay);
-      } catch (err) {
+      }
+      catch (err) {
         setTimeout(reject, this._test_performDiskDelay, err);
       }
     });
   }
 
-  public get<TData>(container: string, key: string): Promise<TData> {
-    return new Promise((resolve: Function, reject: (error: any) => void) => {
+  public get<TData>(container: string, key: string) {
+    return new Promise<TData>((resolve: (data: TData) => void, reject: (error: any) => void) => {
       try {
         const names: IFolderFile = this._generateFilename(container, key);
         const rawData: any = localStorage.getItem(names.full);
         let data: any = undefined;
         if (typeof rawData == 'string') data = JSON.parse(rawData);
         setTimeout(resolve, this._test_performDiskDelay, data);
-      } catch (err) {
+      }
+      catch (err) {
         setTimeout(reject, this._test_performDiskDelay, err);
       }
     });
   }
 
   public del(container: string, key: string): Promise<void> {
-    return new Promise((resolve: Function) => {
+    return new Promise((resolve: () => void) => {
       const names: IFolderFile = this._generateFilename(container, key);
       localStorage.removeItem(names.full);
       setTimeout(resolve, this._test_performDiskDelay);
     });
   }
 
   public delContainer(container: string): Promise<void> {
-    return new Promise((resolve: Function) => {
+    return new Promise((resolve: () => void) => {
       const names: IFolderFile = this._generateFilename(container);
       Object.keys(localStorage)
         .filter((key: string) => key.startsWith(names.folder + '/'))
@@ -74,7 +79,7 @@ export class DynaDiskMemory implements IDynaDiskMemory {
   }
 
   public delAll(): Promise<void> {
-    return new Promise((resolve: Function) => {
+    return new Promise((resolve: () => void) => {
       const names: IFolderFile = this._generateFilename();
       Object.keys(localStorage)
         .filter((key: string) => key.startsWith(names.base + '/'))
@@ -89,7 +94,12 @@ export class DynaDiskMemory implements IDynaDiskMemory {
     const folder: string = full.substr(0, full.lastIndexOf('/'));
     const file: string = full.substr(full.lastIndexOf('/') + 1);
 
-    return {full, base, folder, file};
+    return {
+      full,
+      base,
+      folder,
+      file,
+    };
   }
 }
 
diff --git a/src/DynaDiskMemoryForNode.ts b/src/DynaDiskMemoryForNode.ts
@@ -1,11 +1,17 @@
-const fs = require('fs');
-const path = require('path');
+import * as fs from "fs";
+import * as path from "path";
 import * as md5 from 'md5';
 
 import {DynaJobQueue} from "dyna-job-queue";
-import {deleteFile, isFolderEmpty, rmdir} from "dyna-node-fs";
+import {
+  deleteFile,
+  isFolderEmpty,
+  rmdir,
+} from "dyna-node-fs";
 
-import {IDynaDiskMemoryConfig, IDynaDiskMemory} from './interfaces';
+import {
+  IDynaDiskMemoryConfig, IDynaDiskMemory,
+} from './interfaces';
 
 interface IFolderFile {
   full: string;
@@ -24,7 +30,7 @@ export class DynaDiskMemory implements IDynaDiskMemory {
   public _test_performDiskDelay: number = 0;
 
   public set<TData>(container: string, key: string, data: TData): Promise<void> {
-    return this._jogQueue.addJobPromise((resolve: Function, reject: (error: any) => void) => {
+    return this._jogQueue.addJobPromise((resolve: () => void, reject: (error: any) => void) => {
       this._saveFile(container, key, data)
         .then(() => resolve())
         .catch(reject);
@@ -40,7 +46,7 @@ export class DynaDiskMemory implements IDynaDiskMemory {
   }
 
   public del(container: string, key: string): Promise<void> {
-    return this._jogQueue.addJobPromise((resolve: Function, reject: (error: any) => void) => {
+    return this._jogQueue.addJobPromise((resolve: () => void, reject: (error: any) => void) => {
       const fileInfo: IFolderFile = this._generateFilename(container, key);
 
       deleteFile(fileInfo.full)
@@ -51,16 +57,16 @@ export class DynaDiskMemory implements IDynaDiskMemory {
   }
 
   private _deleteEmptyFolderPath(fileInfo: IFolderFile): Promise<void> {
-    return new Promise<void>((resolve: Function, reject: (error: any) => void) => {
-      let foldersToDel: string[] = [];
+    return new Promise<void>((resolve: () => void, reject: (error: any) => void) => {
+      const foldersToDel: string[] = [];
       let folder: string = fileInfo.folder;
 
       while (folder.length && folder !== this._settings.diskPath.slice(0, -1)) {
         foldersToDel.push(folder);
         folder = folder.substr(0, folder.lastIndexOf('/'));
       }
 
-      let folderToDel: string | undefined= foldersToDel.shift();
+      let folderToDel: string | undefined = foldersToDel.shift();
       const run = () => {
         if (folderToDel) {
           this._deleteEmptyFolder(folderToDel)
@@ -69,12 +75,13 @@ export class DynaDiskMemory implements IDynaDiskMemory {
               if (folderToDel) run(); else resolve();
             })
             .catch(reject);
-        } else {
-          resolve(); // no folder
+        }
+        else {
+          resolve(); // No folder
         }
       };
 
-      run(); // start
+      run(); // Start
     });
   }
 
@@ -87,21 +94,23 @@ export class DynaDiskMemory implements IDynaDiskMemory {
   }
 
   public delContainer(container: string): Promise<void> {
-    return this._jogQueue.addJobPromise((resolve: Function, reject: (error: any) => void) => {
+    return this._jogQueue.addJobPromise((resolve: () => void, reject: (error: any) => void) => {
       const folder = this._generateFilename(container).folder;
-      rmdir(folder).then(() => resolve()).catch(reject);
+      rmdir(folder).then(() => resolve())
+        .catch(reject);
     });
   }
 
   public delAll(): Promise<void> {
-    return this._jogQueue.addJobPromise((resolve: Function, reject: (error: any) => void) => {
-      rmdir(this._settings.diskPath).then(() => resolve()).catch(reject);
+    return this._jogQueue.addJobPromise((resolve: () => void, reject: (error: any) => void) => {
+      rmdir(this._settings.diskPath).then(() => resolve())
+        .catch(reject);
     });
   }
 
   private _saveFile(container: string, key: string, data: any): Promise<void> {
-    return new Promise((resolve: Function, reject: (error: any) => void) => {
-      let fileNames: IFolderFile = this._generateFilename(container, key);
+    return new Promise((resolve: () => void, reject: (error: any) => void) => {
+      const fileNames: IFolderFile = this._generateFilename(container, key);
 
       this._createDirectory(fileNames.folder)
         .then(() => {
@@ -114,8 +123,8 @@ export class DynaDiskMemory implements IDynaDiskMemory {
   }
 
   private _loadFile(container: string, key: string): Promise<any> {
-    return new Promise((resolve: Function) => {
-      let fileNames: IFolderFile = this._generateFilename(container, key);
+    return new Promise<void>((resolve: (data: any) => void) => {
+      const fileNames: IFolderFile = this._generateFilename(container, key);
 
       this._readFileFromDisk(fileNames.folder, fileNames.file)
         .then((data: any) => resolve(data))
@@ -124,61 +133,79 @@ export class DynaDiskMemory implements IDynaDiskMemory {
   }
 
   private _createDirectory(directory: string): Promise<void> {
-    // todo: make this async
-    return new Promise((resolve: Function, reject: Function) => {
+    // Todo: make this async
+    return new Promise((resolve: () => void, reject: (err: any) => void) => {
       try {
-        const sep = '/'; //path.sep;
+        const sep = path.sep;
         const initDir = path.isAbsolute(directory) ? sep : '';
         directory.split(sep).reduce((parentDir, childDir) => {
           const curDir = path.resolve(parentDir, childDir);
           if (!fs.existsSync(curDir)) fs.mkdirSync(curDir);
           return curDir;
         }, initDir);
         resolve();
-      } catch (err) {
+      }
+      catch (err) {
         reject(err);
       }
     });
   }
 
   private _writeFileOnDisk(folder: string, fileName: string, data: any): Promise<void> {
-    return new Promise((resolve: Function, reject: (error: any) => void) => {
+    return new Promise((resolve: () => void, reject: (error: any) => void) => {
       const fullPath: string = `${folder}/${fileName}`;
       setTimeout(() => {
         fs.exists(fullPath, (exists: boolean) => {
           if (exists) fs.unlinkSync(fullPath);
           fs.writeFile(`${fullPath}`, JSON.stringify(data), (err: any) => {
-            if (err)
-              reject({errorMessage: `Cannot write file [${fullPath}]`, error: err});
-            else
+            if (err) {
+              reject({
+                errorMessage: `Cannot write file [${fullPath}]`,
+                error: err,
+              });
+            }
+            else {
               resolve();
+            }
           });
         });
       }, this._test_performDiskDelay);
     });
   }
 
   private _readFileFromDisk(folder: string, fileName: string): Promise<any> {
-    return new Promise((resolve: Function, reject: (error: any) => void) => {
+    return new Promise((resolve: (data: any) => void, reject: (error: any) => void) => {
       setTimeout(() => {
         const fullFileName: string = `${folder}/${fileName}`;
         fs.exists(fullFileName, function (exists: boolean) {
           if (exists) {
             fs.readFile(fullFileName, 'utf8', (err: any, data: any) => {
-              if (err)
-                reject({code: 1802241812, errorMessage: `Cannot read file [${fullFileName}]`, error: err});
-              else
+              if (err) {
+                reject({
+                  code: 1802241812,
+                  errorMessage: `Cannot read file [${fullFileName}]`,
+                  error: err,
+                });
+              }
+              else {
                 try {
                   resolve(JSON.parse(data));
-                } catch (error) {
-                  reject({code: 1802241811, errorMessage: `Cannot parse file [${fullFileName}]`, error: err});
                 }
+                catch (error) {
+                  reject({
+                    code: 1802241811,
+                    errorMessage: `Cannot parse file [${fullFileName}]`,
+                    error: err,
+                  });
+                }
+              }
             });
-          } else {
+          }
+          else {
             reject({
               code: 1802241813,
               errorMessage: `DynaDiskMemory: _readFileFromDisk: cannot find to read file for folder [${folder}] and fileName [${fileName}]`,
-              fullFileName
+              fullFileName,
             });
           }
         });
@@ -196,7 +223,12 @@ export class DynaDiskMemory implements IDynaDiskMemory {
     let containerBase: string = `${generatedContainer}/${generatedKey}`;
     containerBase = containerBase.substr(0, containerBase.lastIndexOf('/'));
 
-    return {full, folder, file, containerBase};
+    return {
+      full,
+      folder,
+      file,
+      containerBase,
+    };
   }
 
   private _getAsciiCodeHash(key: string): string {
@@ -205,9 +237,9 @@ export class DynaDiskMemory implements IDynaDiskMemory {
 
   private _splitText(text: string, step: number, separetor: string): string {
     let output: string = "";
-    let se: string[] = text.split('').reverse();
+    const se: string[] = text.split('').reverse();
     while (se.length) output += se.splice(0, step).join('') + separetor;
-    if (output[output.length - 1] == separetor) output += '_fc';
+    if (output[output.length - 1] === separetor) output += '_fc';
     return output;
   }
 }

diff --git a/src/DynaDiskMemoryUniversal.ts b/src/DynaDiskMemoryUniversal.ts
@@ -1,7 +1,9 @@
-// dev node: This is not used at the moment, will be used once the Webpack supports target: "universal"
+// Dev node: This is not used at the moment, will be used once the Webpack supports target: "universal"
 
 import {isNode}                                 from 'dyna-universal';
-import {IDynaDiskMemory, IDynaDiskMemoryConfig} from './interfaces';
+import {
+  IDynaDiskMemory, IDynaDiskMemoryConfig,
+} from './interfaces';
 
 import {DynaDiskMemory as DynaDiskMemoryForBrowser} from './DynaDiskMemoryForBrowser';
 import {DynaDiskMemory as DynaDiskMemoryForNode} from './DynaDiskMemoryForNode';
@@ -12,16 +14,19 @@ export class DynaDiskMemoryUniversal {
       fragmentSize: 13,
       _test_workForBrowser: false,
       _test_performDiskDelay: 0,
-      ...settings
+      ...settings,
     };
     if (settings.diskPath[settings.diskPath.length - 1] !== '/') this._settings.diskPath += '/';
 
-    if (this._settings._test_workForBrowser)
+    if (this._settings._test_workForBrowser) {
       this._memory = new DynaDiskMemoryForBrowser(this._settings);
-    else if (isNode)
+    }
+    else if (isNode) {
       this._memory = new DynaDiskMemoryForNode(this._settings);
-    else
+    }
+    else {
       this._memory = new DynaDiskMemoryForBrowser(this._settings);
+    }
 
     this._memory._test_performDiskDelay = this._test_performDiskDelay;
   }

diff --git a/src/index.ts b/src/index.ts
@@ -1,11 +1,14 @@
 // Export for the types
-export {IDynaDiskMemory, IDynaDiskMemoryConfig} from './interfaces';
+export {
+  IDynaDiskMemory,
+  IDynaDiskMemoryConfig,
+} from './interfaces';
 export * from "./DynaDiskMemoryForNode";
 
 console.error(`
 dyna-disk-memory: Import error
     You should import "dyna-disk-memory/dist/commonJs/web" or "dyna-disk-memory/dist/commonJs/node" (with lazy load or not) according the runtime environment.
-    There is also am es version instead of commonJs, there imports are "dyna-disk-memory/dist/esNext/web" and "dyna-disk-memory/dist/esNext/node". 
+    There is also am es version instead of commonJs, there imports are "dyna-disk-memory/dist/esNext/web" and "dyna-disk-memory/dist/esNext/node".
     For typescript, you should import the types from "dyna-disk-memory" but functional code from "web" or "node" versions.
     More for how to import with conditional lazy load: https://github.com/aneldev/dyna-ts-module-boilerplate#how-to-import
 `);
diff --git a/src/interfaces.ts b/src/interfaces.ts
@@ -1,7 +1,7 @@
 export interface IDynaDiskMemoryConfig {
   fragmentSize?: number;
   diskPath: string;
-  _test_workForBrowser?: boolean;   // force it to work as in browser (for tests under nodejs)
+  _test_workForBrowser?: boolean;   // Force it to work as in browser (for tests under nodejs)
   _test_performDiskDelay?: number;
 }