@maxzima/wa-communicator 0.0.13 → 0.0.16

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

@@ -10,7 +10,7 @@ export function modifyOrigin(address) {
     catch (_) {
         return null;
     }
-    return url.origin;
+    return url.origin !== 'null' ? url.origin : null;
 }
 export function isValidMessage(message) {
     const isValidTarget = message.target && CommunicatorTargetEnum_isCorrect(message.target);
@@ -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

@@ -1,4 +1,5 @@
 export declare enum CommunicatorActionEnum {
+    LOADED = "loaded",
     TOKEN = "token",
     RESIZE = "resize",
     CLOSE = "close",
@@ -6,4 +7,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/dist/enums/CommunicatorActionEnum.js

@@ -1,5 +1,6 @@
 export var CommunicatorActionEnum;
 (function (CommunicatorActionEnum) {
+    CommunicatorActionEnum["LOADED"] = "loaded";
     CommunicatorActionEnum["TOKEN"] = "token";
     CommunicatorActionEnum["RESIZE"] = "resize";
     CommunicatorActionEnum["CLOSE"] = "close";

package/dist/types/index.d.ts

@@ -23,6 +23,7 @@ export declare type TCommunicatorActionGotoParams = {
     isTargetBlank?: boolean;
 };
 export declare type TCommunicatorSenderActionMap = {
+    [CommunicatorActionEnum.LOADED]?: true;
     [CommunicatorActionEnum.TOKEN]?: TCommunicatorActionTokenParams;
     [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams;
     [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams;

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.16",
   "name": "@maxzima/wa-communicator",
   "description": "",
   "author": "Noname",
@@ -13,16 +13,51 @@
     "type": "git",
     "url": ""
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "size-limit": [
+    {
+      "path": "dist/index.js",
+      "limit": "10 KB"
+    },
+    {
+      "path": "dist/sender.js",
+      "limit": "10 KB"
+    },
+    {
+      "path": "dist/receiver.js",
+      "limit": "10 KB"
+    }
+  ],
   "scripts": {
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run test && npm run build && npm run size",
     "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",
+    "size": "size-limit"
   },
   "devDependencies": {
+    "@size-limit/preset-small-lib": "^8.1.0",
+    "@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",
+    "size-limit": "^8.1.0",
+    "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
@@ -14,7 +14,7 @@ export function modifyOrigin(address: string): string {
   } catch (_) {
     return null;
   }
-  return url.origin;
+  return url.origin !== 'null' ? url.origin : null;
 }
 
 /**
@@ -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

@@ -1,4 +1,5 @@
 export enum CommunicatorActionEnum {
+  LOADED = 'loaded',
   TOKEN = 'token',
   RESIZE = 'resize',
   CLOSE = 'close',
@@ -10,6 +11,6 @@ export function CommunicatorActionEnum_isCorrect(item: string): boolean {
   return Object.values(CommunicatorActionEnum).includes(item as CommunicatorActionEnum);
 }
 
-export function CommunicatorActionEnum_scenario(): string[]  {
-  return Object.values(CommunicatorActionEnum);
+export function CommunicatorActionEnum_scenario(): CommunicatorActionEnum[]  {
+  return Object.values(CommunicatorActionEnum) as 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/src/types/index.ts

@@ -30,6 +30,7 @@ export type TCommunicatorActionGotoParams = {
 }
 
 export type TCommunicatorSenderActionMap = {
+  [CommunicatorActionEnum.LOADED]?: true,
   [CommunicatorActionEnum.TOKEN]?: TCommunicatorActionTokenParams,
   [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams,
   [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams,

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,165 @@
+import {TReceiverMessageQueue} from '../../src/types';
+import {CommunicatorActionEnum, CommunicatorTargetEnum} from '../../src';
+
+const queueWithoutSorting: TReceiverMessageQueue = [
+  {
+    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: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.TOKEN,
+    params: {
+      callback: () => {}
+    }
+  },
+];
+
+const queueWithDefaultScenario: TReceiverMessageQueue = [
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.TOKEN,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    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: () => {}
+    }
+  },
+];
+
+const queueWithCustomScenario: TReceiverMessageQueue = [
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.OPEN,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.CLOSE,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.TOKEN,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.GOTO,
+    params: {
+      callback: () => {}
+    }
+  },
+];
+
+const queueWithCustomV2Scenario: TReceiverMessageQueue = [
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.CLOSE,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.TOKEN,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.OPEN,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.GOTO,
+    params: {
+      callback: () => {}
+    }
+  },
+];
+
+const queueWithCustomV3Scenario: TReceiverMessageQueue = [
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.OPEN,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.CLOSE,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.TOKEN,
+    params: {
+      callback: () => {}
+    }
+  },
+  {
+    target: CommunicatorTargetEnum.SIGN_IN,
+    action: CommunicatorActionEnum.GOTO,
+    params: {
+      callback: () => {}
+    }
+  },
+];
+
+export {
+  queueWithoutSorting,
+  queueWithDefaultScenario,
+  queueWithCustomScenario,
+  queueWithCustomV2Scenario,
+  queueWithCustomV3Scenario,
+};

package/test/testUnits/scenario.ts

@@ -0,0 +1,31 @@
+import {CommunicatorActionEnum, CommunicatorActionEnum_scenario} from '../../src/enums/CommunicatorActionEnum';
+
+const defaultScenario = CommunicatorActionEnum_scenario();
+
+const scenarioCustom = [
+  CommunicatorActionEnum.CLOSE,
+  CommunicatorActionEnum.TOKEN,
+  CommunicatorActionEnum.GOTO,
+];
+
+const scenarioCustomV2 = [
+  CommunicatorActionEnum.CLOSE,
+  CommunicatorActionEnum.TOKEN,
+  CommunicatorActionEnum.OPEN,
+  CommunicatorActionEnum.GOTO,
+];
+
+const scenarioCustomV3 = [
+  CommunicatorActionEnum.OPEN,
+  CommunicatorActionEnum.CLOSE,
+  CommunicatorActionEnum.TOKEN,
+  CommunicatorActionEnum.OPEN,
+  CommunicatorActionEnum.GOTO,
+];
+
+export {
+  defaultScenario,
+  scenarioCustom,
+  scenarioCustomV2,
+  scenarioCustomV3
+};

package/test/utiles.spec.ts

@@ -0,0 +1,69 @@
+import {isValidMessage, modifyOrigin, sortMessageQueue} from '../src/engine/utils';
+import {
+  queueWithCustomScenario,
+  queueWithCustomV2Scenario, queueWithCustomV3Scenario,
+  queueWithDefaultScenario,
+  queueWithoutSorting
+} from './testUnits/queue';
+import {messageWithInvalidAction, messageWithInvalidTarget, normalMessage} from './testUnits/message';
+import {scenarioCustom, defaultScenario, scenarioCustomV2, scenarioCustomV3} from './testUnits/scenario';
+
+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');
+  expect(modifyOrigin('  https://google.com/')).toBe('https://google.com');
+  expect(modifyOrigin('htts://google.com')).toBe(null);
+});
+
+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 (Default scenario)', () => {
+    expect(
+      JSON.stringify(sortMessageQueue(queueWithoutSorting, defaultScenario))
+    ).toBe(JSON.stringify(queueWithDefaultScenario));
+  });
+
+  it('Custom Sorting (Not full scenario)', () => {
+    expect(
+      JSON.stringify(sortMessageQueue(queueWithoutSorting, scenarioCustom))
+    ).toBe(JSON.stringify(queueWithCustomScenario));
+  });
+
+  it('Custom Sorting (Full scenario)', () => {
+    expect(
+      JSON.stringify(sortMessageQueue(queueWithoutSorting, scenarioCustomV2))
+    ).toBe(JSON.stringify(queueWithCustomV2Scenario));
+  });
+
+  it('Custom Sorting (Full scenario with Doubling)', () => {
+    expect(
+      JSON.stringify(sortMessageQueue(queueWithoutSorting, scenarioCustomV3))
+    ).toBe(JSON.stringify(queueWithCustomV3Scenario));
+  });
+});
+

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'));
 }