@onekeyfe/hd-core 0.2.46 → 0.2.49-alpha.0

package/src/lowLevelInject.ts

@@ -0,0 +1,52 @@
+import { EventEmitter } from 'events';
+import { CallMethod, CoreMessage } from './events';
+import { CoreApi } from './types/api';
+import { createCoreApi } from './inject';
+
+type IAddHardwareGlobalEventListener = (coreMessage: CoreMessage) => void;
+
+export interface LowLevelInjectApi {
+  call: CallMethod;
+  eventEmitter: EventEmitter;
+  init: CoreApi['init'];
+  dispose: CoreApi['dispose'];
+  uiResponse: CoreApi['uiResponse'];
+  cancel: CoreApi['cancel'];
+  addHardwareGlobalEventListener: (listener: IAddHardwareGlobalEventListener) => void;
+}
+
+export type LowLevelCoreApi = Omit<CoreApi, 'on' | 'off'> & {
+  addHardwareGlobalEventListener: (listener: IAddHardwareGlobalEventListener) => void;
+};
+
+export const lowLevelInject = ({
+  call,
+  cancel,
+  dispose,
+  eventEmitter,
+  init,
+  uiResponse,
+  addHardwareGlobalEventListener,
+}: LowLevelInjectApi): LowLevelCoreApi => {
+  const api: LowLevelCoreApi = {
+    addHardwareGlobalEventListener,
+    removeAllListeners: type => {
+      eventEmitter.removeAllListeners(type);
+    },
+
+    init,
+
+    call,
+
+    dispose,
+
+    uiResponse,
+
+    cancel,
+
+    emit: () => {},
+
+    ...createCoreApi(call),
+  };
+  return api;
+};

package/src/topLevelInject.ts

@@ -0,0 +1,55 @@
+import EventEmitter from 'events';
+import { CoreApi } from './types/api';
+import { createCoreApi } from './inject';
+import type { LowLevelCoreApi } from './lowLevelInject';
+
+export interface TopLevelInjectApi {
+  init: CoreApi['init'];
+  call: CoreApi['call'];
+}
+
+const eventEmitter = new EventEmitter();
+
+const EmptyFN = () => {};
+
+export const topLevelInject = () => {
+  let lowLevelApi: LowLevelCoreApi | undefined;
+  const call = (params: any) => {
+    if (!lowLevelApi) return Promise.resolve(undefined);
+    return lowLevelApi.call(params);
+  };
+  const api: CoreApi = {
+    on: <T extends string, P extends (...args: any[]) => any>(type: T, fn: P) => {
+      eventEmitter.on(type, fn);
+    },
+
+    emit: (eventName: string, ...args: any[]) => {
+      eventEmitter.emit(eventName, ...args);
+    },
+
+    off: (type, fn) => {
+      eventEmitter.emit(type, fn);
+    },
+
+    init: (settings, hardwareLowLeverApi) => {
+      lowLevelApi = hardwareLowLeverApi;
+      return lowLevelApi?.init(settings) ?? Promise.resolve(false);
+    },
+
+    call,
+
+    ...createCoreApi(call),
+
+    removeAllListeners: type => {
+      eventEmitter.removeAllListeners(type);
+    },
+
+    dispose: lowLevelApi?.dispose ?? EmptyFN,
+
+    uiResponse: lowLevelApi?.uiResponse ?? EmptyFN,
+
+    cancel: lowLevelApi?.cancel ?? EmptyFN,
+  };
+
+  return api;
+};

package/src/types/api/index.ts

@@ -113,6 +113,7 @@ export type CoreApi = {
   init: typeof init;
   on: typeof on;
   off: typeof off;
+  emit: (event: string, ...args: any[]) => void;
   removeAllListeners: typeof removeAllListeners;
   dispose: () => void;
   call: (params: any) => Promise<any>;

package/src/types/api/init.ts

@@ -1,3 +1,7 @@
+import { LowLevelCoreApi } from '../../lowLevelInject';
 import type { ConnectSettings } from '../settings';
 
-export declare function init(settings: Partial<ConnectSettings>): Promise<boolean>;
+export declare function init(
+  settings: Partial<ConnectSettings>,
+  lowLevelApi?: LowLevelCoreApi
+): Promise<boolean>;