@maxzima/wa-communicator 0.0.2 → 0.0.7

package/README.md

@@ -1,36 +1,61 @@
-# Sender
+# Import communicator modules
+
+Import all 
+```javascript
+import {
+   CommunicatorReceiver,
+   CommunicatorSender,
+   CommunicatorTargetEnum,
+   CommunicatorActionEnum,
+} from '@maxzima/wa-communicator';
+```
+
+Import only sender
+```javascript
+import {
+   CommunicatorSender,
+   CommunicatorTargetEnum,
+   CommunicatorActionEnum,
+} from '@maxzima/wa-communicator/dit/sender';
+```
+
+Import only receiver
+```javascript
+import {
+   CommunicatorReceiver,
+   CommunicatorTargetEnum,
+   CommunicatorActionEnum,
+} from '@maxzima/wa-communicator';
+```
+
+# Usage Sender
 
 ```javascript
 const communicator = new CommunicatorSender({
-  targetOrigin: 'google.com',
+  receiverOrigin: 'google.com',
   otherWindow: window.parent,
 });
 
 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
+    },
+  }
 });
 ```
 
-# Receiver
+# Usage Receiver
 
 ```javascript
 const communicator = new CommunicatorReceiver({
+  senderOrigin: 'clients.google.com',
   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/config/tsconfig.esm.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig",
+  "compilerOptions": {
+    "module": "ESNext",
+    "outDir": "../dist",
+  },
+  "exclude": [
+    "../src/types/index.ts",
+  ]
+}

package/config/tsconfig.types.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig",
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "../dist"
+  }
+}

package/dist/engine/CommunicatorReceiver.d.ts

@@ -0,0 +1,8 @@
+import { TReceiverProps } from '../types';
+export declare class CommunicatorReceiver {
+    private readonly callback;
+    private readonly senderOrigin;
+    constructor(props: TReceiverProps);
+    watch(): void;
+    private onMessage;
+}

package/dist/engine/CommunicatorReceiver.js

@@ -0,0 +1,29 @@
+export class CommunicatorReceiver {
+    constructor(props) {
+        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 (this.senderOrigin !== event.origin) {
+                return;
+            }
+            if (typeof this.callback !== 'function') {
+                return;
+            }
+            this.callback(message);
+        };
+        this.callback = props.callback;
+        this.senderOrigin = props.senderOrigin;
+    }
+    watch() {
+        window.addEventListener('message', this.onMessage, false);
+    }
+}

package/dist/engine/CommunicatorSender.d.ts

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

package/dist/engine/CommunicatorSender.js

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

package/dist/engine/utils.d.ts

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

package/dist/engine/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/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/receiver.d.ts

@@ -0,0 +1,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, };

package/dist/receiver.js

@@ -0,0 +1,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, };

package/dist/sender.d.ts

@@ -0,0 +1,5 @@
+import { CommunicatorSender } from "./engine/CommunicatorSender";
+import { CommunicatorTargetEnum } from "./enums/CommunicatorTargetEnum";
+import { CommunicatorActionEnum } from "./enums/CommunicatorActionEnum";
+import * as types from "./types";
+export { CommunicatorSender, CommunicatorTargetEnum, CommunicatorActionEnum, types, };

package/dist/sender.js

@@ -0,0 +1,5 @@
+import { CommunicatorSender } from "./engine/CommunicatorSender";
+import { CommunicatorTargetEnum } from "./enums/CommunicatorTargetEnum";
+import { CommunicatorActionEnum } from "./enums/CommunicatorActionEnum";
+import * as types from "./types";
+export { CommunicatorSender, CommunicatorTargetEnum, CommunicatorActionEnum, types, };

package/dist/types/index.d.ts

@@ -0,0 +1,29 @@
+import { CommunicatorActionEnum } from "../enums/CommunicatorActionEnum";
+import { CommunicatorTargetEnum } from "../enums/CommunicatorTargetEnum";
+export declare type TSenderProps = {
+    receiverOrigin: string;
+    otherWindow: Window;
+};
+export declare type TReceiverProps = {
+    callback: TReceiverCallback;
+    senderOrigin: string;
+};
+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/index.js

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

package/package.json

@@ -1,19 +1,28 @@
 {
-  "version": "0.0.2",
+  "version": "0.0.7",
   "name": "@maxzima/wa-communicator",
   "description": "",
   "author": "Noname",
   "license": "MIT",
   "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "dist/index.d.js",
   "engines": {
     "node": ">=14"
   },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
   "scripts": {
-    "postinstall": "npm run build",
-    "build": "tsc --project tsconfig.json"
+    "prepublishOnly": "npm run build",
+    "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"
   },
   "devDependencies": {
+    "npm-run-all": "^4.1.5",
     "typescript": "^4.7.4"
   }
 }

package/src/engine/CommunicatorReceiver.ts

@@ -1,24 +1,26 @@
-import {TCommunicatorMessage, TReceiverProps} from '../types';
+import {TCommunicatorMessage, TReceiverCallback, TReceiverProps} from '../types';
 
 export class CommunicatorReceiver {
-  private readonly callback: any;
+  private readonly callback: TReceiverCallback;
+  private readonly senderOrigin: string;
 
   constructor(props: TReceiverProps) {
     this.callback = props.callback;
+    this.senderOrigin = props.senderOrigin;
   }
 
   /**
    * 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;
     }
@@ -32,14 +34,10 @@ export class CommunicatorReceiver {
       return;
     }
 
-    if (window.origin !== event.origin) {
+    if (this.senderOrigin !== event.origin) {
       return;
     }
 
-    if (!Array.isArray(message.action)) {
-      message.action = [message.action];
-    }
-
     if (typeof this.callback !== 'function') {
       return;
     }

package/src/engine/CommunicatorSender.ts

@@ -1,26 +1,30 @@
 import {TCommunicatorMessage, TSenderProps} from '../types';
-import {modifyUrl} from '../utils';
-import {CommunicatorTargetEnum} from '../enums/CommunicatorTargetEnum';
+import {modifyUrl} 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 = modifyUrl(props.receiverOrigin);
   }
 
+  /**
+   * Send PostMessage
+   * @param message
+   */
   public sendMessage(message: TCommunicatorMessage) {
     if (
-      !this.targetOrigin ||
-      !CommunicatorTargetEnum.isCorrect(message.target)
+      !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/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/receiver.ts

@@ -0,0 +1,11 @@
+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,
+}

package/src/sender.ts

@@ -0,0 +1,11 @@
+import {CommunicatorSender} from "./engine/CommunicatorSender"
+import {CommunicatorTargetEnum} from "./enums/CommunicatorTargetEnum"
+import {CommunicatorActionEnum} from "./enums/CommunicatorActionEnum"
+import * as types from "./types";
+
+export {
+  CommunicatorSender,
+  CommunicatorTargetEnum,
+  CommunicatorActionEnum,
+  types,
+}

package/src/types/index.ts

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

package/tools/cleanup.js

@@ -0,0 +1,26 @@
+/* eslint-disable */
+const fs = require('fs')
+const Path = require('path')
+/* eslint-enable */
+
+const deleteFolderRecursive = (path) => {
+  if (fs.existsSync(path)) {
+    fs.readdirSync(path).forEach((file) => {
+      const curPath = Path.join(path, file)
+      if (fs.lstatSync(curPath).isDirectory()) {
+        deleteFolderRecursive(curPath)
+      } else {
+        fs.unlinkSync(curPath)
+      }
+    })
+    fs.rmdirSync(path)
+  }
+}
+
+const folder = process.argv.slice(2)[0]
+
+if (folder) {
+  deleteFolderRecursive(Path.join(__dirname, '../dist', folder))
+} else {
+  deleteFolderRecursive(Path.join(__dirname, '../dist'))
+}

package/tsconfig.json

@@ -7,17 +7,15 @@
       "ESNext"
     ],
     "target": "ES6",
-    "module": "esnext",
     "moduleResolution": "node",
     "strictNullChecks": false,
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "baseUrl": "./src",
+    "baseUrl": "./",
     "outDir": "dist",
-    "declaration": true,
     "alwaysStrict": true,
-    "removeComments": false,
+    "removeComments": true,
     "noImplicitReturns": true,
     "noEmit": false,
     "noFallthroughCasesInSwitch": true,
@@ -25,13 +23,10 @@
     "noUnusedParameters": true,
     "importHelpers": true,
     "sourceMap": false,
-    "typeRoots": [
-      "./node_modules/@types",
-      "./src/types"
-    ],
   },
   "exclude": [
     "dist",
     "node_modules",
-  ]
+  ],
+  "include": ["src/**/*"]
 }

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

package/src/types.ts

@@ -1,43 +0,0 @@
-export type TSenderProps = {
-  targetOrigin: string,
-  otherWindow: Window,
-}
-
-export type TReceiverProps = {
-  callback: (message: TCommunicatorMessageReceiver) => void,
-}
-
-export type TCommunicatorTargetKey = 'sign_up' | 'sign_in';
-export type TCommunicatorActionKey = keyof TCommunicatorSenderActionMap;
-
-export type TCommunicatorActionResizeParams = {
-  width?: number,
-  height?: number,
-}
-
-export type TCommunicatorActionGotoParams = {
-  url: string,
-  isTargetBlank?: boolean,
-}
-
-export type TCommunicatorSenderActionMap = {
-  'resize': TCommunicatorActionResizeParams,
-  'goto': TCommunicatorActionGotoParams,
-  'close': null,
-  'open': TCommunicatorTargetKey,
-}
-
-export type TCommunicatorMessage = {
-  target: TCommunicatorTargetKey,
-  action: TCommunicatorActionItem | TCommunicatorActionItem[]
-}
-
-export type TCommunicatorMessageReceiver = {
-  target: TCommunicatorTargetKey,
-  action: TCommunicatorActionItem[]
-}
-
-export type TCommunicatorActionItem = {
-  key: TCommunicatorActionKey,
-  params?: TCommunicatorSenderActionMap[TCommunicatorActionKey]
-};