@maxzima/wa-communicator 0.0.16 → 1.0.2

package/src/types/TCommunicator.ts

@@ -0,0 +1,179 @@
+type TChallenge = 'email_otp' | 'mobile_otp' | 'pin';
+type TAuditSource = 'Backend' | 'SelfService';
+type TRegistrationRequestBodySourceDeviceType = 'mobile' | 'regular';
+
+type TRequestProps = {
+  url?: string,
+  method?: RequestInit['method'],
+  body?: any,
+  headers?: HeadersInit,
+  mode?: RequestMode,
+  queryParams?: TRequestQueryParams,
+}
+
+type TRequestQueryParams = {
+  [key: string]: string
+}
+
+type TResponse = {
+  json: any;
+  status: number;
+  ok: boolean;
+}
+
+/* region signIn */
+type TSignInStartRequestBody =  {
+  captcha_response?: string,
+  meta: TAccountMeta,
+  mobile?: string,
+}
+
+type TAccountMeta = {
+  audit_source_type: TAuditSource,
+  browser_page_resolution: string,
+  cookies_enabled: boolean,
+  ip: string,
+  js_enabled: boolean,
+  language: string,
+  user_agent: string
+}
+
+type TSignInByMobileRequestData = {
+  phoneNumber: string,
+}
+
+type TSignInByMobileResponse = {
+  auth_token: string,
+  challenges: TChallenge[],
+}
+/* endregion signIn */
+
+/* region signUp */
+type TSignUpStartRequestBody = {
+  locale: string,
+  mobile: string,
+  timezone_name: string,
+}
+
+type TSignUpByMobileRequestData = {
+  locale: string,
+  phoneNumber: string,
+  timezoneName: string,
+}
+/* endregion signUp */
+
+/* region setupChallenge */
+type TSetupChallengeRequestData = {
+  type: TChallenge,
+  authToken: string,
+}
+
+type TSetupChallengeResponse = {
+  attempts_left: number,
+  masked_email: string,
+  masked_mobile: string,
+  next_attempt_after: number,
+}
+/* endregion setupChallenge */
+
+/* region verifyChallenge */
+type TVerifyChallengeRequestBody = {
+  type: TChallenge,
+  value: string,
+}
+
+type TVerifyChallengeRequestData = {
+  authToken: string,
+  type: TChallenge,
+  code: string,
+}
+
+type TVerifyChallengeResponse = {
+  auth_token: string,
+  challenges: TChallenge[],
+}
+/* endregion verifyChallenge */
+
+/* region emailUpdate */
+type TEmailUpdateRequestData = {
+  authToken: string,
+  email: string,
+}
+/* endregion emailUpdate */
+
+/* region createSession */
+type TCreateSessionRequestData = {
+  authToken: string,
+}
+
+type TCreateSessionResponse = {
+  access_token: string,
+  refresh_token: string,
+}
+/* endregion createSession */
+
+/* region getCurrentUserProfile */
+/**
+ * Has other properties witch not important for processing on frontend,
+ * see https://api-frontend-qa.goolge.com/v1/doc/#operation/GetCurrentUserProfile
+ */
+type TGetCurrentUserProfileResponseUser = {
+  profiles: (TGetCurrentUserProfileResponseUserProfiles & Record<string, unknown>)[],
+}
+
+/**
+ * Has other properties witch not important for processing on frontend,
+ * see https://api-frontend-qa.goolge.com/v1/doc/#operation/GetCurrentUserProfile
+ */
+type TGetCurrentUserProfileResponseUserProfiles = {
+  target_entity_name: string,
+  target_entity_id: string,
+}
+/* endregion getCurrentUserProfile */
+
+/* region registration */
+type TRegistrationRequestBodySource = {
+  hash: string,
+  device_type: TRegistrationRequestBodySourceDeviceType,
+  ga_id: string,
+  origin: string,
+}
+
+type TRegistrationRequestBody = {
+  name: string,
+  source: TRegistrationRequestBodySource,
+}
+
+type TRegistrationRequestData = {
+  authToken: string,
+  name: TRegistrationRequestBody['name'],
+  deviceType: TRegistrationRequestBodySource['device_type']
+  hash: TRegistrationRequestBodySource['hash'],
+  gaId: TRegistrationRequestBodySource['ga_id'],
+  origin: TRegistrationRequestBodySource['origin'],
+}
+/* endregion registration */
+
+export {
+  TChallenge,
+  TAuditSource,
+  TRequestProps,
+  TRequestQueryParams,
+  TResponse,
+  TSignInStartRequestBody,
+  TAccountMeta,
+  TSignInByMobileRequestData,
+  TSignInByMobileResponse,
+  TSignUpStartRequestBody,
+  TSignUpByMobileRequestData,
+  TSetupChallengeRequestData,
+  TSetupChallengeResponse,
+  TVerifyChallengeRequestBody,
+  TVerifyChallengeRequestData,
+  TVerifyChallengeResponse,
+  TEmailUpdateRequestData,
+  TCreateSessionRequestData,
+  TCreateSessionResponse,
+  TGetCurrentUserProfileResponseUser,
+  TRegistrationRequestData
+};

