@maxzima/wa-communicator 0.0.13 → 0.0.14

package/.editorconfig

@@ -0,0 +1,16 @@
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{diff,md,sh}]
+trim_trailing_whitespace = false
+insert_final_newline = false
+
+[*.json]
+insert_final_newline = false

package/.eslintrc.js

@@ -0,0 +1,58 @@
+'use strict';
+
+module.exports = {
+  root: true,
+  parser: '@typescript-eslint/parser',
+  extends: [
+    'eslint:recommended',
+    'plugin:eslint-comments/recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:import/typescript',
+    'prettier',
+  ],
+  plugins: [
+    '@typescript-eslint',
+    'prettier',
+    'import',
+    'eslint-comments',
+    'editorconfig',
+  ],
+  parserOptions: {
+    ecmaVersion: 6,
+    sourceType: 'module',
+  },
+  env: {
+    es6: true,
+    node: true,
+    browser: true,
+  },
+  ignorePatterns: [
+    'node_modules',
+    'dist'
+  ],
+  globals: {
+    BigInt: true,
+    console: true,
+    document: true,
+    navigator: true,
+    window: true,
+    Math: true,
+    module: true,
+    require: true,
+    global: true,
+  },
+  rules: {
+    'no-empty': 'off',
+    'no-async-promise-executor': 'off',
+    "no-extra-boolean-cast": 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    'eslint-comments/disable-enable-pair': ['error', {allowWholeFile: true}],
+    'eslint-comments/no-unused-disable': 'error',
+    // 'eslint-comments/no-unlimited-disable': 'off',
+    '@typescript-eslint/ban-ts-ignore': 'off',
+    '@typescript-eslint/ban-ts-comment': 'off',
+    '@typescript-eslint/no-empty-function': 'off',
+    'semi': ['error', 'always'],
+    'no-prototype-builtins': 'off',
+  },
+};

package/.gitattributes

@@ -0,0 +1,29 @@
+#*.php text eol=lf
+*.sh text eol=lf
+*.js text eol=lf
+*.ts text eol=lf
+*.json text eol=lf
+*.css text eol=lf
+*.scss text eol=lf
+*.sql text eol=lf
+
+*.jpg binary
+*.jpeg binary
+*.apng binary
+*.png binary
+*.gif binary
+*.swf binary
+*.ico binary
+
+*.ttf binary
+*.woff binary
+*.woff2 binary
+
+*.exe binary
+
+*.mp3 binary
+*.ogg binary
+*.mov binary
+*.mp4 binary
+
+*.zip binary

package/.prettierignore

@@ -0,0 +1,9 @@
+# Dependencies
+node_modules
+
+# Production
+dist/
+
+# package.json is formatted by package managers, so we ignore it here
+package-lock.json
+package.json

package/.prettierrc.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports = {
+  'semi': true,
+  'singleQuote': true,
+  'arrowParens': 'always',
+  'printWidth': 180,
+  'bracketSpacing': false,
+  'endOfLine': 'lf',
+  'bracketSameLine': false,
+  'proseWrap': 'preserve',
+  'requirePragma': false,
+  'tabWidth': 2,
+  'trailingComma': 'es5',
+  'useTabs': false
+}

package/config/tsconfig.esm.json

@@ -6,5 +6,5 @@
   },
   "exclude": [
     "../src/types/index.ts",
-  ]
+  ],
 }

package/config/tsconfig.types.json

@@ -3,6 +3,6 @@
   "compilerOptions": {
     "declaration": true,
     "emitDeclarationOnly": true,
-    "outDir": "../dist"
-  }
+    "outDir": "../dist",
+  },
 }

package/dist/engine/CommunicatorReceiver.js

