@maxzima/wa-communicator 0.0.2 → 0.0.5

package/README.md

@@ -7,16 +7,14 @@ const communicator = new CommunicatorSender({
 });
 
 communicator.sendMessage({
-  target: 'sign_up',
-  action: [
-    {
-      key: 'goto',
-      params: {
-        url: 'clients.google.com',
-        isTargetBlank: true
-      }
-    }
-  ]
+  target: CommunicatorTargetEnum.SIGN_UP,
+  action: {
+    [CommunicatorActionEnum.CLOSE]: true,
+    [CommunicatorActionEnum.GOTO]: {
+      url: 'clients.google.com',
+      isTargetBlank: true
+    },
+  }
 });
 ```
 
@@ -25,12 +23,8 @@ communicator.sendMessage({
 ```javascript
 const communicator = new CommunicatorReceiver({
   callback: (message) => {
-    if (message.target === 'sign_up' && message.action.length) {
-      message.action.forEach((action) => {
-        if (action.key === CommunicatorActionEnum.GOTO) {
-          window.location = action.params['url'];
-        }
-      })
+    if (message.target === CommunicatorTargetEnum.SIGN_UP && message.action[CommunicatorActionEnum.GOTO]) {
+      window.location.href = message.action[CommunicatorActionEnum.GOTO].url;
     }
   }
 });

package/dist/engine/CommunicatorReceiver.d.ts

@@ -0,0 +1,14 @@
+import { TReceiverProps } from '../types';
+export declare class CommunicatorReceiver {
+    private readonly callback;
+    constructor(props: TReceiverProps);
+    /**
+     * Watch Messages
+     */
+    watch(): void;
+    /**
+     * Message Receive Callback
+     * @param event
+     */
+    private onMessage;
+}

package/dist/engine/CommunicatorReceiver.js

@@ -0,0 +1,35 @@
+export class CommunicatorReceiver {
+    constructor(props) {
+        /**
+         * Message Receive Callback
+         * @param event
+         */
+        this.onMessage = (event) => {
+            if (!event || !event.origin || !event.data) {
+                return;
+            }
+            let message;
+            try {
+                message = JSON.parse(event.data);
+            }
+            catch (error) {
+                console.log('PostMessage read error');
+                return;
+            }
+            if (window.origin !== event.origin) {
+                return;
+            }
+            if (typeof this.callback !== 'function') {
+                return;
+            }
+            this.callback(message);
+        };
+        this.callback = props.callback;
+    }
+    /**
+     * Watch Messages
+     */
+    watch() {
+        window.addEventListener('message', this.onMessage, false);
+    }
+}

package/dist/engine/CommunicatorSender.d.ts

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

package/dist/engine/CommunicatorSender.js

@@ -0,0 +1,20 @@
+import { modifyUrl } from '../utils';
+import { CommunicatorTargetEnum_isCorrect } from '../enums/CommunicatorTargetEnum';
+export class CommunicatorSender {
+    constructor(props) {
+        this.otherWindow = props.otherWindow;
+        this.targetOrigin = modifyUrl(props.targetOrigin);
+    }
+    /**
+     * Send PostMessage
+     * @param message
+     */
+    sendMessage(message) {
+        if (!this.targetOrigin ||
+            !CommunicatorTargetEnum_isCorrect(message.target)) {
+            return;
+        }
+        const jsonMessage = JSON.stringify(message);
+        this.otherWindow.postMessage(jsonMessage, this.targetOrigin);
+    }
+}

package/dist/enums/BaseEnum.d.ts

@@ -0,0 +1,8 @@
+export default abstract class BaseEnum {
+    static array: string[];
+    static isCorrect(value: string): boolean;
+    /**
+     * Gets array of all possible values
+     */
+    static getAsArray(): string[];
+}

package/dist/enums/BaseEnum.js

@@ -0,0 +1,31 @@
+export default class BaseEnum {
+    static isCorrect(value) {
+        return value && value.trim() && this.getAsArray().indexOf(value) !== -1;
+    }
+    /**
+     * Gets array of all possible values
+     */
+    static getAsArray() {
+        if (!this.array) {
+            let props = Object.getOwnPropertyNames(this);
+            let obj = Object.getPrototypeOf(this);
+            this.array = [];
+            while (Object.prototype.isPrototypeOf.call(BaseEnum, obj)) {
+                props = [...props, ...Object.getOwnPropertyNames(obj)];
+                obj = Object.getPrototypeOf(obj);
+            }
+            for (const prop of props) {
+                if (['caller', 'arguments', 'name', 'length', 'prototype'].indexOf(prop) !== -1) {
+                    continue;
+                }
+                const self = this;
+                const propValue = self[prop];
+                if (typeof propValue === 'string' && prop.indexOf('CONTEXT') === -1) {
+                    this.array.push(propValue);
+                }
+            }
+        }
+        return this.array;
+    }
+}
+BaseEnum.array = null;

package/dist/enums/CommunicatorActionEnum.d.ts

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

package/dist/enums/CommunicatorActionEnum.js

@@ -0,0 +1,10 @@
+export var CommunicatorActionEnum;
+(function (CommunicatorActionEnum) {
+    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);
+}

package/dist/enums/CommunicatorTargetEnum.d.ts

@@ -0,0 +1,5 @@
+export declare enum CommunicatorTargetEnum {
+    SIGN_UP = "sign_up",
+    SIGN_IN = "sign_in"
+}
+export declare function CommunicatorTargetEnum_isCorrect(item: string): boolean;

package/dist/enums/CommunicatorTargetEnum.js

@@ -0,0 +1,8 @@
+export var CommunicatorTargetEnum;
+(function (CommunicatorTargetEnum) {
+    CommunicatorTargetEnum["SIGN_UP"] = "sign_up";
+    CommunicatorTargetEnum["SIGN_IN"] = "sign_in";
+})(CommunicatorTargetEnum || (CommunicatorTargetEnum = {}));
+export function CommunicatorTargetEnum_isCorrect(item) {
+    return Object.values(CommunicatorTargetEnum).includes(item);
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+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 { CommunicatorReceiver, CommunicatorSender, CommunicatorTargetEnum, CommunicatorActionEnum, types, };

package/dist/index.js

@@ -0,0 +1,6 @@
+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 { CommunicatorReceiver, CommunicatorSender, CommunicatorTargetEnum, CommunicatorActionEnum, types, };

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+import { CommunicatorActionEnum } from "./enums/CommunicatorActionEnum";
+import { CommunicatorTargetEnum } from "./enums/CommunicatorTargetEnum";
+export declare type TSenderProps = {
+    targetOrigin: string;
+    otherWindow: Window;
+};
+export declare type TReceiverProps = {
+    callback: TReceiverCallback;
+};
+export declare type TReceiverCallback = (message: TCommunicatorMessage) => void;
+export declare type TCommunicatorActionResizeParams = {
+    width?: number;
+    height?: number;
+};
+export declare type TCommunicatorActionGotoParams = {
+    url: string;
+    isTargetBlank?: boolean;
+};
+export declare type TCommunicatorSenderActionMap = {
+    [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams;
+    [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams;
+    [CommunicatorActionEnum.CLOSE]?: true;
+    [CommunicatorActionEnum.OPEN]?: CommunicatorTargetEnum;
+};
+export declare type TCommunicatorMessage = {
+    target: CommunicatorTargetEnum;
+    action: TCommunicatorSenderActionMap;
+};

package/dist/types.js

@@ -0,0 +1 @@
+import { CommunicatorActionEnum } from "./enums/CommunicatorActionEnum";

package/dist/utils.d.ts

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

package/dist/utils.js

@@ -0,0 +1,12 @@
+export function modifyUrl(address) {
+    let url;
+    try {
+        let targetOrigin = address.trim();
+        targetOrigin = (targetOrigin.indexOf('://') === -1) ? 'https://' + targetOrigin : targetOrigin;
+        url = new URL(targetOrigin);
+    }
+    catch (_) {
+        return null;
+    }
+    return url.toString();
+}

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.2",
+  "version": "0.0.5",
   "name": "@maxzima/wa-communicator",
   "description": "",
   "author": "Noname",
@@ -10,6 +10,7 @@
     "node": ">=14"
   },
   "scripts": {
+    "prepublish": "rm -rf dist",
     "postinstall": "npm run build",
     "build": "tsc --project tsconfig.json"
   },

package/src/engine/CommunicatorReceiver.ts

@@ -1,7 +1,7 @@
-import {TCommunicatorMessage, TReceiverProps} from '../types';
+import {TCommunicatorMessage, TReceiverCallback, TReceiverProps} from '../types';
 
 export class CommunicatorReceiver {
-  private readonly callback: any;
+  private readonly callback: TReceiverCallback;
 
   constructor(props: TReceiverProps) {
     this.callback = props.callback;
@@ -11,14 +11,14 @@ export class CommunicatorReceiver {
    * Watch Messages
    */
   public watch() {
-    window.addEventListener('message', this.onMessageReceive, false);
+    window.addEventListener('message', this.onMessage, false);
   }
 
   /**
-   *
+   * Message Receive Callback
    * @param event
    */
-  private onMessageReceive = (event: MessageEvent) => {
+  private onMessage = (event: MessageEvent) => {
     if (!event || !event.origin || !event.data) {
       return;
     }
@@ -36,10 +36,6 @@ export class CommunicatorReceiver {
       return;
     }
 
-    if (!Array.isArray(message.action)) {
-      message.action = [message.action];
-    }
-
     if (typeof this.callback !== 'function') {
       return;
     }

package/src/engine/CommunicatorSender.ts

@@ -1,6 +1,6 @@
 import {TCommunicatorMessage, TSenderProps} from '../types';
 import {modifyUrl} from '../utils';
-import {CommunicatorTargetEnum} from '../enums/CommunicatorTargetEnum';
+import {CommunicatorTargetEnum_isCorrect} from '../enums/CommunicatorTargetEnum';
 
 export class CommunicatorSender {
   private readonly otherWindow: Window;
@@ -11,10 +11,14 @@ export class CommunicatorSender {
     this.targetOrigin = modifyUrl(props.targetOrigin);
   }
 
+  /**
+   * Send PostMessage
+   * @param message
+   */
   public sendMessage(message: TCommunicatorMessage) {
     if (
       !this.targetOrigin ||
-      !CommunicatorTargetEnum.isCorrect(message.target)
+      !CommunicatorTargetEnum_isCorrect(message.target)
     ) {
       return;
     }

package/src/enums/CommunicatorActionEnum.ts

@@ -1,9 +1,10 @@
-import {TCommunicatorActionKey} from '../types';
-import BaseEnum from './BaseEnum';
+export enum CommunicatorActionEnum {
+  CLOSE = 'close',
+  OPEN = 'open',
+  GOTO = 'goto',
+  RESIZE = 'resize',
+}
 
-export class CommunicatorActionEnum extends BaseEnum {
-  public static CLOSE: TCommunicatorActionKey = 'close';
-  public static OPEN: TCommunicatorActionKey = 'open';
-  public static GOTO: TCommunicatorActionKey = 'goto';
-  public static RESIZE: TCommunicatorActionKey = 'resize';
+export function CommunicatorActionEnum_isCorrect(item: string): boolean {
+  return Object.values(CommunicatorActionEnum).includes(item as CommunicatorActionEnum);
 }

package/src/enums/CommunicatorTargetEnum.ts

@@ -1,7 +1,8 @@
-import {TCommunicatorTargetKey} from '../types';
-import BaseEnum from './BaseEnum';
+export enum CommunicatorTargetEnum {
+  SIGN_UP = 'sign_up',
+  SIGN_IN = 'sign_in',
+}
 
-export class CommunicatorTargetEnum extends BaseEnum {
-  public static SIGN_UP: TCommunicatorTargetKey = 'sign_up';
-  public static SIGN_IN: TCommunicatorTargetKey = 'sign_in';
+export function CommunicatorTargetEnum_isCorrect(item: string): boolean {
+  return Object.values(CommunicatorTargetEnum).includes(item as CommunicatorTargetEnum);
 }

package/src/types.ts

@@ -1,14 +1,16 @@
+import {CommunicatorActionEnum} from "./enums/CommunicatorActionEnum";
+import {CommunicatorTargetEnum} from "./enums/CommunicatorTargetEnum";
+
 export type TSenderProps = {
   targetOrigin: string,
   otherWindow: Window,
 }
 
 export type TReceiverProps = {
-  callback: (message: TCommunicatorMessageReceiver) => void,
+  callback: TReceiverCallback,
 }
 
-export type TCommunicatorTargetKey = 'sign_up' | 'sign_in';
-export type TCommunicatorActionKey = keyof TCommunicatorSenderActionMap;
+export type TReceiverCallback = (message: TCommunicatorMessage) => void;
 
 export type TCommunicatorActionResizeParams = {
   width?: number,
@@ -21,23 +23,13 @@ export type TCommunicatorActionGotoParams = {
 }
 
 export type TCommunicatorSenderActionMap = {
-  'resize': TCommunicatorActionResizeParams,
-  'goto': TCommunicatorActionGotoParams,
-  'close': null,
-  'open': TCommunicatorTargetKey,
+  [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams,
+  [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams,
+  [CommunicatorActionEnum.CLOSE]?: true,
+  [CommunicatorActionEnum.OPEN]?: CommunicatorTargetEnum,
 }
 
 export type TCommunicatorMessage = {
-  target: TCommunicatorTargetKey,
-  action: TCommunicatorActionItem | TCommunicatorActionItem[]
-}
-
-export type TCommunicatorMessageReceiver = {
-  target: TCommunicatorTargetKey,
-  action: TCommunicatorActionItem[]
+  target: CommunicatorTargetEnum,
+  action: TCommunicatorSenderActionMap
 }
-
-export type TCommunicatorActionItem = {
-  key: TCommunicatorActionKey,
-  params?: TCommunicatorSenderActionMap[TCommunicatorActionKey]
-};

package/src/enums/BaseEnum.ts

@@ -1,36 +0,0 @@
-export default abstract class BaseEnum {
-  public static array: string[] = null;
-
-  public static isCorrect(value: string): boolean {
-    return value && value.trim() && this.getAsArray().indexOf(value) !== -1;
-  }
-
-  /**
-   * Gets array of all possible values
-   */
-  public static getAsArray(): string[] {
-    if (!this.array) {
-      let props = Object.getOwnPropertyNames(this);
-      let obj = Object.getPrototypeOf(this);
-
-      this.array = [];
-
-      while (Object.prototype.isPrototypeOf.call(BaseEnum, obj)) {
-        props = [...props, ...Object.getOwnPropertyNames(obj)];
-        obj = Object.getPrototypeOf(obj);
-      }
-
-      for (const prop of props) {
-        if (['caller', 'arguments', 'name', 'length', 'prototype'].indexOf(prop) !== -1) {
-          continue;
-        }
-        const self = this as {[index: string]: any};
-        const propValue = self[prop];
-        if (typeof propValue === 'string' && prop.indexOf('CONTEXT') === -1) {
-          this.array.push(propValue);
-        }
-      }
-    }
-    return this.array;
-  }
-}