package/src/types/index.ts

@@ -1,72 +1 @@
-import {CommunicatorActionEnum} from "../enums/CommunicatorActionEnum";
-import {CommunicatorTargetEnum} from "../enums/CommunicatorTargetEnum";
-
-export type TSenderProps = {
-  receiverOrigin: string,
-  otherWindow: Window,
-}
-
-export type TReceiverProps = {
-  senderOrigin: string,
-}
-
-export type TReceiverCallback = (message: TCommunicatorMessage) => void;
-
-export type TCommunicatorActionTokenParams = {
-  name: string,
-  value: string,
-  domain: string,
-  expires?: number,
-}
-
-export type TCommunicatorActionResizeParams = {
-  width?: number,
-  height?: number,
-}
-
-export type TCommunicatorActionGotoParams = {
-  url: string,
-  isTargetBlank?: boolean,
-}
-
-export type TCommunicatorSenderActionMap = {
-  [CommunicatorActionEnum.LOADED]?: true,
-  [CommunicatorActionEnum.TOKEN]?: TCommunicatorActionTokenParams,
-  [CommunicatorActionEnum.RESIZE]?: TCommunicatorActionResizeParams,
-  [CommunicatorActionEnum.GOTO]?: TCommunicatorActionGotoParams,
-  [CommunicatorActionEnum.CLOSE]?: true,
-  [CommunicatorActionEnum.OPEN]?: CommunicatorTargetEnum,
-}
-
-export type TCommunicatorMessage = {
-  target: CommunicatorTargetEnum,
-  action: TCommunicatorSenderActionMap
-}
-
-export type TReceiverSubscribeParams = {
-  code?: string;
-  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,
-}
-
-export type TReceiverTargetScenario = {
-  [key in CommunicatorTargetEnum]?: CommunicatorActionEnum[];
-}
+export * from "./TCommunicator";

package/test/utiles.spec.ts

@@ -1,69 +1,5 @@
-import {isValidMessage, modifyOrigin, sortMessageQueue} from '../src/engine/utils';
-import {
-  queueWithCustomScenario,
-  queueWithCustomV2Scenario, queueWithCustomV3Scenario,
-  queueWithDefaultScenario,
-  queueWithoutSorting
-} from './testUnits/queue';
-import {messageWithInvalidAction, messageWithInvalidTarget, normalMessage} from './testUnits/message';
-import {scenarioCustom, defaultScenario, scenarioCustomV2, scenarioCustomV3} from './testUnits/scenario';
+// TODO: There should be unit tests
 
 test('modifyOrigin', () => {
-  expect(modifyOrigin('google.com')).toBe('https://google.com');
-  expect(modifyOrigin('google.com/test')).toBe('https://google.com');
-  expect(modifyOrigin('https://google.com/')).toBe('https://google.com');
-  expect(modifyOrigin('  https://google.com/')).toBe('https://google.com');
-  expect(modifyOrigin('htts://google.com')).toBe(null);
+  expect(true).toBe(true);
 });
-
-describe('isValidMessage', () => {
-  it('message is valid', () => {
-    expect(isValidMessage(normalMessage)).toBeTruthy();
-  });
-
-  it('message has invalid target', () => {
-    expect(
-      isValidMessage(messageWithInvalidTarget)
-    ).toBeFalsy();
-  });
-
-  it('message has invalid action', () => {
-    expect(
-      isValidMessage(messageWithInvalidAction)
-    ).toBeFalsy();
-  });
-
-  // TODO: need validation action params
-  // it('Invalid Action Params', () => {
-  //   expect(
-  //     isValidMessage(messageWithInvalidActionParams)
-  //   ).toBeFalsy();
-  // });
-});
-
-describe('sortMessageQueue', () => {
-  it('Default Sorting (Default scenario)', () => {
-    expect(
-      JSON.stringify(sortMessageQueue(queueWithoutSorting, defaultScenario))
-    ).toBe(JSON.stringify(queueWithDefaultScenario));
-  });
-
-  it('Custom Sorting (Not full scenario)', () => {
-    expect(
-      JSON.stringify(sortMessageQueue(queueWithoutSorting, scenarioCustom))
-    ).toBe(JSON.stringify(queueWithCustomScenario));
-  });
-
-  it('Custom Sorting (Full scenario)', () => {
-    expect(
-      JSON.stringify(sortMessageQueue(queueWithoutSorting, scenarioCustomV2))
-    ).toBe(JSON.stringify(queueWithCustomV2Scenario));
-  });
-
-  it('Custom Sorting (Full scenario with Doubling)', () => {
-    expect(
-      JSON.stringify(sortMessageQueue(queueWithoutSorting, scenarioCustomV3))
-    ).toBe(JSON.stringify(queueWithCustomV3Scenario));
-  });
-});
-

