@maxzima/wa-communicator 0.0.9 → 0.0.12

package/README.md

@@ -56,7 +56,7 @@ const communicator = new CommunicatorReceiver({
 });
 
 // subscribe
-communicator.follow('one', {
+communicator.subscribe({
   target: CommunicatorTargetEnum.SIGN_UP,
   action: CommunicatorActionEnum.CLOSE,
   callback: message => {
@@ -65,8 +65,7 @@ communicator.follow('one', {
 });
 
 // unsubscribe
-receiver.unfollow({
-  code: 'one',
+receiver.unsubscribe({
   action: CommunicatorActionEnum.CLOSE
 });
 

package/dist/engine/CommunicatorReceiver.d.ts

@@ -1,11 +1,14 @@
-import { TCommunicatorMessage, TReceiverProps, TReceiverSubscribeParams, TReceiverUnsubscribeMessageParams } from '../types';
+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;
-    private prepareCode;
-    isValidMessage: (message: TCommunicatorMessage) => boolean;
-    subscribe: (code: string, params: TReceiverSubscribeParams) => void;
+    subscribe: (params: TReceiverSubscribeParams) => void;
     unsubscribe: (params?: TReceiverUnsubscribeMessageParams) => boolean;
+    private getMessageScenario;
+    setMessageScenario: (target: CommunicatorTargetEnum, scenario: CommunicatorActionEnum[]) => void;
 }

package/dist/engine/CommunicatorReceiver.js

@@ -1,82 +1,96 @@
-import { modifyOrigin } from "./utils";
+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;
             }
+            if (this.senderOrigin !== event.origin) {
+                return;
+            }
             let message;
             try {
                 message = JSON.parse(event.data);
             }
             catch (error) {
-                console.log('PostMessage read error');
-                return;
-            }
-            if (this.senderOrigin !== event.origin) {
                 return;
             }
-            if (!this.isValidMessage(message)) {
+            if (!isValidMessage(message)) {
                 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);
                     }
                 });
             }
         };
-        this.prepareCode = (code) => {
-            if (typeof code === 'string' || code === "") {
-                throw new Error('WAC: code is not valid!');
+        this.subscribe = (params) => {
+            if (params.code && typeof params.code !== 'string') {
+                throw new Error('WAC: code can only be a string!');
             }
-            return `wab_${code}`;
-        };
-        this.isValidMessage = (message) => {
-            const isValidTarget = message.target && CommunicatorTargetEnum_isCorrect(message.target);
-            const actions = message.action;
-            let isValidActions = typeof actions === 'object';
-            if (isValidTarget && isValidActions) {
-                for (const prop in actions) {
-                    if (actions.hasOwnProperty(prop)) {
-                        isValidActions = actions.hasOwnProperty(prop) && CommunicatorActionEnum_isCorrect(prop);
-                        if (!isValidActions) {
-                            break;
-                        }
-                    }
-                }
-            }
-            return isValidTarget && isValidActions;
-        };
-        this.subscribe = (code, params) => {
             if ((!params.target || !CommunicatorTargetEnum_isCorrect(params.target)) ||
                 (!params.action || !CommunicatorActionEnum_isCorrect(params.action))) {
                 throw new Error('WAC: target or action is not allowed!');
             }
-            if (this.queue.find(item => item.code === this.prepareCode(code) && item.target === params.target && item.action === params.action)) {
+            if (this.queue.find(item => {
+                return (!params.code || item.code === params.code) &&
+                    item.target === params.target &&
+                    item.action === params.action;
+            })) {
                 console.log(`WAB: subscribe is exists!`);
+                return;
             }
-            this.queue.push({
-                code: this.prepareCode(code),
+            const newQueueItem = {
                 target: params.target,
                 action: params.action,
                 params: {
                     callback: params.callback,
                 }
-            });
+            };
+            if (params.code) {
+                newQueueItem['code'] = params.code;
+            }
+            this.queue.push(newQueueItem);
         };
         this.unsubscribe = (params) => {
-            if (!params) {
+            if (!params || Object.keys(params).length === 0) {
                 this.queue = [];
                 return true;
             }
             const queueForRemove = this.queue.filter(item => {
-                return (!params.code || item.code === this.prepareCode(params.code)) &&
+                return (!params.code || item.code === params.code) &&
                     (!params.target || item.target === params.target) &&
                     (!params.action || item.action === params.action);
             });
@@ -87,6 +101,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/engine/CommunicatorSender.js

@@ -1,5 +1,4 @@
-import { modifyOrigin } from './utils';
-import { CommunicatorTargetEnum_isCorrect } from '../enums/CommunicatorTargetEnum';
+import { isValidMessage, modifyOrigin } from './utils';
 export class CommunicatorSender {
     constructor(props) {
         this.otherWindow = props.otherWindow;
@@ -12,12 +11,8 @@ export class CommunicatorSender {
         if (!this.receiverOrigin) {
             return;
         }
-        if (!CommunicatorTargetEnum_isCorrect(message.target)) {
-            throw new Error(`WAC: Target "${message.target}" is not allowed!`);
-        }
-        if (!this.receiverOrigin ||
-            !CommunicatorTargetEnum_isCorrect(message.target)) {
-            return;
+        if (!isValidMessage(message)) {
+            throw new Error(`WAC: Message not valid!`);
         }
         const jsonMessage = JSON.stringify(message);
         this.otherWindow.postMessage(jsonMessage, this.receiverOrigin);

package/dist/engine/utils.d.ts

@@ -1 +1,3 @@
+import { TCommunicatorMessage } from "../types";
 export declare function modifyOrigin(address: string): string;
+export declare function isValidMessage(message: TCommunicatorMessage): boolean;

package/dist/engine/utils.js

@@ -1,3 +1,5 @@
+import { CommunicatorTargetEnum_isCorrect } from "../enums/CommunicatorTargetEnum";
+import { CommunicatorActionEnum_isCorrect } from "../enums/CommunicatorActionEnum";
 export function modifyOrigin(address) {
     let url;
     try {
@@ -10,3 +12,19 @@ export function modifyOrigin(address) {
     }
     return url.origin;
 }
+export function isValidMessage(message) {
+    const isValidTarget = message.target && CommunicatorTargetEnum_isCorrect(message.target);
+    const actions = message.action;
+    let isValidActions = typeof actions === 'object';
+    if (isValidTarget && isValidActions) {
+        for (const prop in actions) {
+            if (actions.hasOwnProperty(prop)) {
+                isValidActions = actions.hasOwnProperty(prop) && CommunicatorActionEnum_isCorrect(prop);
+                if (!isValidActions) {
+                    break;
+                }
+            }
+        }
+    }
+    return isValidTarget && isValidActions;
+}

package/dist/enums/CommunicatorActionEnum.d.ts

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

package/dist/enums/CommunicatorActionEnum.js

@@ -1,10 +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 || (CommunicatorActionEnum = {}));
 export function CommunicatorActionEnum_isCorrect(item) {
     return Object.values(CommunicatorActionEnum).includes(item);
 }
+export function CommunicatorActionEnum_scenario() {
+    return Object.values(CommunicatorActionEnum);
+}

package/dist/receiver.d.ts

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

package/dist/receiver.js

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

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,6 +23,7 @@ export declare type TCommunicatorActionGotoParams = {
     isTargetBlank?: boolean;
 };
 export declare type TCommunicatorSenderActionMap = {
+    [CommunicatorActionEnum.TOKEN]?: TCommunicatorActionTokenParams;
     [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams;
     [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams;
     [CommunicatorActionEnum.CLOSE]?: true;
@@ -27,13 +34,14 @@ export declare type TCommunicatorMessage = {
     action: TCommunicatorSenderActionMap;
 };
 export declare type TReceiverSubscribeParams = {
+    code?: string;
     target: CommunicatorTargetEnum;
     action: CommunicatorActionEnum;
     callback: TReceiverCallback;
 };
 export declare type TReceiverMessageQueue = TReceiverMessageQueueItem[];
 export declare type TReceiverMessageQueueItem = {
-    code: string;
+    code?: string;
     target: CommunicatorTargetEnum;
     action: CommunicatorActionEnum;
     params?: {
@@ -45,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.9",
+  "version": "0.0.12",
   "name": "@maxzima/wa-communicator",
   "description": "",
   "author": "Noname",

package/src/engine/CommunicatorReceiver.ts

@@ -3,15 +3,21 @@ import {
   TReceiverMessageQueue,
   TReceiverProps,
   TReceiverSubscribeParams,
+  TReceiverTargetScenario,
   TReceiverUnsubscribeMessageParams,
 } from '../types';
-import {modifyOrigin} from "./utils";
-import {CommunicatorTargetEnum_isCorrect} from '../enums/CommunicatorTargetEnum';
-import {CommunicatorActionEnum_isCorrect} from '../enums/CommunicatorActionEnum';
+import {isValidMessage, modifyOrigin} from "./utils";
+import {CommunicatorTargetEnum, CommunicatorTargetEnum_isCorrect} from '../enums/CommunicatorTargetEnum';
+import {
+  CommunicatorActionEnum,
+  CommunicatorActionEnum_isCorrect,
+  CommunicatorActionEnum_scenario
+} from '../enums/CommunicatorActionEnum';
 
 export class CommunicatorReceiver {
   private readonly senderOrigin: string;
   private queue: TReceiverMessageQueue = [];
+  private scenario: TReceiverTargetScenario = {};
 
   constructor(props: TReceiverProps) {
     this.senderOrigin = modifyOrigin(props.senderOrigin);
@@ -33,75 +39,72 @@ export class CommunicatorReceiver {
       return;
     }
 
+    if (this.senderOrigin !== event.origin) {
+      return;
+    }
+
     let message: TCommunicatorMessage;
 
     try {
       message = JSON.parse(event.data);
     } catch (error) {
-      console.log('PostMessage read error');
       return;
     }
 
-    if (this.senderOrigin !== event.origin) {
-      return;
-    }
-
-    if (!this.isValidMessage(message)) {
+    if (!isValidMessage(message)) {
       return;
     }
 
     // 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 => {
-        if (typeof item.params.callback === 'function') {
-          item.params.callback(message);
+    // 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;
       })
     }
-  };
 
-  /**
-   * Prepare code for queue
-   * @param code
-   */
-  private prepareCode = (code: string) => {
-    if (typeof code === 'string' || code === "") {
-      throw new Error('WAC: code is not valid!');
-    }
-    return `wab_${code}`
-  }
-
-  /**
-   * Check the message for validity
-   * @param message
-   */
-  public isValidMessage = (message: TCommunicatorMessage) => {
-    const isValidTarget = message.target && CommunicatorTargetEnum_isCorrect(message.target);
-    const actions = message.action;
-    let isValidActions = typeof actions === 'object';
-
-    if (isValidTarget && isValidActions) {
-      for (const prop in actions) {
-        if(actions.hasOwnProperty(prop)) {
-          isValidActions = actions.hasOwnProperty(prop) && CommunicatorActionEnum_isCorrect(prop);
-          if (!isValidActions) {
-            break;
-          }
+    if (sortedQueue.length) {
+      sortedQueue.forEach(item => {
+        if (typeof item.params.callback === 'function') {
+          item.params.callback(message);
         }
-      }
+      })
     }
-
-    return isValidTarget && isValidActions;
-  }
+  };
 
   /**
    * Subscribe by target and action
-   * @param code
    * @param params
    */
-  public subscribe = (code: string, params: TReceiverSubscribeParams): void => {
+  public subscribe = (params: TReceiverSubscribeParams): void => {
+    if (params.code && typeof params.code !== 'string') {
+      throw new Error('WAC: code can only be a string!');
+    }
+
     if (
       (!params.target || !CommunicatorTargetEnum_isCorrect(params.target)) ||
       (!params.action || !CommunicatorActionEnum_isCorrect(params.action))
@@ -109,18 +112,28 @@ export class CommunicatorReceiver {
       throw new Error('WAC: target or action is not allowed!');
     }
 
-    if (this.queue.find(item => item.code === this.prepareCode(code) && item.target === params.target && item.action === params.action)) {
+    if (this.queue.find(item => {
+      return (!params.code || item.code === params.code) &&
+        item.target === params.target &&
+        item.action === params.action;
+    })) {
       console.log(`WAB: subscribe is exists!`);
+      return;
     }
 
-    this.queue.push({
-      code: this.prepareCode(code),
+    const newQueueItem = {
       target: params.target,
       action: params.action,
       params: {
         callback: params.callback,
       }
-    });
+    };
+
+    if (params.code) {
+      newQueueItem['code'] = params.code;
+    }
+
+    this.queue.push(newQueueItem);
   }
 
   /**
@@ -128,13 +141,13 @@ export class CommunicatorReceiver {
    * @param params
    */
   public unsubscribe = (params?: TReceiverUnsubscribeMessageParams): boolean => {
-    if (!params) {
+    if (!params || Object.keys(params).length === 0) {
       this.queue = [];
       return true;
     }
 
     const queueForRemove = this.queue.filter(item => {
-      return (!params.code || item.code === this.prepareCode(params.code)) &&
+      return (!params.code || item.code === params.code) &&
         (!params.target || item.target === params.target) &&
         (!params.action || item.action === params.action);
     });
@@ -147,5 +160,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/CommunicatorSender.ts

@@ -1,6 +1,5 @@
 import {TCommunicatorMessage, TSenderProps} from '../types';
-import {modifyOrigin} from './utils';
-import {CommunicatorTargetEnum_isCorrect} from '../enums/CommunicatorTargetEnum';
+import {isValidMessage, modifyOrigin} from './utils';
 
 export class CommunicatorSender {
   private readonly otherWindow: Window;
@@ -24,15 +23,8 @@ export class CommunicatorSender {
       return;
     }
 
-    if (!CommunicatorTargetEnum_isCorrect(message.target)) {
-      throw new Error(`WAC: Target "${message.target}" is not allowed!`);
-    }
-
-    if (
-      !this.receiverOrigin ||
-      !CommunicatorTargetEnum_isCorrect(message.target)
-    ) {
-      return;
+    if (!isValidMessage(message)) {
+      throw new Error(`WAC: Message not valid!`);
     }
 
     const jsonMessage = JSON.stringify(message);

package/src/engine/utils.ts

@@ -1,3 +1,10 @@
+import {TCommunicatorMessage} from "../types";
+import {CommunicatorTargetEnum_isCorrect} from "../enums/CommunicatorTargetEnum";
+import {CommunicatorActionEnum_isCorrect} from "../enums/CommunicatorActionEnum";
+
+/**
+ * @param address
+ */
 export function modifyOrigin(address: string): string {
   let url: URL;
   try {
@@ -9,3 +16,26 @@ export function modifyOrigin(address: string): string {
   }
   return url.origin;
 }
+
+/**
+ * Check the message for validity
+ * @param message
+ */
+export function isValidMessage(message: TCommunicatorMessage) {
+  const isValidTarget = message.target && CommunicatorTargetEnum_isCorrect(message.target);
+  const actions = message.action;
+  let isValidActions = typeof actions === 'object';
+
+  if (isValidTarget && isValidActions) {
+    for (const prop in actions) {
+      if(actions.hasOwnProperty(prop)) {
+        isValidActions = actions.hasOwnProperty(prop) && CommunicatorActionEnum_isCorrect(prop);
+        if (!isValidActions) {
+          break;
+        }
+      }
+    }
+  }
+
+  return isValidTarget && isValidActions;
+}

package/src/enums/CommunicatorActionEnum.ts

@@ -1,10 +1,15 @@
 export enum CommunicatorActionEnum {
+  TOKEN = 'token',
+  RESIZE = 'resize',
   CLOSE = 'close',
   OPEN = 'open',
   GOTO = 'goto',
-  RESIZE = 'resize',
 }
 
 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/receiver.ts

@@ -2,10 +2,12 @@ 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";
 
 export {
   CommunicatorReceiver,
   CommunicatorTargetEnum,
   CommunicatorActionEnum,
   types,
+  communicatorMessageIsValid
 }

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,6 +30,7 @@ export type TCommunicatorActionGotoParams = {
 }
 
 export type TCommunicatorSenderActionMap = {
+  [CommunicatorActionEnum.TOKEN]?: TCommunicatorActionTokenParams,
   [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams,
   [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams,
   [CommunicatorActionEnum.CLOSE]?: true,
@@ -35,6 +43,7 @@ export type TCommunicatorMessage = {
 }
 
 export type TReceiverSubscribeParams = {
+  code?: string;
   target: CommunicatorTargetEnum,
   action: CommunicatorActionEnum,
   callback: TReceiverCallback,
@@ -43,7 +52,7 @@ export type TReceiverSubscribeParams = {
 export type TReceiverMessageQueue = TReceiverMessageQueueItem[]
 
 export type TReceiverMessageQueueItem = {
-  code: string;
+  code?: string;
   target: CommunicatorTargetEnum,
   action: CommunicatorActionEnum,
   params?: {
@@ -56,3 +65,7 @@ export type TReceiverUnsubscribeMessageParams = {
   target?: CommunicatorTargetEnum,
   action?: CommunicatorActionEnum,
 }
+
+export type TReceiverTargetScenario = {
+  [key in CommunicatorTargetEnum]?: CommunicatorActionEnum[];
+}