@yagolive/event-kit 1.0.0

package/src/adapters/index.d.ts

@@ -0,0 +1,44 @@
+import { Action, Jump, Navigate, Replace, EnterRoom, LiveDetect, Onelink, ActionType, ActionData, ActionCreator } from '../core/index.js';
+
+export interface IActionAdapter {
+  sendAction(action: any): Promise<any>;
+  sendActionNoReply?(action: any): void;
+  init?(): void;
+  destroy?(): void;
+}
+
+export interface AdapterOptions {
+  timeout?: number;
+}
+
+export declare class RNWebViewAdapter implements IActionAdapter {
+  constructor(options?: AdapterOptions);
+  sendAction(action: any): Promise<any>;
+  sendActionNoReply(action: any): void;
+  init(): void;
+  destroy(): void;
+}
+
+export interface MockCall {
+  type: string;
+  data: Record<string, any>;
+  messageId: string;
+  timestamp: number;
+}
+
+export interface MockAdapterOptions extends AdapterOptions {
+  delay?: number;
+}
+
+export declare class MockAdapter implements IActionAdapter {
+  constructor(options?: MockAdapterOptions);
+  mockResult(actionType: string, result: any): this;
+  mockError(actionType: string, error: any): this;
+  getCalls(): MockCall[];
+  clearCalls(): this;
+  clearMocks(): this;
+  sendAction(action: any): Promise<any>;
+  sendActionNoReply(action: any): void;
+  init(): void;
+  destroy(): void;
+}

package/src/adapters/index.js

@@ -0,0 +1,2 @@
+export { default as RNWebViewAdapter } from './RNWebViewAdapter.js';
+export { default as MockAdapter } from './MockAdapter.js';

package/src/bridge/ActionBridge.js