package/tsconfig.json

@@ -23,6 +23,11 @@
     "noUnusedParameters": true,
     "importHelpers": true,
     "sourceMap": false,
+    "paths": {
+      "@root*": [
+        "./src*",
+      ],
+    }
   },
   "exclude": [
     "dist",

package/dist/engine/CommunicatorReceiver.d.ts

@@ -1,14 +0,0 @@
-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,114 +0,0 @@
-import { isValidMessage, modifyOrigin, sortMessageQueue } from "./utils";
-import { CommunicatorTargetEnum_isCorrect } from '../enums/CommunicatorTargetEnum';
-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) {
-                return;
-            }
-            if (!isValidMessage(message)) {
-                return;
-            }
-            const queue = this.queue.filter(item => item.target === message.target && message.action.hasOwnProperty(item.action));
-            const defaultScenario = CommunicatorActionEnum_scenario();
-            let sortedQueue = sortMessageQueue(queue, defaultScenario);
-            const scenario = this.getMessageScenario(message.target);
-            if (defaultScenario !== scenario) {
-                sortedQueue = sortMessageQueue(queue, scenario);
-            }
-            if (sortedQueue.length) {
-                sortedQueue.forEach(item => {
-                    if (typeof item.params.callback === 'function') {
-                        item.params.callback(message);
-                    }
-                });
-            }
-        };
-        this.subscribe = (params) => {
-            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))) {
-                throw new Error('WAC: target or action is not allowed!');
-            }
-            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;
-            }
-            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 || Object.keys(params).length === 0) {
-                this.queue = [];
-                return true;
-            }
-            const queueForRemove = this.queue.filter(item => {
-                return (!params.code || item.code === 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.getMessageScenario = (target) => {
-            const 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);
-        }
-        else {
-            throw new Error('WAC: senderOrigin is broken!');
-        }
-    }
-}

package/dist/engine/CommunicatorSender.d.ts

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

@@ -1,20 +0,0 @@
-import { isValidMessage, modifyOrigin } from './utils';
-export class CommunicatorSender {
-    constructor(props) {
-        this.otherWindow = props.otherWindow;
-        this.receiverOrigin = modifyOrigin(props.receiverOrigin);
-        if (!this.receiverOrigin) {
-            throw new Error('WAC: receiverOrigin is broken!');
-        }
-    }
-    sendMessage(message) {
-        if (!this.receiverOrigin) {
-            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,5 +0,0 @@
-import { TCommunicatorMessage, TReceiverMessageQueue } from "../types";
-import { CommunicatorActionEnum } from "../enums/CommunicatorActionEnum";
-export declare function modifyOrigin(address: string): string;
-export declare function isValidMessage(message: TCommunicatorMessage): boolean;
-export declare function sortMessageQueue(queue: TReceiverMessageQueue, scenario: CommunicatorActionEnum[]): TReceiverMessageQueue;

package/dist/engine/utils.js

@@ -1,41 +0,0 @@
-import { CommunicatorTargetEnum_isCorrect } from "../enums/CommunicatorTargetEnum";
-import { CommunicatorActionEnum_isCorrect } from "../enums/CommunicatorActionEnum";
-export function modifyOrigin(address) {
-    let url;
-    try {
-        let targetOrigin = address.trim();
-        targetOrigin = (targetOrigin.indexOf('://') === -1) ? 'https://' + targetOrigin : targetOrigin;
-        url = new URL(targetOrigin);
-    }
-    catch (_) {
-        return null;
-    }
-    return url.origin !== 'null' ? url.origin : null;
-}
-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;
-}
-export function sortMessageQueue(queue, scenario) {
-    return queue.sort((a, b) => {
-        if (scenario.indexOf(a.action) > scenario.indexOf(b.action)) {
-            return 1;
-        }
-        if (scenario.indexOf(a.action) < scenario.indexOf(b.action)) {
-            return -1;
-        }
-        return 0;
-    });
-}

package/dist/enums/CommunicatorActionEnum.d.ts

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

package/dist/enums/CommunicatorActionEnum.js

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

package/dist/enums/CommunicatorTargetEnum.d.ts

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

@@ -1,8 +0,0 @@
-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/receiver.d.ts

@@ -1,6 +0,0 @@
-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/dist/receiver.js

@@ -1,6 +0,0 @@
-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/dist/sender.d.ts

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

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