@maxzima/wa-communicator 0.0.6 → 0.0.9

package/README.md

@@ -32,7 +32,7 @@ import {
 
 ```javascript
 const communicator = new CommunicatorSender({
-  targetOrigin: 'google.com',
+  receiverOrigin: 'google.com',
   otherWindow: window.parent,
 });
 
@@ -52,12 +52,22 @@ communicator.sendMessage({
 
 ```javascript
 const communicator = new CommunicatorReceiver({
-  callback: (message) => {
-    if (message.target === CommunicatorTargetEnum.SIGN_UP && message.action[CommunicatorActionEnum.GOTO]) {
-      window.location.href = message.action[CommunicatorActionEnum.GOTO].url;
-    }
-  }
+  senderOrigin: 'clients.google.com'
+});
+
+// subscribe
+communicator.follow('one', {
+  target: CommunicatorTargetEnum.SIGN_UP,
+  action: CommunicatorActionEnum.CLOSE,
+  callback: message => {
+    console.log('close', message);
+  },
+});
+
+// unsubscribe
+receiver.unfollow({
+  code: 'one',
+  action: CommunicatorActionEnum.CLOSE
 });
 
-communicator.watch();
 ```

package/dist/engine/CommunicatorReceiver.d.ts

@@ -1,7 +1,11 @@
-import { TReceiverProps } from '../types';
+import { TCommunicatorMessage, TReceiverProps, TReceiverSubscribeParams, TReceiverUnsubscribeMessageParams } from '../types';
 export declare class CommunicatorReceiver {
-    private readonly callback;
+    private readonly senderOrigin;
+    private queue;
     constructor(props: TReceiverProps);
-    watch(): void;
     private onMessage;
+    private prepareCode;
+    isValidMessage: (message: TCommunicatorMessage) => boolean;
+    subscribe: (code: string, params: TReceiverSubscribeParams) => void;
+    unsubscribe: (params?: TReceiverUnsubscribeMessageParams) => boolean;
 }

package/dist/engine/CommunicatorReceiver.js

@@ -1,5 +1,9 @@
+import { modifyOrigin } from "./utils";
+import { CommunicatorTargetEnum_isCorrect } from '../enums/CommunicatorTargetEnum';
+import { CommunicatorActionEnum_isCorrect } from '../enums/CommunicatorActionEnum';
 export class CommunicatorReceiver {
     constructor(props) {
+        this.queue = [];
         this.onMessage = (event) => {
             if (!event || !event.origin || !event.data) {
                 return;
@@ -12,17 +16,83 @@ export class CommunicatorReceiver {
                 console.log('PostMessage read error');
                 return;
             }
-            if (window.origin !== event.origin) {
+            if (this.senderOrigin !== event.origin) {
                 return;
             }
-            if (typeof this.callback !== 'function') {
+            if (!this.isValidMessage(message)) {
                 return;
             }
-            this.callback(message);
+            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);
+                    }
+                });
+            }
         };
-        this.callback = props.callback;
-    }
-    watch() {
-        window.addEventListener('message', this.onMessage, false);
+        this.prepareCode = (code) => {
+            if (typeof code === 'string' || code === "") {
+                throw new Error('WAC: code is not valid!');
+            }
+            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)) {
+                console.log(`WAB: subscribe is exists!`);
+            }
+            this.queue.push({
+                code: this.prepareCode(code),
+                target: params.target,
+                action: params.action,
+                params: {
+                    callback: params.callback,
+                }
+            });
+        };
+        this.unsubscribe = (params) => {
+            if (!params) {
+                this.queue = [];
+                return true;
+            }
+            const queueForRemove = this.queue.filter(item => {
+                return (!params.code || item.code === this.prepareCode(params.code)) &&
+                    (!params.target || item.target === params.target) &&
+                    (!params.action || item.action === params.action);
+            });
+            if (queueForRemove.length) {
+                const toRemove = new Set(queueForRemove);
+                this.queue = this.queue.filter(x => !toRemove.has(x));
+                return true;
+            }
+            return false;
+        };
+        this.senderOrigin = modifyOrigin(props.senderOrigin);
+        if (this.senderOrigin) {
+            window.addEventListener('message', this.onMessage, false);
+        }
+        else {
+            throw new Error('WAC: senderOrigin is broken!');
+        }
     }
 }

package/dist/engine/CommunicatorSender.d.ts

@@ -1,7 +1,7 @@
 import { TCommunicatorMessage, TSenderProps } from '../types';
 export declare class CommunicatorSender {
     private readonly otherWindow;
-    private readonly targetOrigin;
+    private readonly receiverOrigin;
     constructor(props: TSenderProps);
     sendMessage(message: TCommunicatorMessage): void;
 }

package/dist/engine/CommunicatorSender.js

@@ -1,16 +1,25 @@
-import { modifyUrl } from './utils';
+import { modifyOrigin } from './utils';
 import { CommunicatorTargetEnum_isCorrect } from '../enums/CommunicatorTargetEnum';
 export class CommunicatorSender {
     constructor(props) {
         this.otherWindow = props.otherWindow;
-        this.targetOrigin = modifyUrl(props.targetOrigin);
+        this.receiverOrigin = modifyOrigin(props.receiverOrigin);
+        if (!this.receiverOrigin) {
+            throw new Error('WAC: receiverOrigin is broken!');
+        }
     }
     sendMessage(message) {
-        if (!this.targetOrigin ||
+        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;
         }
         const jsonMessage = JSON.stringify(message);
-        this.otherWindow.postMessage(jsonMessage, this.targetOrigin);
+        this.otherWindow.postMessage(jsonMessage, this.receiverOrigin);
     }
 }

package/dist/engine/utils.d.ts

@@ -1 +1 @@
-export declare function modifyUrl(address: string): string;
+export declare function modifyOrigin(address: string): string;

package/dist/engine/utils.js

@@ -1,4 +1,4 @@
-export function modifyUrl(address) {
+export function modifyOrigin(address) {
     let url;
     try {
         let targetOrigin = address.trim();
@@ -8,5 +8,5 @@ export function modifyUrl(address) {
     catch (_) {
         return null;
     }
-    return url.toString();
+    return url.origin;
 }

package/dist/types/index.d.ts

@@ -1,11 +1,11 @@
 import { CommunicatorActionEnum } from "../enums/CommunicatorActionEnum";
 import { CommunicatorTargetEnum } from "../enums/CommunicatorTargetEnum";
 export declare type TSenderProps = {
-    targetOrigin: string;
+    receiverOrigin: string;
     otherWindow: Window;
 };
 export declare type TReceiverProps = {
-    callback: TReceiverCallback;
+    senderOrigin: string;
 };
 export declare type TReceiverCallback = (message: TCommunicatorMessage) => void;
 export declare type TCommunicatorActionResizeParams = {
@@ -26,3 +26,22 @@ export declare type TCommunicatorMessage = {
     target: CommunicatorTargetEnum;
     action: TCommunicatorSenderActionMap;
 };
+export declare type TReceiverSubscribeParams = {
+    target: CommunicatorTargetEnum;
+    action: CommunicatorActionEnum;
+    callback: TReceiverCallback;
+};
+export declare type TReceiverMessageQueue = TReceiverMessageQueueItem[];
+export declare type TReceiverMessageQueueItem = {
+    code: string;
+    target: CommunicatorTargetEnum;
+    action: CommunicatorActionEnum;
+    params?: {
+        callback: TReceiverCallback;
+    };
+};
+export declare type TReceiverUnsubscribeMessageParams = {
+    code?: string;
+    target?: CommunicatorTargetEnum;
+    action?: CommunicatorActionEnum;
+};

package/package.json

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

package/src/engine/CommunicatorReceiver.ts

@@ -1,17 +1,27 @@
-import {TCommunicatorMessage, TReceiverCallback, TReceiverProps} from '../types';
+import {
+  TCommunicatorMessage,
+  TReceiverMessageQueue,
+  TReceiverProps,
+  TReceiverSubscribeParams,
+  TReceiverUnsubscribeMessageParams,
+} from '../types';
+import {modifyOrigin} from "./utils";
+import {CommunicatorTargetEnum_isCorrect} from '../enums/CommunicatorTargetEnum';
+import {CommunicatorActionEnum_isCorrect} from '../enums/CommunicatorActionEnum';
 
 export class CommunicatorReceiver {
-  private readonly callback: TReceiverCallback;
+  private readonly senderOrigin: string;
+  private queue: TReceiverMessageQueue = [];
 
   constructor(props: TReceiverProps) {
-    this.callback = props.callback;
-  }
+    this.senderOrigin = modifyOrigin(props.senderOrigin);
 
-  /**
-   * Watch Messages
-   */
-  public watch() {
-    window.addEventListener('message', this.onMessage, false);
+    if (this.senderOrigin) {
+      // Watch Messages
+      window.addEventListener('message', this.onMessage, false);
+    } else {
+      throw new Error('WAC: senderOrigin is broken!');
+    }
   }
 
   /**
@@ -32,15 +42,110 @@ export class CommunicatorReceiver {
       return;
     }
 
-    if (window.origin !== event.origin) {
+    if (this.senderOrigin !== event.origin) {
       return;
     }
 
-    if (typeof this.callback !== 'function') {
+    if (!this.isValidMessage(message)) {
       return;
     }
 
-    this.callback(message);
+    // 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);
+        }
+      })
+    }
   };
+
+  /**
+   * 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;
+          }
+        }
+      }
+    }
+
+    return isValidTarget && isValidActions;
+  }
+
+  /**
+   * Subscribe by target and action
+   * @param code
+   * @param params
+   */
+  public subscribe = (code: string, params: TReceiverSubscribeParams): void => {
+    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)) {
+      console.log(`WAB: subscribe is exists!`);
+    }
+
+    this.queue.push({
+      code: this.prepareCode(code),
+      target: params.target,
+      action: params.action,
+      params: {
+        callback: params.callback,
+      }
+    });
+  }
+
+  /**
+   * Subscribe by code or target or action
+   * @param params
+   */
+  public unsubscribe = (params?: TReceiverUnsubscribeMessageParams): boolean => {
+    if (!params) {
+      this.queue = [];
+      return true;
+    }
+
+    const queueForRemove = this.queue.filter(item => {
+      return (!params.code || item.code === this.prepareCode(params.code)) &&
+        (!params.target || item.target === params.target) &&
+        (!params.action || item.action === params.action);
+    });
+
+    if (queueForRemove.length) {
+      const toRemove = new Set(queueForRemove);
+      this.queue = this.queue.filter(x => !toRemove.has(x));
+      return true;
+    }
+
+    return false;
+  }
 }
 

package/src/engine/CommunicatorSender.ts

@@ -1,14 +1,18 @@
 import {TCommunicatorMessage, TSenderProps} from '../types';
-import {modifyUrl} from './utils';
+import {modifyOrigin} from './utils';
 import {CommunicatorTargetEnum_isCorrect} from '../enums/CommunicatorTargetEnum';
 
 export class CommunicatorSender {
   private readonly otherWindow: Window;
-  private readonly targetOrigin: string;
+  private readonly receiverOrigin: string;
 
   constructor(props: TSenderProps) {
     this.otherWindow = props.otherWindow;
-    this.targetOrigin = modifyUrl(props.targetOrigin);
+    this.receiverOrigin = modifyOrigin(props.receiverOrigin);
+
+    if (!this.receiverOrigin) {
+      throw new Error('WAC: receiverOrigin is broken!');
+    }
   }
 
   /**
@@ -16,15 +20,23 @@ export class CommunicatorSender {
    * @param message
    */
   public sendMessage(message: TCommunicatorMessage) {
+    if (!this.receiverOrigin) {
+      return;
+    }
+
+    if (!CommunicatorTargetEnum_isCorrect(message.target)) {
+      throw new Error(`WAC: Target "${message.target}" is not allowed!`);
+    }
+
     if (
-      !this.targetOrigin ||
+      !this.receiverOrigin ||
       !CommunicatorTargetEnum_isCorrect(message.target)
     ) {
       return;
     }
 
     const jsonMessage = JSON.stringify(message);
-    this.otherWindow.postMessage(jsonMessage, this.targetOrigin);
+    this.otherWindow.postMessage(jsonMessage, this.receiverOrigin);
   }
 }
 

package/src/engine/utils.ts

@@ -1,4 +1,4 @@
-export function modifyUrl(address: string): string {
+export function modifyOrigin(address: string): string {
   let url: URL;
   try {
     let targetOrigin = address.trim();
@@ -7,5 +7,5 @@ export function modifyUrl(address: string): string {
   } catch (_) {
     return null;
   }
-  return url.toString();
+  return url.origin;
 }

package/src/types/index.ts

@@ -2,12 +2,12 @@ import {CommunicatorActionEnum} from "../enums/CommunicatorActionEnum";
 import {CommunicatorTargetEnum} from "../enums/CommunicatorTargetEnum";
 
 export type TSenderProps = {
-  targetOrigin: string,
+  receiverOrigin: string,
   otherWindow: Window,
 }
 
 export type TReceiverProps = {
-  callback: TReceiverCallback,
+  senderOrigin: string,
 }
 
 export type TReceiverCallback = (message: TCommunicatorMessage) => void;
@@ -33,3 +33,26 @@ export type TCommunicatorMessage = {
   target: CommunicatorTargetEnum,
   action: TCommunicatorSenderActionMap
 }
+
+export type TReceiverSubscribeParams = {
+  target: CommunicatorTargetEnum,
+  action: CommunicatorActionEnum,
+  callback: TReceiverCallback,
+}
+
+export type TReceiverMessageQueue = TReceiverMessageQueueItem[]
+
+export type TReceiverMessageQueueItem = {
+  code: string;
+  target: CommunicatorTargetEnum,
+  action: CommunicatorActionEnum,
+  params?: {
+    callback: TReceiverCallback,
+  }
+}
+
+export type TReceiverUnsubscribeMessageParams = {
+  code?: string;
+  target?: CommunicatorTargetEnum,
+  action?: CommunicatorActionEnum,
+}

package/tsconfig.json

@@ -16,7 +16,7 @@
     "outDir": "dist",
     "alwaysStrict": true,
     "removeComments": true,
-    "noImplicitReturns": true,
+    "noImplicitReturns": false,
     "noEmit": false,
     "noFallthroughCasesInSwitch": true,
     "noUnusedLocals": true,