@@ -1,4 +1,4 @@
-import { isValidMessage, modifyOrigin } from "./utils";
+import { isValidMessage, modifyOrigin, sortMessageQueue } from "./utils";
 import { CommunicatorTargetEnum_isCorrect } from '../enums/CommunicatorTargetEnum';
 import { CommunicatorActionEnum_isCorrect, CommunicatorActionEnum_scenario } from '../enums/CommunicatorActionEnum';
 export class CommunicatorReceiver {
@@ -24,29 +24,10 @@ export class CommunicatorReceiver {
             }
             const queue = this.queue.filter(item => item.target === message.target && message.action.hasOwnProperty(item.action));
             const defaultScenario = CommunicatorActionEnum_scenario();
-            let sortedQueue = queue.sort((a, b) => {
-                if (defaultScenario.indexOf(a.action) > defaultScenario.indexOf(b.action)) {
-                    return -1;
-                }
-                if (defaultScenario.indexOf(a.action) < defaultScenario.indexOf(b.action)) {
-                    return 1;
-                }
-                return 0;
-            });
+            let sortedQueue = sortMessageQueue(queue, defaultScenario);
             const scenario = this.getMessageScenario(message.target);
             if (defaultScenario !== scenario) {
-                sortedQueue = queue.sort((a, b) => {
-                    if (scenario.indexOf(a.action) === -1 || scenario.indexOf(b.action) === -1) {
-                        return 0;
-                    }
-                    if (scenario.indexOf(a.action) > scenario.indexOf(b.action)) {
-                        return 1;
-                    }
-                    if (scenario.indexOf(a.action) < scenario.indexOf(b.action)) {
-                        return -1;
-                    }
-                    return 0;
-                });
+                sortedQueue = sortMessageQueue(queue, scenario);
             }
             if (sortedQueue.length) {
                 sortedQueue.forEach(item => {
@@ -102,7 +83,7 @@ export class CommunicatorReceiver {
             return false;
         };
         this.getMessageScenario = (target) => {
-            let scenario = this.scenario[target];
+            const scenario = this.scenario[target];
             if (scenario) {
                 return scenario;
             }

package/dist/engine/utils.d.ts

@@ -1,3 +1,5 @@
-import { TCommunicatorMessage } from "../types";
+import { TCommunicatorMessage, TReceiverMessageQueue } from "../types";
+import { CommunicatorActionEnum } from "../enums/CommunicatorActionEnum";
 export declare function modifyOrigin(address: string): string;
 export declare function isValidMessage(message: TCommunicatorMessage): boolean;
+export declare function sortMessageQueue(queue: TReceiverMessageQueue, scenario: CommunicatorActionEnum[]): TReceiverMessageQueue;

package/dist/engine/utils.js

@@ -28,3 +28,14 @@ export function isValidMessage(message) {
     }
     return isValidTarget && isValidActions;
 }
+export function sortMessageQueue(queue, scenario) {
+    return queue.sort((a, b) => {
+        if (scenario.indexOf(a.action) > scenario.indexOf(b.action)) {
+            return 1;
+        }
+        if (scenario.indexOf(a.action) < scenario.indexOf(b.action)) {
+            return -1;
+        }
+        return 0;
+    });
+}

package/dist/enums/CommunicatorActionEnum.d.ts

@@ -6,4 +6,4 @@ export declare enum CommunicatorActionEnum {
     GOTO = "goto"
 }
 export declare function CommunicatorActionEnum_isCorrect(item: string): boolean;
-export declare function CommunicatorActionEnum_scenario(): string[];
+export declare function CommunicatorActionEnum_scenario(): CommunicatorActionEnum[];

package/jest.config.js

@@ -0,0 +1,18 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { defaultsESM: tsjPreset } = require('ts-jest/presets');
+
+module.exports = {
+  roots: ['<rootDir>/test'],
+  testMatch: [
+    '**/__tests__/**/*.+(ts|js)',
+    '**/?(*.)+(spec).+(ts|js)',
+  ],
+  transform: {
+    ...tsjPreset.transform,
+  },
+  globals: {
+    'ts-jest': {
+      'tsconfig': 'tsconfig.json'
+    }
+  }
+};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.13",
+  "version": "0.0.14",
   "name": "@maxzima/wa-communicator",
   "description": "",
   "author": "Noname",
@@ -13,16 +13,34 @@
     "type": "git",
     "url": ""
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run test && npm run build",
     "clean": "node tools/cleanup",
     "build": "npm run clean && run-p build:*",
     "build:esm": "tsc -p config/tsconfig.esm.json",
     "build:types": "tsc -p config/tsconfig.types.json",
-    "package": "npm run build"
+    "package": "npm run build",
+    "lint": "eslint --cache --ext .ts ./src",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "jest --no-cache --runInBand"
   },
   "devDependencies": {
+    "@types/jest": "^28.1.8",
+    "@typescript-eslint/eslint-plugin": "^5.35.1",
+    "@typescript-eslint/parser": "^5.35.1",
+    "eslint": "^8.22.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-editorconfig": "^4.0.2",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "^28.1.3",
     "npm-run-all": "^4.1.5",
+    "prettier": "^2.7.1",
+    "ts-jest": "^28.0.8",
     "typescript": "^4.7.4"
   }
 }

package/src/engine/CommunicatorReceiver.ts

@@ -6,7 +6,7 @@ import {
   TReceiverTargetScenario,
   TReceiverUnsubscribeMessageParams,
 } from '../types';
-import {isValidMessage, modifyOrigin} from "./utils";
+import {isValidMessage, modifyOrigin, sortMessageQueue} from "./utils";
 import {CommunicatorTargetEnum, CommunicatorTargetEnum_isCorrect} from '../enums/CommunicatorTargetEnum';
 import {
   CommunicatorActionEnum,
@@ -55,36 +55,16 @@ export class CommunicatorReceiver {
       return;
     }
 
-    // Find queue by target and action
     const queue = this.queue.filter(item => item.target === message.target && message.action.hasOwnProperty(item.action));
 
     // default sort queue
     const defaultScenario = CommunicatorActionEnum_scenario();
-    let sortedQueue = queue.sort((a, b) => {
-      if (defaultScenario.indexOf(a.action) > defaultScenario.indexOf(b.action)) {
-        return -1;
-      }
-      if (defaultScenario.indexOf(a.action) < defaultScenario.indexOf(b.action)) {
-        return 1;
-      }
-      return 0;
-    })
+    let sortedQueue = sortMessageQueue(queue, defaultScenario);
 
     // sort queue
     const scenario = this.getMessageScenario(message.target);
     if (defaultScenario !== scenario) {
-      sortedQueue = queue.sort((a, b) => {
-        if (scenario.indexOf(a.action) === -1 || scenario.indexOf(b.action) === -1) {
-          return 0;
-        }
-        if (scenario.indexOf(a.action) > scenario.indexOf(b.action)) {
-          return 1;
-        }
-        if (scenario.indexOf(a.action) < scenario.indexOf(b.action)) {
-          return -1;
-        }
-        return 0;
-      })
+      sortedQueue = sortMessageQueue(queue, scenario);
     }
 
     if (sortedQueue.length) {
@@ -92,7 +72,7 @@ export class CommunicatorReceiver {
         if (typeof item.params.callback === 'function') {
           item.params.callback(message);
         }
-      })
+      });
     }
   };
 
