@maxzima/wa-communicator 0.0.10 → 0.0.11

package/dist/engine/CommunicatorReceiver.d.ts

@@ -1,9 +1,14 @@
 import { TReceiverProps, TReceiverSubscribeParams, TReceiverUnsubscribeMessageParams } from '../types';
+import { CommunicatorTargetEnum } from '../enums/CommunicatorTargetEnum';
+import { CommunicatorActionEnum } from '../enums/CommunicatorActionEnum';
 export declare class CommunicatorReceiver {
     private readonly senderOrigin;
     private queue;
+    private scenario;
     constructor(props: TReceiverProps);
     private onMessage;
     subscribe: (params: TReceiverSubscribeParams) => void;
     unsubscribe: (params?: TReceiverUnsubscribeMessageParams) => boolean;
+    private getMessageScenario;
+    setMessageScenario: (target: CommunicatorTargetEnum, scenario: CommunicatorActionEnum[]) => void;
 }

package/dist/engine/CommunicatorReceiver.js

@@ -1,9 +1,10 @@
 import { isValidMessage, modifyOrigin } from "./utils";
 import { CommunicatorTargetEnum_isCorrect } from '../enums/CommunicatorTargetEnum';
-import { CommunicatorActionEnum_isCorrect } from '../enums/CommunicatorActionEnum';
+import { CommunicatorActionEnum_isCorrect, CommunicatorActionEnum_scenario } from '../enums/CommunicatorActionEnum';
 export class CommunicatorReceiver {
     constructor(props) {
         this.queue = [];
+        this.scenario = {};
         this.onMessage = (event) => {
             if (!event || !event.origin || !event.data) {
                 return;
@@ -22,8 +23,33 @@ export class CommunicatorReceiver {
                 return;
             }
             const queue = this.queue.filter(item => item.target === message.target && message.action.hasOwnProperty(item.action));
-            if (queue.length) {
-                queue.forEach(item => {
+            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;
+            });
+            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;
+                });
+            }
+            if (sortedQueue.length) {
+                sortedQueue.forEach(item => {
                     if (typeof item.params.callback === 'function') {
                         item.params.callback(message);
                     }
@@ -74,6 +100,27 @@ export class CommunicatorReceiver {
             }
             return false;
         };
+        this.getMessageScenario = (target) => {
+            let scenario = this.scenario[target];
+            if (scenario) {
+                return scenario;
+            }
+            return CommunicatorActionEnum_scenario();
+        };
+        this.setMessageScenario = (target, scenario) => {
+            if (!CommunicatorTargetEnum_isCorrect(target) ||
+                !Array.isArray(scenario) ||
+                !scenario.length) {
+                return;
+            }
+            scenario = [...new Set(scenario)];
+            scenario.forEach(item => {
+                if (!CommunicatorActionEnum_isCorrect(item)) {
+                    throw new Error('WAC: failed scenario action!');
+                }
+            });
+            this.scenario[target] = scenario;
+        };
         this.senderOrigin = modifyOrigin(props.senderOrigin);
         if (this.senderOrigin) {
             window.addEventListener('message', this.onMessage, false);

package/dist/enums/CommunicatorActionEnum.d.ts

@@ -1,8 +1,9 @@
 export declare enum CommunicatorActionEnum {
+    TOKEN = "token",
+    RESIZE = "resize",
     CLOSE = "close",
     OPEN = "open",
-    GOTO = "goto",
-    RESIZE = "resize",
-    TOKEN = "token"
+    GOTO = "goto"
 }
 export declare function CommunicatorActionEnum_isCorrect(item: string): boolean;
+export declare function CommunicatorActionEnum_scenario(): string[];

package/dist/enums/CommunicatorActionEnum.js

@@ -1,11 +1,14 @@
 export var CommunicatorActionEnum;
 (function (CommunicatorActionEnum) {
+    CommunicatorActionEnum["TOKEN"] = "token";
+    CommunicatorActionEnum["RESIZE"] = "resize";
     CommunicatorActionEnum["CLOSE"] = "close";
     CommunicatorActionEnum["OPEN"] = "open";
     CommunicatorActionEnum["GOTO"] = "goto";
-    CommunicatorActionEnum["RESIZE"] = "resize";
-    CommunicatorActionEnum["TOKEN"] = "token";
 })(CommunicatorActionEnum || (CommunicatorActionEnum = {}));
 export function CommunicatorActionEnum_isCorrect(item) {
     return Object.values(CommunicatorActionEnum).includes(item);
 }
+export function CommunicatorActionEnum_scenario() {
+    return Object.values(CommunicatorActionEnum);
+}

package/dist/types/index.d.ts

@@ -8,6 +8,12 @@ export declare type TReceiverProps = {
     senderOrigin: string;
 };
 export declare type TReceiverCallback = (message: TCommunicatorMessage) => void;
+export declare type TCommunicatorActionTokenParams = {
+    name: string;
+    value: string;
+    domain: string;
+    expires: string;
+};
 export declare type TCommunicatorActionResizeParams = {
     width?: number;
     height?: number;
@@ -17,11 +23,11 @@ export declare type TCommunicatorActionGotoParams = {
     isTargetBlank?: boolean;
 };
 export declare type TCommunicatorSenderActionMap = {
+    [CommunicatorActionEnum.TOKEN]?: TCommunicatorActionTokenParams;
     [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams;
     [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams;
     [CommunicatorActionEnum.CLOSE]?: true;
     [CommunicatorActionEnum.OPEN]?: CommunicatorTargetEnum;
-    [CommunicatorActionEnum.TOKEN]?: string;
 };
 export declare type TCommunicatorMessage = {
     target: CommunicatorTargetEnum;
@@ -47,3 +53,6 @@ export declare type TReceiverUnsubscribeMessageParams = {
     target?: CommunicatorTargetEnum;
     action?: CommunicatorActionEnum;
 };
+export declare type TReceiverTargetScenario = {
+    [key in CommunicatorTargetEnum]?: CommunicatorActionEnum[];
+};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.10",
+  "version": "0.0.11",
   "name": "@maxzima/wa-communicator",
   "description": "",
   "author": "Noname",

package/src/engine/CommunicatorReceiver.ts

@@ -3,15 +3,29 @@ import {
   TReceiverMessageQueue,
   TReceiverProps,
   TReceiverSubscribeParams,
+  TReceiverTargetScenario,
   TReceiverUnsubscribeMessageParams,
 } from '../types';
 import {isValidMessage, modifyOrigin} from "./utils";
-import {CommunicatorTargetEnum_isCorrect} from '../enums/CommunicatorTargetEnum';
-import {CommunicatorActionEnum_isCorrect} from '../enums/CommunicatorActionEnum';
+import {CommunicatorTargetEnum, CommunicatorTargetEnum_isCorrect} from '../enums/CommunicatorTargetEnum';
+import {
+  CommunicatorActionEnum,
+  CommunicatorActionEnum_isCorrect,
+  CommunicatorActionEnum_scenario
+} from '../enums/CommunicatorActionEnum';
+
+// const defaultScenario = [
+//   CommunicatorActionEnum.TOKEN,
+//   CommunicatorActionEnum.RESIZE,
+//   CommunicatorActionEnum.GOTO,
+//   CommunicatorActionEnum.CLOSE,
+//   CommunicatorActionEnum.OPEN,
+// ];
 
 export class CommunicatorReceiver {
   private readonly senderOrigin: string;
   private queue: TReceiverMessageQueue = [];
+  private scenario: TReceiverTargetScenario = {};
 
   constructor(props: TReceiverProps) {
     this.senderOrigin = modifyOrigin(props.senderOrigin);
@@ -52,8 +66,37 @@ export class CommunicatorReceiver {
     // Find queue by target and action
     const queue = this.queue.filter(item => item.target === message.target && message.action.hasOwnProperty(item.action));
 
-    if (queue.length) {
-      queue.forEach(item => {
+    // 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;
+    })
+
+    // 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;
+      })
+    }
+
+    if (sortedQueue.length) {
+      sortedQueue.forEach(item => {
         if (typeof item.params.callback === 'function') {
           item.params.callback(message);
         }
@@ -124,5 +167,34 @@ export class CommunicatorReceiver {
 
     return false;
   }
+
+  private getMessageScenario = (target: CommunicatorTargetEnum) => {
+    let scenario = this.scenario[target];
+
+    if (scenario) {
+      return scenario;
+    }
+
+    return CommunicatorActionEnum_scenario();
+  }
+
+  public setMessageScenario = (target: CommunicatorTargetEnum, scenario: CommunicatorActionEnum[]) => {
+    if (
+      !CommunicatorTargetEnum_isCorrect(target) ||
+      !Array.isArray(scenario) ||
+      !scenario.length) {
+      return;
+    }
+
+    scenario = [...new Set(scenario)];
+
+    scenario.forEach(item => {
+      if (!CommunicatorActionEnum_isCorrect(item)) {
+        throw new Error('WAC: failed scenario action!');
+      }
+    })
+
+    this.scenario[target] = scenario;
+  }
 }
 

package/src/engine/utils.ts

@@ -3,7 +3,6 @@ import {CommunicatorTargetEnum_isCorrect} from "../enums/CommunicatorTargetEnum"
 import {CommunicatorActionEnum_isCorrect} from "../enums/CommunicatorActionEnum";
 
 /**
- * 
  * @param address
  */
 export function modifyOrigin(address: string): string {

package/src/enums/CommunicatorActionEnum.ts

@@ -1,11 +1,15 @@
 export enum CommunicatorActionEnum {
+  TOKEN = 'token',
+  RESIZE = 'resize',
   CLOSE = 'close',
   OPEN = 'open',
   GOTO = 'goto',
-  RESIZE = 'resize',
-  TOKEN = 'token',
 }
 
 export function CommunicatorActionEnum_isCorrect(item: string): boolean {
   return Object.values(CommunicatorActionEnum).includes(item as CommunicatorActionEnum);
 }
+
+export function CommunicatorActionEnum_scenario(): string[]  {
+  return Object.values(CommunicatorActionEnum);
+}

package/src/types/index.ts

@@ -12,6 +12,13 @@ export type TReceiverProps = {
 
 export type TReceiverCallback = (message: TCommunicatorMessage) => void;
 
+export type TCommunicatorActionTokenParams = {
+  name: string,
+  value: string,
+  domain: string,
+  expires: string,
+}
+
 export type TCommunicatorActionResizeParams = {
   width?: number,
   height?: number,
@@ -23,11 +30,11 @@ export type TCommunicatorActionGotoParams = {
 }
 
 export type TCommunicatorSenderActionMap = {
+  [CommunicatorActionEnum.TOKEN]?: TCommunicatorActionTokenParams,
   [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams,
   [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams,
   [CommunicatorActionEnum.CLOSE]?: true,
   [CommunicatorActionEnum.OPEN]?: CommunicatorTargetEnum,
-  [CommunicatorActionEnum.TOKEN]?: string,
 }
 
 export type TCommunicatorMessage = {
@@ -58,3 +65,7 @@ export type TReceiverUnsubscribeMessageParams = {
   target?: CommunicatorTargetEnum,
   action?: CommunicatorActionEnum,
 }
+
+export type TReceiverTargetScenario = {
+  [key in CommunicatorTargetEnum]?: CommunicatorActionEnum[];
+}