@onetokenfe/hd-core 1.1.23

package/src/utils/logger.ts

@@ -0,0 +1,190 @@
+import { LOG, createLogMessage } from '../events/log';
+
+import type { CoreMessage } from '../events';
+
+type LogMessage = {
+  level: string;
+  prefix: string;
+  message: any[];
+  timestamp: number;
+};
+
+const MAX_ENTRIES = 500;
+
+let postMessage: (message: CoreMessage) => void;
+
+class Log {
+  prefix: string;
+
+  enabled: boolean;
+
+  messages: LogMessage[];
+
+  constructor(prefix: string, enabled: boolean) {
+    this.prefix = prefix;
+    this.enabled = enabled;
+    this.messages = [];
+  }
+
+  addMessage(level: string, prefix: string, ...args: any[]) {
+    this.messages.push({
+      level,
+      prefix,
+      message: args,
+      timestamp: new Date().getTime(),
+    });
+    if (this.messages.length > MAX_ENTRIES) {
+      this.messages.shift();
+    }
+  }
+
+  log(...args: any[]) {
+    this.addMessage('log', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+    if (!this.enabled) {
+      return;
+    }
+    console.log(this.prefix, ...args);
+  }
+
+  error(...args: any[]) {
+    this.addMessage('error', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+    if (!this.enabled) {
+      return;
+    }
+    console.error(this.prefix, ...args);
+  }
+
+  warn(...args: any[]) {
+    this.addMessage('warn', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+    if (!this.enabled) {
+      return;
+    }
+    console.warn(this.prefix, ...args);
+  }
+
+  debug(...args: any[]) {
+    this.addMessage('debug', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+    if (!this.enabled) {
+      return;
+    }
+    console.log(this.prefix, ...args);
+  }
+}
+
+const _logs: { [k: string]: Log } = {};
+
+export const initLog = (prefix: string, enabled?: boolean) => {
+  const instance = new Log(prefix, !!enabled);
+  _logs[prefix] = instance;
+  return instance;
+};
+
+export const enableLog = (enabled?: boolean) => {
+  Object.keys(_logs).forEach(key => {
+    _logs[key].enabled = !!enabled;
+  });
+};
+
+export const enableLogByPrefix = (prefix: string, enabled: boolean) => {
+  if (_logs[prefix]) {
+    _logs[prefix].enabled = enabled;
+  }
+};
+
+export const getLog = () => {
+  let logs: LogMessage[] = [];
+  Object.keys(_logs).forEach(key => {
+    logs = logs.concat(_logs[key].messages);
+  });
+  logs.sort((a, b) => a.timestamp - b.timestamp);
+  return logs;
+};
+
+export const setLoggerPostMessage = (postMessageFn: (message: CoreMessage) => void) => {
+  postMessage = postMessageFn;
+};
+
+const serializeLog = (...args: any[]) =>
+  args.map(arg => {
+    if (typeof arg === 'string') {
+      return arg;
+    }
+    if (typeof arg === 'number') {
+      return arg;
+    }
+    if (typeof arg === 'boolean') {
+      return arg;
+    }
+    if (typeof arg === 'undefined') {
+      return arg;
+    }
+    if (typeof arg === 'object') {
+      return JSON.stringify(arg, getCircularReplacer());
+    }
+    return arg;
+  });
+
+const getCircularReplacer = () => {
+  const seen = new WeakSet();
+  return (_: string, value: any) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return;
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+};
+
+const sendLogMessage = (prefix: string, ...args: any[]) => {
+  postMessage?.(createLogMessage(LOG.OUTPUT, serializeLog(prefix, ...args)));
+};
+
+export enum LoggerNames {
+  Core = '@onetoken/hd-core',
+  Transport = 'Transport',
+  Device = 'Device',
+  DeviceCommands = 'DeviceCommands',
+  DeviceConnector = 'DeviceConnector',
+  DeviceList = 'DeviceList',
+  DevicePool = 'DevicePool',
+  HdCommonConnectSdk = '@onetoken/common-connect-sdk',
+  HdBleSdk = '@onetoken/hd-ble-sdk',
+  HdTransportHttp = '@onetoken/hd-transport-http',
+  HdTransportLowLevel = '@onetoken/hd-transport-lowlevel',
+  HdBleTransport = '@onetoken/hd-ble-transport',
+  HdWebBleTransport = '@onetoken/hd-web-ble-transport',
+  HdTransportWebUsb = '@onetoken/hd-transport-webusb',
+  Connect = '@onetoken/connect',
+  Iframe = 'IFrame',
+  SendMessage = '[SendMessage]',
+  Method = '[Method]',
+}
+
+export const LoggerMap = {
+  [LoggerNames.Core]: initLog(LoggerNames.Core),
+  [LoggerNames.Transport]: initLog(LoggerNames.Transport),
+  [LoggerNames.Device]: initLog(LoggerNames.Device),
+  [LoggerNames.DeviceCommands]: initLog(LoggerNames.DeviceCommands),
+  [LoggerNames.DeviceConnector]: initLog(LoggerNames.DeviceConnector),
+  [LoggerNames.DeviceList]: initLog(LoggerNames.DeviceList),
+  [LoggerNames.DevicePool]: initLog(LoggerNames.DevicePool),
+  [LoggerNames.HdBleSdk]: initLog(LoggerNames.HdBleSdk),
+  [LoggerNames.HdTransportHttp]: initLog(LoggerNames.HdTransportHttp),
+  [LoggerNames.HdBleTransport]: initLog(LoggerNames.HdBleTransport),
+  [LoggerNames.HdWebBleTransport]: initLog(LoggerNames.HdWebBleTransport),
+  [LoggerNames.HdTransportLowLevel]: initLog(LoggerNames.HdTransportLowLevel),
+  [LoggerNames.HdTransportWebUsb]: initLog(LoggerNames.HdTransportWebUsb),
+  [LoggerNames.Connect]: initLog(LoggerNames.Connect),
+  [LoggerNames.Iframe]: initLog(LoggerNames.Iframe),
+  [LoggerNames.SendMessage]: initLog(LoggerNames.SendMessage),
+  [LoggerNames.Method]: initLog(LoggerNames.Method),
+  [LoggerNames.HdCommonConnectSdk]: initLog(LoggerNames.Method),
+};
+
+export const getLogger = (key: LoggerNames) => LoggerMap[key];

package/src/utils/networkUtils.ts

@@ -0,0 +1,25 @@
+import axios from 'axios';
+
+export const httpRequest = async (url: string, type = 'text') => {
+  const headers: any = {};
+  if (url.indexOf('ngrok-free.app') > -1) {
+    headers['ngrok-skip-browser-warning'] = true;
+  }
+  const response = await axios.request({
+    url,
+    withCredentials: false,
+    responseType: type === 'binary' ? 'arraybuffer' : 'json',
+    headers,
+  });
+
+  if (+response.status === 200) {
+    if (type === 'json') {
+      return response.data;
+    }
+    if (type === 'binary') {
+      return response.data;
+    }
+    return response.data;
+  }
+  throw new Error(`httpRequest error: ${url} ${response.statusText}`);
+};

package/src/utils/patch.ts

@@ -0,0 +1,14 @@
+import type { DefaultMessageResponse } from '../device/DeviceCommands';
+
+export function patchFeatures(response: DefaultMessageResponse) {
+  if (response.type !== 'Features') {
+    return response;
+  }
+
+  // Bootloader 小于 1.8.7 时 major_version 可能小于 0，需要转换为 1
+  if (response.message.major_version < 1) {
+    response.message.major_version = 1;
+  }
+
+  return response;
+}

package/src/utils/promiseUtils.ts

@@ -0,0 +1,4 @@
+export const resolveAfter = (msec: number, value?: any) =>
+  new Promise<any>(resolve => {
+    setTimeout(resolve, msec, value);
+  });

package/src/utils/release.ts

@@ -0,0 +1,42 @@
+import semver from 'semver';
+
+import type {
+  IBLEFirmwareReleaseInfo,
+  IDeviceFirmwareStatus,
+  IFirmwareReleaseInfo,
+  IVersionArray,
+} from '../types';
+
+export const getReleaseStatus = (
+  releases: (IFirmwareReleaseInfo | IBLEFirmwareReleaseInfo)[],
+  currentVersion: string
+): IDeviceFirmwareStatus => {
+  const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
+  if (newVersions.length === 0) {
+    return 'valid';
+  }
+  if (newVersions.some(r => r.required)) {
+    return 'required';
+  }
+  return 'outdated';
+};
+
+export const getReleaseChangelog = (
+  releases: (IFirmwareReleaseInfo | IBLEFirmwareReleaseInfo)[],
+  currentVersion: string
+): IFirmwareReleaseInfo['changelog'][] => {
+  const newVersions = releases.filter(r => semver.gt(r.version.join('.'), currentVersion));
+  return newVersions.map(r => r.changelog);
+};
+
+export const findLatestRelease = <T extends { version: IVersionArray }>(
+  releases: T[]
+): T | undefined => {
+  let leastRelease = releases[0];
+  releases.forEach(release => {
+    if (semver.gt(release.version.join('.'), leastRelease.version.join('.'))) {
+      leastRelease = release;
+    }
+  });
+  return leastRelease;
+};

package/src/utils/semver.test.js

@@ -0,0 +1,53 @@
+import semver from 'semver';
+
+const semverTest = [
+  {
+    description: 'success - normal version',
+    version: '2.10.0',
+    expected: '2.10.0',
+  },
+  {
+    description: 'success - 0.0.0 version',
+    version: '0.0.0',
+    expected: '0.0.0',
+  },
+  {
+    description: 'error - 0 version',
+    version: '0',
+    expected: null,
+  },
+  {
+    description: 'error - unnecessary version',
+    version: '2.10.0 QA',
+    expected: null,
+  },
+  {
+    description: 'error - normal version',
+    version: '2.10',
+    expected: null,
+  },
+  {
+    description: 'error - null version',
+    version: null,
+    expected: null,
+  },
+  {
+    description: 'error - empty version',
+    version: '',
+    expected: null,
+  },
+  {
+    description: 'error - undefined version',
+    version: undefined,
+    expected: null,
+  },
+];
+
+describe('Check Semver', () => {
+  semverTest.forEach(data => {
+    test(data.description, () => {
+      const { version, expected } = data;
+      expect(semver.valid(version)).toBe(expected);
+    });
+  });
+});

package/src/utils/tracing.ts

@@ -0,0 +1,238 @@
+/**
+ * SDK Tracing Utilities
+ * Tracks object instances and request call chains across multiple SDK instances
+ */
+
+import { LoggerNames, getLogger } from './logger';
+
+// Global counters (cross-SDK instances)
+
+const Log = getLogger(LoggerNames.Core);
+
+let globalInstanceCounter = 0;
+let sdkInstanceCounter = 0;
+
+/**
+ * Generate SDK instance ID
+ * @returns Format: "SDK-<number>-<timestamp>"
+ * @example "SDK-1-123456"
+ */
+export function generateSdkInstanceId(): string {
+  sdkInstanceCounter++;
+  const timestamp = Date.now().toString().slice(-6);
+  return `SDK-${sdkInstanceCounter}-${timestamp}`;
+}
+
+/**
+ * Generate globally unique instance ID
+ * @param type Instance type (Device, DeviceCommands, BaseMethod, etc.)
+ * @param sdkInstanceId SDK instance ID (optional)
+ * @returns Format: <SDK>.<type>-<number>-<timestamp>
+ * @example "SDK-1.Device-1-123456" or "Device-1-123456"
+ */
+export function generateInstanceId(type: string, sdkInstanceId?: string): string {
+  globalInstanceCounter++;
+  const timestamp = Date.now().toString().slice(-6);
+  const baseId = `${type}-${globalInstanceCounter}-${timestamp}`;
+  return sdkInstanceId ? `${sdkInstanceId}.${baseId}` : baseId;
+}
+
+// Request context management
+
+/**
+ * Request context information
+ */
+export interface RequestContext {
+  /** Request unique ID (reuses BaseMethod.responseID) */
+  responseID: number;
+  /** SDK instance ID */
+  sdkInstanceId?: string;
+  /** API method name */
+  methodName: string;
+  /** Device connection ID */
+  connectId?: string;
+  /** Device instance ID */
+  deviceInstanceId?: string;
+  /** DeviceCommands instance ID */
+  commandsInstanceId?: string;
+  /** Parent request ID (for nested calls like allNetworkGetAddress) */
+  parentResponseID?: number;
+  /** Request start time */
+  startTime: number;
+  /** Request end time */
+  endTime?: number;
+  /** Request status */
+  status?: 'pending' | 'running' | 'success' | 'error' | 'cancelled';
+  /** Error message */
+  error?: string;
+}
+
+/**
+ * SDK instance tracing context
+ */
+export interface SdkTracingContext {
+  /** SDK instance ID */
+  sdkInstanceId: string;
+  /** Creation timestamp */
+  createdAt: number;
+  /** Active requests */
+  activeRequests: Map<number, RequestContext>;
+}
+
+// Global SDK instance tracking map
+const sdkInstances = new Map<string, SdkTracingContext>();
+
+// Global request map (cross-SDK instances for quick lookup)
+const globalActiveRequests = new Map<number, RequestContext>();
+
+/**
+ * Create SDK instance tracing context
+ */
+export function createSdkTracingContext(): SdkTracingContext {
+  const sdkInstanceId = generateSdkInstanceId();
+  const context: SdkTracingContext = {
+    sdkInstanceId,
+    createdAt: Date.now(),
+    activeRequests: new Map(),
+  };
+
+  sdkInstances.set(sdkInstanceId, context);
+
+  return context;
+}
+
+/**
+ * Create and register request context
+ * @param responseID Request ID (reuses BaseMethod.responseID)
+ * @param methodName API method name
+ * @param options Additional options
+ */
+export function createRequestContext(
+  responseID: number,
+  methodName: string,
+  options?: {
+    sdkInstanceId?: string;
+    connectId?: string;
+    deviceInstanceId?: string;
+    commandsInstanceId?: string;
+    parentResponseID?: number;
+  }
+): RequestContext {
+  const context: RequestContext = {
+    responseID,
+    sdkInstanceId: options?.sdkInstanceId,
+    methodName,
+    connectId: options?.connectId,
+    deviceInstanceId: options?.deviceInstanceId,
+    commandsInstanceId: options?.commandsInstanceId,
+    parentResponseID: options?.parentResponseID,
+    startTime: Date.now(),
+    status: 'pending',
+  };
+
+  // Register to global map
+  globalActiveRequests.set(context.responseID, context);
+
+  // Register to SDK instance map
+  if (options?.sdkInstanceId) {
+    const sdkContext = sdkInstances.get(options.sdkInstanceId);
+    if (sdkContext) {
+      sdkContext.activeRequests.set(context.responseID, context);
+    }
+  }
+
+  return context;
+}
+
+/**
+ * Update request context
+ */
+export function updateRequestContext(responseID: number, updates: Partial<RequestContext>): void {
+  const context = globalActiveRequests.get(responseID);
+  if (context) {
+    Object.assign(context, updates);
+  }
+}
+
+/**
+ * Complete request context
+ */
+export function completeRequestContext(responseID: number, error?: Error): void {
+  const context = globalActiveRequests.get(responseID);
+  if (context) {
+    context.endTime = Date.now();
+    context.status = error ? 'error' : 'success';
+    if (error) {
+      context.error = error.message;
+      Log.error(
+        `[RequestContext] [completeRequestContext] Error: ${formatRequestContext(context)}`
+      );
+    }
+
+    // Remove from active list
+    globalActiveRequests.delete(responseID);
+
+    // Remove from SDK instance
+    if (context.sdkInstanceId) {
+      const sdkContext = sdkInstances.get(context.sdkInstanceId);
+      if (sdkContext) {
+        sdkContext.activeRequests.delete(responseID);
+      }
+    }
+  }
+}
+
+// Query API
+
+/**
+ * Get active requests for specific Device instance
+ */
+export function getActiveRequestsByDeviceInstance(deviceInstanceId: string): RequestContext[] {
+  return Array.from(globalActiveRequests.values()).filter(
+    ctx => ctx.deviceInstanceId === deviceInstanceId
+  );
+}
+
+// Format output
+
+/**
+ * Format request context for logging
+ */
+export function formatRequestContext(context: RequestContext): string {
+  const duration = context.endTime
+    ? context.endTime - context.startTime
+    : Date.now() - context.startTime;
+
+  const parts = [
+    `[req:${context.responseID}]`,
+    context.sdkInstanceId ? `sdk=${context.sdkInstanceId}` : null,
+    `method=${context.methodName}`,
+    context.connectId ? `connectId=${context.connectId}` : null,
+    context.deviceInstanceId ? `deviceInst=${context.deviceInstanceId}` : null,
+    context.commandsInstanceId ? `commandsInst=${context.commandsInstanceId}` : null,
+    context.parentResponseID ? `parent=${context.parentResponseID}` : null,
+    `duration=${duration}ms`,
+    `status=${context.status}`,
+    `error=${context.error}`,
+  ].filter(Boolean);
+
+  return parts.join(' ');
+}
+
+// Cleanup and reset
+
+/**
+ * Cleanup specific SDK instance
+ */
+export function cleanupSdkInstance(sdkInstanceId: string): void {
+  const sdkContext = sdkInstances.get(sdkInstanceId);
+  if (sdkContext) {
+    // Remove SDK requests from global active requests
+    for (const responseID of sdkContext.activeRequests.keys()) {
+      globalActiveRequests.delete(responseID);
+    }
+
+    // Remove SDK instance
+    sdkInstances.delete(sdkInstanceId);
+  }
+}

package/src/utils/versionUtils.ts

@@ -0,0 +1,120 @@
+const VER_NUMS = 3;
+
+// eslint-disable-next-line prefer-regex-literals
+const versionRegex = new RegExp(/^[0-9]{1,3}(\.[0-9]{1,3}){0,2}$/);
+
+/**
+ * Validates version string
+ * @param {string} version Version string
+ * @returns {boolean} True if version string is valid, false if not
+ */
+export const isValidVersionString = (version: string) => versionRegex.test(version);
+
+/**
+ * Validates a version array
+ * @param {number[]} version Version array
+ * @returns {boolean} True if version array is valid, false if not
+ */
+export const isValidVersionArray = (version: number[]) => {
+  // Check if we're getting an actual array
+  if (!Array.isArray(version)) {
+    return false;
+  }
+
+  // Array has to have something in it and be no longer than the VER_NUMS const
+  if (version.length === 0 || version.length > VER_NUMS) {
+    return false;
+  }
+
+  // There's no major version 0 (invalid number)
+  if (version[0] === 0) {
+    return false;
+  }
+
+  // Check for invalid numbers in the array
+  for (let i = 0; i < version.length; i++) {
+    if (typeof version[i] !== 'number' || version[i] < 0) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Fills the missing version numbers with zeros (ie: [1, 2] will become [1, 2, 0])
+ * @param {number[]} version Version array
+ * @returns {number[]} Version array with all positions filled
+ */
+export const normalizeVersionArray = (version: number[]) => {
+  if (version.length === VER_NUMS) {
+    return version;
+  }
+
+  // Filling zero's for partial versions
+  const partialVersion = [...version];
+  for (let i = version.length; i < VER_NUMS; i++) {
+    partialVersion.push(0);
+  }
+
+  return partialVersion;
+};
+
+/**
+ * Returns a valid version array from a version string
+ * @param {string} version Version string
+ * @returns {number[]} Version array
+ */
+export const versionSplit = (version: string): number[] => {
+  if (!isValidVersionString(version)) {
+    return [0, 0, 0];
+  }
+
+  return version.split('.').map(v => Number(v));
+};
+
+/**
+ * Compares two versions and returns if the version is newer (1), older (-1) or equal (0).
+ * @param {string | number[]} a Version to compare from
+ * @param {string | number[]} b Version to compare with
+ * @returns {number} Returns 1 if newer, -1 if older and 0 if equal
+ */
+export const versionCompare = (a: string | number[], b: string | number[]) => {
+  // Quick compare for same version
+  if (typeof a === 'string' && typeof b === 'string' && a === b) {
+    return 0;
+  }
+
+  // Convert string to version arrays
+  const pa = typeof a === 'string' ? versionSplit(a) : a;
+  const pb = typeof b === 'string' ? versionSplit(b) : b;
+
+  // Check version validity
+  const vpa = isValidVersionArray(pa);
+  const vpb = isValidVersionArray(pb);
+
+  if (!vpa && !vpb) {
+    // Both arrays are invalid
+    return 0;
+  }
+  if (!vpa && vpb) {
+    // First array is Invalid
+    return -1;
+  }
+  if (vpa && !vpb) {
+    // Second array is invalid
+    return 1;
+  }
+
+  // Normalize arrays (to contain the right version array length)
+  const npa = normalizeVersionArray(pa);
+  const npb = normalizeVersionArray(pb);
+
+  // Compare versions numbers
+  for (let i = 0; i < VER_NUMS; i++) {
+    if (npa[i] > npb[i]) return 1;
+    if (npb[i] > npa[i]) return -1;
+  }
+
+  return 0;
+};

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "types": [
+      "w3c-web-usb",
+      "web-bluetooth"
+    ]
+  },
+  "include": ["./src",]
+}