@@ -0,0 +1,164 @@
+import { ActionCreator, ActionData, ActionType } from '../core/ActionCreator.js';
+import RNWebViewAdapter from '../adapters/RNWebViewAdapter.js';
+import MockAdapter from '../adapters/MockAdapter.js';
+
+export default class ActionBridge {
+  constructor(adapter, options) {
+    if (!adapter || typeof adapter.sendAction !== 'function') {
+      throw new Error('ActionBridge requires an adapter with sendAction method');
+    }
+    this._adapter = adapter;
+    this._options = options || {};
+    if (typeof this._adapter.init === 'function') {
+      this._adapter.init();
+    }
+  }
+
+  get ActionCreator() {
+    return ActionCreator;
+  }
+  get ActionType() {
+    return ActionType;
+  }
+  get ActionData() {
+    return ActionData;
+  }
+
+  sendAction(action, callback) {
+    var promise = this._adapter.sendAction(action);
+    if (callback) {
+      promise.then(
+        function (result) {
+          callback(result, null);
+        },
+        function (error) {
+          callback(null, error);
+        },
+      );
+    }
+    return promise;
+  }
+
+  sendActionNoReply(action) {
+    return this._adapter.sendActionNoReply(action);
+  }
+
+  jump(path) {
+    return this._adapter.sendAction(ActionCreator.createJumpAction(path));
+  }
+
+  buildJump(path) {
+    return ActionCreator.buildJump(path);
+  }
+  createJumpAction(path) {
+    return ActionCreator.createJumpAction(path);
+  }
+  createJumpActionWithData(jump) {
+    return ActionCreator.createJumpActionWithData(jump);
+  }
+
+  navigate(screen, params) {
+    var action = params
+      ? ActionCreator.createNavigateActionWithParams(screen, params)
+      : ActionCreator.createNavigateAction(screen);
+    return this._adapter.sendAction(action);
+  }
+
+  buildNavigate(screen, params) {
+    return ActionCreator.buildNavigate(screen, params);
+  }
+  createNavigateAction(screen) {
+    return ActionCreator.createNavigateAction(screen);
+  }
+  createNavigateActionWithParams(screen, params) {
+    return ActionCreator.createNavigateActionWithParams(screen, params);
+  }
+  createNavigateActionWithData(navigate) {
+    return ActionCreator.createNavigateActionWithData(navigate);
+  }
+
+  replace(screen, params) {
+    var action = params
+      ? ActionCreator.createReplaceActionWithParams(screen, params)
+      : ActionCreator.createReplaceAction(screen);
+    return this._adapter.sendAction(action);
+  }
+
+  buildReplace(screen, params) {
+    return ActionCreator.buildReplace(screen, params);
+  }
+  createReplaceAction(screen) {
+    return ActionCreator.createReplaceAction(screen);
+  }
+  createReplaceActionWithParams(screen, params) {
+    return ActionCreator.createReplaceActionWithParams(screen, params);
+  }
+  createReplaceActionWithData(replace) {
+    return ActionCreator.createReplaceActionWithData(replace);
+  }
+
+  enterRoom(id) {
+    return this._adapter.sendAction(ActionCreator.createEnterRoomAction(id));
+  }
+
+  buildEnterRoom() {
+    return ActionCreator.buildEnterRoom();
+  }
+  createEnterRoomAction(id) {
+    return ActionCreator.createEnterRoomAction(id);
+  }
+  createEnterRoomActionWithData(enterRoom) {
+    return ActionCreator.createEnterRoomActionWithData(enterRoom);
+  }
+
+  liveDetect() {
+    return this._adapter.sendAction(ActionCreator.createLiveDetectAction());
+  }
+
+  buildLiveDetect() {
+    return ActionCreator.buildLiveDetect();
+  }
+  createLiveDetectAction() {
+    return ActionCreator.createLiveDetectAction();
+  }
+  createLiveDetectActionWithData(liveDetect) {
+    return ActionCreator.createLiveDetectActionWithData(liveDetect);
+  }
+
+  onelink(url) {
+    return this._adapter.sendAction(ActionCreator.createOnelinkAction(url));
+  }
+
+  buildOnelink(url) {
+    return ActionCreator.buildOnelink(url);
+  }
+  createOnelinkAction(url) {
+    return ActionCreator.createOnelinkAction(url);
+  }
+  createOnelinkActionWithData(onelink) {
+    return ActionCreator.createOnelinkActionWithData(onelink);
+  }
+
+  destroy() {
+    if (typeof this._adapter.destroy === 'function') {
+      this._adapter.destroy();
+    }
+  }
+
+  static createDefault(options) {
+    if (typeof window !== 'undefined' && window.ReactNativeWebView) {
+      return new ActionBridge(new RNWebViewAdapter(options), options);
+    }
+    return new ActionBridge(new MockAdapter(options), options);
+  }
+
+  static createWithMock(options) {
+    return new ActionBridge(new MockAdapter(options), options);
+  }
+}
+
+ActionBridge.ActionCreator = ActionCreator;
+ActionBridge.ActionType = ActionType;
+ActionBridge.ActionData = ActionData;
+ActionBridge.RNWebViewAdapter = RNWebViewAdapter;
+ActionBridge.MockAdapter = MockAdapter;

package/src/bridge/index.d.ts