@@ -134,7 +114,7 @@ export class CommunicatorReceiver {
     }
 
     this.queue.push(newQueueItem);
-  }
+  };
 
   /**
    * Subscribe by code or target or action
@@ -159,18 +139,27 @@ export class CommunicatorReceiver {
     }
 
     return false;
-  }
+  };
 
+  /**
+   * Get scenario for target
+   * @param target
+   */
   private getMessageScenario = (target: CommunicatorTargetEnum) => {
-    let scenario = this.scenario[target];
+    const scenario = this.scenario[target];
 
     if (scenario) {
       return scenario;
     }
 
     return CommunicatorActionEnum_scenario();
-  }
+  };
 
+  /**
+   * Change scenario for target
+   * @param target
+   * @param scenario
+   */
   public setMessageScenario = (target: CommunicatorTargetEnum, scenario: CommunicatorActionEnum[]) => {
     if (
       !CommunicatorTargetEnum_isCorrect(target) ||
@@ -185,9 +174,9 @@ export class CommunicatorReceiver {
       if (!CommunicatorActionEnum_isCorrect(item)) {
         throw new Error('WAC: failed scenario action!');
       }
-    })
+    });
 
     this.scenario[target] = scenario;
-  }
+  };
 }
 

package/src/engine/utils.ts

@@ -1,6 +1,6 @@
-import {TCommunicatorMessage} from "../types";
+import {TCommunicatorMessage, TReceiverMessageQueue} from "../types";
 import {CommunicatorTargetEnum_isCorrect} from "../enums/CommunicatorTargetEnum";