@@ -0,0 +1,59 @@
+import {
+  Action, Jump, Navigate, Replace, EnterRoom, LiveDetect, Onelink,
+  ActionType, ActionData, ActionCreator,
+} from '../core/index.js';
+import { IActionAdapter, RNWebViewAdapter, MockAdapter, AdapterOptions } from '../adapters/index.js';
+
+export declare class ActionBridge {
+  constructor(adapter: IActionAdapter, options?: AdapterOptions);
+
+  readonly ActionCreator: typeof ActionCreator;
+  readonly ActionType: typeof ActionType;
+  readonly ActionData: typeof ActionData;
+
+  sendAction(action: any, callback?: (result: any, error: any) => void): Promise<any>;
+  sendActionNoReply(action: any): void;
+
+  jump(path: string): Promise<any>;
+  buildJump(path: string): Jump;
+  createJumpAction(path: string): Action;
+  createJumpActionWithData(jump: Jump): Action;
+
+  navigate(screen: string, params?: Record<string, any>): Promise<any>;
+  buildNavigate(screen: string, params?: Record<string, any>): Navigate;
+  createNavigateAction(screen: string): Action;
+  createNavigateActionWithParams(screen: string, params: Record<string, any>): Action;
+  createNavigateActionWithData(navigate: Navigate): Action;
+
+  replace(screen: string, params?: Record<string, any>): Promise<any>;
+  buildReplace(screen: string, params?: Record<string, any>): Replace;
+  createReplaceAction(screen: string): Action;
+  createReplaceActionWithParams(screen: string, params: Record<string, any>): Action;
+  createReplaceActionWithData(replace: Replace): Action;
+
+  enterRoom(id: number): Promise<any>;
+  buildEnterRoom(): EnterRoom;
+  createEnterRoomAction(id: number): Action;
+  createEnterRoomActionWithData(enterRoom: EnterRoom): Action;
+
+  liveDetect(): Promise<any>;
+  buildLiveDetect(): LiveDetect;
+  createLiveDetectAction(): Action;
+  createLiveDetectActionWithData(liveDetect: LiveDetect): Action;
+
+  onelink(url: string): Promise<any>;
+  buildOnelink(url: string): Onelink;
+  createOnelinkAction(url: string): Action;
+  createOnelinkActionWithData(onelink: Onelink): Action;
+
+  destroy(): void;
+
+  static ActionCreator: typeof ActionCreator;
+  static ActionType: typeof ActionType;
+  static ActionData: typeof ActionData;
+  static RNWebViewAdapter: typeof RNWebViewAdapter;
+  static MockAdapter: typeof MockAdapter;
+
+  static createDefault(options?: AdapterOptions): ActionBridge;
+  static createWithMock(options?: AdapterOptions): ActionBridge;
+}

package/src/bridge/index.js

@@ -0,0 +1 @@
+export { default as ActionBridge } from './ActionBridge.js';

package/src/core/ActionCreator.js

@@ -0,0 +1,121 @@
+import Jump from './types/Jump.js';
+import Navigate from './types/Navigate.js';
+import Replace from './types/Replace.js';
+import EnterRoom from './types/EnterRoom.js';
+import LiveDetect from './types/LiveDetect.js';
+import Onelink from './types/Onelink.js';
+import Action from './types/Action.js';
+
+const ActionType = {
+  JUMP: 'jump',
+  NAVIGATE: 'navigate',
+  REPLACE: 'replace',
+  ENTER_ROOM: 'enter_room',
+  LIVE_DETECT: 'live_detect',
+  ONELINK: 'onelink',
+};
+
+const ActionData = {
+  Jump,
+  Navigate,
+  Replace,
+  EnterRoom,
+  LiveDetect,
+  Onelink,
+};
+
+const ActionCreator = {
+  ActionData: ActionData,
+  ActionType: ActionType,
+
+  // Jump
+  buildJump(path) {
+    return new Jump(path);
+  },
+
+  createJumpAction(path) {
+    return new Action(ActionType.JUMP, new Jump(path));
+  },
+
+  createJumpActionWithData(jump) {
+    return new Action(ActionType.JUMP, jump);
+  },
+
+  // Navigate
+  buildNavigate(screen, params) {
+    return new Navigate(screen, params);
+  },
+
+  createNavigateAction(screen) {
+    return new Action(ActionType.NAVIGATE, new Navigate(screen));
+  },
+
+  createNavigateActionWithParams(screen, params) {
+    return new Action(ActionType.NAVIGATE, new Navigate(screen, params));
+  },
+
+  createNavigateActionWithData(navigate) {
+    return new Action(ActionType.NAVIGATE, navigate);
+  },
+
+  // Replace
+  buildReplace(screen, params) {
+    return new Replace(screen, params);
+  },
+
+  createReplaceAction(screen) {
+    return new Action(ActionType.REPLACE, new Replace(screen));
+  },
+
+  createReplaceActionWithParams(screen, params) {
+    return new Action(ActionType.REPLACE, new Replace(screen, params));
+  },
+
+  createReplaceActionWithData(replace) {
+    return new Action(ActionType.REPLACE, replace);
+  },
+
+  // EnterRoom
+  buildEnterRoom() {
+    return new EnterRoom();
+  },
+
+  createEnterRoomAction(id) {
+    var enterRoom = new EnterRoom();
+    if (id != null) enterRoom.setId(id);
+    return new Action(ActionType.ENTER_ROOM, enterRoom);
+  },
+
+  createEnterRoomActionWithData(enterRoom) {
+    return new Action(ActionType.ENTER_ROOM, enterRoom);
+  },
+
+  // LiveDetect
+  buildLiveDetect() {
+    return new LiveDetect();
+  },
+
+  createLiveDetectAction() {
+    return new Action(ActionType.LIVE_DETECT, new LiveDetect());
+  },
+
+  createLiveDetectActionWithData(liveDetect) {
+    return new Action(ActionType.LIVE_DETECT, liveDetect);
+  },
+
+  // Onelink
+  buildOnelink(url) {
+    return new Onelink(url);
+  },
+
+  createOnelinkAction(url) {
+    return new Action(ActionType.ONELINK, new Onelink(url));
+  },
+
+  createOnelinkActionWithData(onelink) {
+    return new Action(ActionType.ONELINK, onelink);
+  },
+};
+
+export { ActionCreator, ActionData, ActionType };
+export default ActionCreator;

package/src/core/index.d.ts

@@ -0,0 +1,182 @@
+// Core types
+
+export class Jump {
+  constructor(path: string);
+  text: string | null;
+  path: string;
+  getText(): string | null;
+  setText(text: string): this;
+  getPath(): string;
+  setPath(path: string): this;
+  toMap(): Record<string, any>;
+}
+
+export class Navigate {
+  constructor(screen: string, params?: Record<string, any>);
+  text: string | null;
+  screen: string;
+  params: Record<string, any>;
+  getText(): string | null;
+  setText(text: string): this;
+  getScreen(): string;
+  setScreen(screen: string): this;
+  getParams(): Record<string, any>;
+  setParams(params: Record<string, any>): this;
+  toMap(): Record<string, any>;
+}
+
+export class Replace extends Navigate {
+  constructor(screen: string, params?: Record<string, any>);
+}
+
+export class OpenGiftPopupCallback {
+  constructor();
+  id: number | null;
+  type: string | null;
+  count: number | null;
+  getId(): number | null;
+  setId(id: number): this;
+  getType(): string | null;
+  setType(type: string): this;
+  getCount(): number | null;
+  setCount(count: number): this;
+  toMap(): Record<string, any>;
+}
+
+export class OpenGameCallback {
+  constructor();
+  id: number | null;
+  getId(): number | null;
+  setId(id: number): this;
+  toMap(): Record<string, any>;
+}
+
+export class OpenActivityCallback {
+  constructor();
+  id: string | null;
+  getId(): string | null;
+  setId(id: string): this;
+  toMap(): Record<string, any>;
+}
+
+export class SwitchRoomTypeCallback {
+  constructor();
+  type: string | null;
+  getType(): string | null;
+  setType(type: string): this;
+  toMap(): Record<string, any>;
+}
+
+export const CallbackType: {
+  OPEN_GIFT_POPUP: 'open_gift_popup';
+  OPEN_GAME: 'open_game';
+  OPEN_ACTIVITY: 'open_activity';
+  SWITCH_ROOM_TYPE: 'switch_room_type';
+};
+
+export class EnterRoom {
+  constructor();
+  text: string | null;
+  id: number | null;
+  match: string | null;
+  callbacks: Record<string, any> | null;
+  useReplace: boolean | null;
+  static CallbackType: typeof CallbackType;
+  static OpenGiftPopupCallback: typeof OpenGiftPopupCallback;
+  static OpenGameCallback: typeof OpenGameCallback;
+  static OpenActivityCallback: typeof OpenActivityCallback;
+  static SwitchRoomTypeCallback: typeof SwitchRoomTypeCallback;
+  getText(): string | null;
+  setText(text: string): this;
+  getId(): number | null;
+  setId(id: number): this;
+  getMatch(): string | null;
+  setMatch(match: string): this;
+  getUseReplace(): boolean | null;
+  setUseReplace(useReplace: boolean): this;
+  addOpenGiftPopupCallback(cb: OpenGiftPopupCallback): this;
+  addOpenGameCallback(cb: OpenGameCallback): this;
+  addOpenActivityCallback(cb: OpenActivityCallback): this;
+  addSwitchRoomTypeCallback(cb: SwitchRoomTypeCallback): this;
+  toMap(): Record<string, any>;
+}
+
+export class LiveDetect {
+  constructor();
+  text: string | null;
+  getText(): string | null;
+  setText(text: string): this;
+  toMap(): Record<string, any>;
+}
+
+export class Onelink {
+  constructor(url?: string);
+  text: string | null;
+  url: string | null;
+  share: boolean | null;
+  getText(): string | null;
+  setText(text: string): this;
+  getUrl(): string | null;
+  setUrl(url: string): this;
+  getShare(): boolean | null;
+  setShare(share: boolean): this;
+  toMap(): Record<string, any>;
+}
+
+export class Action {
+  constructor(type: ActionTypeValue, data: any);
+  type: ActionTypeValue;
+  data: any;
+  messageId: string | null;
+  getType(): ActionTypeValue;
+  setType(type: ActionTypeValue): this;
+  getData(): any;
+  setData(data: any): this;
+  setBaseData(text: string): this;
+  toJson(): string;
+}
+
+export type ActionTypeValue = 'jump' | 'navigate' | 'replace' | 'enter_room' | 'live_detect' | 'onelink';
+
+export const ActionType: {
+  JUMP: 'jump';
+  NAVIGATE: 'navigate';
+  REPLACE: 'replace';
+  ENTER_ROOM: 'enter_room';
+  LIVE_DETECT: 'live_detect';
+  ONELINK: 'onelink';
+};
+
+export const ActionData: {
+  Jump: typeof Jump;
+  Navigate: typeof Navigate;
+  Replace: typeof Replace;
+  EnterRoom: typeof EnterRoom;
+  LiveDetect: typeof LiveDetect;
+  Onelink: typeof Onelink;
+};
+
+export const ActionCreator: {
+  ActionData: typeof ActionData;
+  ActionType: typeof ActionType;
+  buildJump(path: string): Jump;
+  createJumpAction(path: string): Action;
+  createJumpActionWithData(jump: Jump): Action;
+  buildNavigate(screen: string, params?: Record<string, any>): Navigate;
+  createNavigateAction(screen: string): Action;
+  createNavigateActionWithParams(screen: string, params: Record<string, any>): Action;
+  createNavigateActionWithData(navigate: Navigate): Action;
+  buildReplace(screen: string, params?: Record<string, any>): Replace;
+  createReplaceAction(screen: string): Action;
+  createReplaceActionWithParams(screen: string, params: Record<string, any>): Action;
+  createReplaceActionWithData(replace: Replace): Action;
+  buildEnterRoom(): EnterRoom;
+  createEnterRoomAction(id: string): Action;
+  createEnterRoomActionWithData(enterRoom: EnterRoom): Action;
+  buildLiveDetect(): LiveDetect;
+  createLiveDetectAction(): Action;
+  createLiveDetectActionWithData(liveDetect: LiveDetect): Action;
+  buildOnelink(url: string): Onelink;
+  createOnelinkAction(url: string): Action;
+  createOnelinkActionWithData(onelink: Onelink): Action;
+};

package/src/core/index.js

@@ -0,0 +1,8 @@
+export { ActionCreator, ActionData, ActionType } from './ActionCreator.js';
+export { default as Jump } from './types/Jump.js';
+export { default as Navigate } from './types/Navigate.js';
+export { default as Replace } from './types/Replace.js';
+export { default as EnterRoom } from './types/EnterRoom.js';
+export { default as LiveDetect } from './types/LiveDetect.js';
+export { default as Onelink } from './types/Onelink.js';
+export { default as Action } from './types/Action.js';

package/src/core/types/Action.js

@@ -0,0 +1,28 @@
+class Action {
+  constructor(type, data) {
+    this.type = type;
+    this.data = data;
+    this.messageId = null;
+  }
+
+  getType() { return this.type; }
+  setType(type) { this.type = type; return this; }
+  getData() { return this.data; }
+  setData(data) { this.data = data; return this; }
+
+  setBaseData(text) {
+    if (this.data != null && typeof this.data.setText === 'function') {
+      this.data.setText(text);
+    }
+    return this;
+  }
+
+  toJson() {
+    return JSON.stringify({
+      type: this.type,
+      data: this.data != null ? this.data.toMap() : {},
+    });
+  }
+}
+
+export default Action;