-import {CommunicatorActionEnum_isCorrect} from "../enums/CommunicatorActionEnum";
+import {CommunicatorActionEnum, CommunicatorActionEnum_isCorrect} from "../enums/CommunicatorActionEnum";
 
 /**
  * @param address
@@ -39,3 +39,15 @@ export function isValidMessage(message: TCommunicatorMessage) {
 
   return isValidTarget && isValidActions;
 }
+
+export function sortMessageQueue(queue: TReceiverMessageQueue, scenario: CommunicatorActionEnum[]) {
+  return queue.sort((a, b) => {
+    if (scenario.indexOf(a.action) > scenario.indexOf(b.action)) {
+      return 1;
+    }
+    if (scenario.indexOf(a.action) < scenario.indexOf(b.action)) {
+      return -1;
+    }
+    return 0;
+  });
+}

package/src/enums/CommunicatorActionEnum.ts

@@ -10,6 +10,6 @@ export function CommunicatorActionEnum_isCorrect(item: string): boolean {
   return Object.values(CommunicatorActionEnum).includes(item as CommunicatorActionEnum);
 }
 
-export function CommunicatorActionEnum_scenario(): string[]  {
+export function CommunicatorActionEnum_scenario(): CommunicatorActionEnum[]  {
   return Object.values(CommunicatorActionEnum);
 }

package/src/index.ts

@@ -1,7 +1,7 @@
-import {CommunicatorReceiver} from "./engine/CommunicatorReceiver"
-import {CommunicatorSender} from "./engine/CommunicatorSender"
-import {CommunicatorTargetEnum} from "./enums/CommunicatorTargetEnum"
-import {CommunicatorActionEnum} from "./enums/CommunicatorActionEnum"
+import {CommunicatorReceiver} from "./engine/CommunicatorReceiver";
+import {CommunicatorSender} from "./engine/CommunicatorSender";
+import {CommunicatorTargetEnum} from "./enums/CommunicatorTargetEnum";
+import {CommunicatorActionEnum} from "./enums/CommunicatorActionEnum";
 import * as types from "./types";
 
 export {
@@ -10,4 +10,4 @@ export {
   CommunicatorTargetEnum,
   CommunicatorActionEnum,
   types,
-}
+};

package/src/receiver.ts

@@ -1,6 +1,6 @@
-import {CommunicatorReceiver} from "./engine/CommunicatorReceiver"
-import {CommunicatorTargetEnum} from "./enums/CommunicatorTargetEnum"
-import {CommunicatorActionEnum} from "./enums/CommunicatorActionEnum"
+import {CommunicatorReceiver} from "./engine/CommunicatorReceiver";
+import {CommunicatorTargetEnum} from "./enums/CommunicatorTargetEnum";
+import {CommunicatorActionEnum} from "./enums/CommunicatorActionEnum";
 import * as types from "./types";
 import {isValidMessage as communicatorMessageIsValid} from "./engine/utils";
 
@@ -10,4 +10,4 @@ export {
   CommunicatorActionEnum,
   types,
   communicatorMessageIsValid
-}
+};

package/src/sender.ts

@@ -1,6 +1,6 @@
-import {CommunicatorSender} from "./engine/CommunicatorSender"
-import {CommunicatorTargetEnum} from "./enums/CommunicatorTargetEnum"
-import {CommunicatorActionEnum} from "./enums/CommunicatorActionEnum"
+import {CommunicatorSender} from "./engine/CommunicatorSender";
+import {CommunicatorTargetEnum} from "./enums/CommunicatorTargetEnum";
+import {CommunicatorActionEnum} from "./enums/CommunicatorActionEnum";
 import * as types from "./types";
 
 export {
@@ -8,4 +8,4 @@ export {
   CommunicatorTargetEnum,
   CommunicatorActionEnum,
   types,
-}
+};

package/test/testUnits/message.ts

@@ -0,0 +1,44 @@
+import {TCommunicatorMessage} from '../../src/types';
+import {CommunicatorActionEnum, CommunicatorTargetEnum} from '../../src';
+
+const normalMessage: TCommunicatorMessage = {
+  target: CommunicatorTargetEnum.SIGN_UP,
+  action: {
+    [CommunicatorActionEnum.OPEN]: CommunicatorTargetEnum.SIGN_IN,
+    [CommunicatorActionEnum.CLOSE]: true,
+    [CommunicatorActionEnum.GOTO]: {
+      url: 'google.com',
+    },
+  }
+};
+
+const messageWithInvalidTarget: TCommunicatorMessage = {
+  target: 'Invalid' as CommunicatorTargetEnum,
+  action: {
+    [CommunicatorActionEnum.OPEN]: CommunicatorTargetEnum.SIGN_IN,
+    [CommunicatorActionEnum.CLOSE]: true,
+  }
+};
+
+const messageWithInvalidAction: TCommunicatorMessage = {
+  target: CommunicatorTargetEnum.SIGN_UP,
+  action: {
+    ['Invalid' as CommunicatorActionEnum]: CommunicatorTargetEnum.SIGN_IN,
+    [CommunicatorActionEnum.CLOSE]: true,
+  }
+};
+
+const messageWithInvalidActionParams: TCommunicatorMessage = {
+  target: 'Invalid' as CommunicatorTargetEnum,
+  action: {
+    [CommunicatorActionEnum.OPEN]: 'failed' as CommunicatorTargetEnum,
+    [CommunicatorActionEnum.CLOSE]: true,
+  }
+};
+
+export {
+  normalMessage,
+  messageWithInvalidTarget,
+  messageWithInvalidAction,
+  messageWithInvalidActionParams
+};

package/test/testUnits/queue.ts

@@ -0,0 +1,56 @@
+import {TReceiverMessageQueue} from '../../src/types';
+import {CommunicatorActionEnum, CommunicatorTargetEnum} from '../../src';
+
+const getQueue = (isDefaultSort = false): TReceiverMessageQueue => {
+  if (isDefaultSort) {
+    return [
+      {
+        target: CommunicatorTargetEnum.SIGN_IN,
+        action: CommunicatorActionEnum.CLOSE,
+        params: {
+          callback: () => {}
+        }
+      },
+      {
+        target: CommunicatorTargetEnum.SIGN_IN,
+        action: CommunicatorActionEnum.OPEN,
+        params: {
+          callback: () => {}
+        }
+      },
+      {
+        target: CommunicatorTargetEnum.SIGN_IN,
+        action: CommunicatorActionEnum.GOTO,
+        params: {
+          callback: () => {}
+        }
+      }
+    ];
+  }
+
+  return [
+    {
+      target: CommunicatorTargetEnum.SIGN_IN,
+      action: CommunicatorActionEnum.OPEN,
+      params: {
+        callback: () => {}
+      }
+    },
+    {
+      target: CommunicatorTargetEnum.SIGN_IN,
+      action: CommunicatorActionEnum.CLOSE,
+      params: {
+        callback: () => {}
+      }
+    },
+    {
+      target: CommunicatorTargetEnum.SIGN_IN,
+      action: CommunicatorActionEnum.GOTO,
+      params: {
+        callback: () => {}
+      }
+    }
+  ];
+};
+
+export default getQueue;

package/test/utiles.spec.ts

@@ -0,0 +1,44 @@
+import {isValidMessage, modifyOrigin, sortMessageQueue} from '../src/engine/utils';
+import {CommunicatorActionEnum_scenario} from '../src/enums/CommunicatorActionEnum';
+import getQueue from './testUnits/queue';
+import {messageWithInvalidAction, messageWithInvalidTarget, normalMessage} from './testUnits/message';
+
+test('modifyOrigin', () => {
+  expect(modifyOrigin('google.com')).toBe('https://google.com');
+  expect(modifyOrigin('google.com/test')).toBe('https://google.com');
+  expect(modifyOrigin('https://google.com/')).toBe('https://google.com');
+});
+
+describe('isValidMessage', () => {
+  it('message is valid', () => {
+    expect(isValidMessage(normalMessage)).toBeTruthy();
+  });
+
+  it('message has invalid target', () => {
+    expect(
+      isValidMessage(messageWithInvalidTarget)
+    ).toBeFalsy();
+  });
+
+  it('message has invalid action', () => {
+    expect(
+      isValidMessage(messageWithInvalidAction)
+    ).toBeFalsy();
+  });
+
+  // TODO: need validation action params
+  // it('Invalid Action Params', () => {
+  //   expect(
+  //     isValidMessage(messageWithInvalidActionParams)
+  //   ).toBeFalsy();
+  // });
+});
+
+describe('sortMessageQueue', () => {
+  it('Default Sorting', () => {
+    expect(
+      JSON.stringify(sortMessageQueue(getQueue(), CommunicatorActionEnum_scenario()))
+    ).toBe(JSON.stringify(getQueue(true)));
+  });
+});
+

package/tools/cleanup.js

@@ -1,26 +1,26 @@
-/* eslint-disable */
-const fs = require('fs')
-const Path = require('path')
-/* eslint-enable */
+/* eslint-disable @typescript-eslint/no-var-requires */
+const fs = require('fs');
+const Path = require('path');
+/* eslint-enable @typescript-eslint/no-var-requires */
 
 const deleteFolderRecursive = (path) => {
   if (fs.existsSync(path)) {
     fs.readdirSync(path).forEach((file) => {
-      const curPath = Path.join(path, file)
+      const curPath = Path.join(path, file);
       if (fs.lstatSync(curPath).isDirectory()) {
-        deleteFolderRecursive(curPath)
+        deleteFolderRecursive(curPath);
       } else {
-        fs.unlinkSync(curPath)
+        fs.unlinkSync(curPath);
       }
-    })
-    fs.rmdirSync(path)
+    });
+    fs.rmdirSync(path);
   }
-}
+};
 
-const folder = process.argv.slice(2)[0]
+const folder = process.argv.slice(2)[0];
 
 if (folder) {
-  deleteFolderRecursive(Path.join(__dirname, '../dist', folder))
+  deleteFolderRecursive(Path.join(__dirname, '../dist', folder));
 } else {
-  deleteFolderRecursive(Path.join(__dirname, '../dist'))
+  deleteFolderRecursive(Path.join(__dirname, '../dist'));
 }