leiao 1.0.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "leiao",
+  "version": "1.0.0",
+  "description": "Leiao client SDK",
+  "license": "MIT",
+  "author": "leiao",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "react-native": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./core": "./src/core/index.ts",
+    "./updates": "./src/updates/index.ts",
+    "./push": "./src/push.ts",
+    "./analytics": "./src/analytics.ts",
+    "./auth": "./src/auth.ts"
+  },
+  "files": ["src"],
+  "peerDependencies": {
+    "react": "^19.2.0",
+    "react-native": "^0.87.0",
+    "react-native-blob-util": "*",
+    "react-native-ota-hot-update": "^2.4.4"
+  },
+  "peerDependenciesMeta": {
+    "react": {"optional": true},
+    "react-native": {"optional": true},
+    "react-native-blob-util": {"optional": true},
+    "react-native-ota-hot-update": {"optional": true}
+  }
+}

package/src/analytics.ts

@@ -0,0 +1,261 @@
+import {getConfig, type LeiaoConfig} from './core/config';
+import type {LeiaoModule} from './core/module';
+import {collectDeviceProfile} from './device';
+import {request} from './core/request';
+import {getDeviceId, getIdentity, ready as deviceReady} from './identity';
+import {readJson, writeJson} from './storage';
+
+export const ReservedEvents = {
+  install: 'app_install',
+  start: 'app_start',
+  end: 'app_end',
+  update: 'app_update',
+  login: 'app_login',
+  logout: 'app_logout',
+  screen: 'app_screen',
+} as const;
+
+type Queued = {
+  event: string;
+  props: Record<string, unknown>;
+  deviceId: string;
+  userId: string;
+  platform: string;
+  appVersion: string;
+  brand: string;
+  manufacturer: string;
+  model: string;
+  osName: string;
+  osVersion: string;
+  locale: string;
+  timezone: string;
+  network: string;
+  sessionId: string;
+  durationMs?: number;
+  ts: string;
+};
+
+const QUEUE_FILE = 'leiao-event-queue';
+const SUPER_FILE = 'leiao-super-props';
+const MAX_QUEUE = 200;
+const FLUSH_AT = 10;
+const FLUSH_MS = 2000;
+
+function native(): {AppState?: {addEventListener: Function}} | null {
+  try {
+    return require('react-native');
+  } catch {
+    return null;
+  }
+}
+
+function newSessionId() {
+  const cryptoObj = (globalThis as unknown as {crypto?: {randomUUID?: () => string}}).crypto;
+  const uuid = cryptoObj?.randomUUID
+    ? cryptoObj.randomUUID()
+    : `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}`;
+  return `ses_${uuid.replace(/-/g, '')}`;
+}
+
+class AnalyticsModule implements LeiaoModule {
+  private userId = '';
+  private started = false;
+  private sessionOpen = false;
+  private sessionId = '';
+  private sessionStarted = 0;
+  private superProps: Record<string, unknown> = {};
+  private queue: Queued[] = [];
+  private flushing = false;
+  private timer: ReturnType<typeof setTimeout> | null = null;
+
+  configure(_config: LeiaoConfig): void {}
+
+  reset() {
+    this.userId = '';
+    this.started = false;
+    this.sessionOpen = false;
+    this.sessionId = '';
+    this.sessionStarted = 0;
+    this.superProps = {};
+    this.queue = [];
+    this.flushing = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+
+  identify(userId: string) {
+    this.userId = userId;
+  }
+
+  set(props: Record<string, unknown>) {
+    this.superProps = {...this.superProps, ...props};
+    writeJson(SUPER_FILE, this.superProps).catch(() => undefined);
+  }
+
+  unset(key: string) {
+    const next = {...this.superProps};
+    delete next[key];
+    this.superProps = next;
+    writeJson(SUPER_FILE, this.superProps).catch(() => undefined);
+  }
+
+  login(provider: string, extra: Record<string, unknown> = {}) {
+    this.track(ReservedEvents.login, {provider, ...extra}).catch(() => undefined);
+  }
+
+  screen(name: string, extra: Record<string, unknown> = {}) {
+    return this.track(ReservedEvents.screen, {name, ...extra});
+  }
+
+  async track(event: string, props: Record<string, unknown> = {}) {
+    const config = getConfig();
+    const profile = collectDeviceProfile();
+    const deviceId = getDeviceId() || (await deviceReady());
+    const durationMs = Number(props.durationMs || 0) || 0;
+    this.queue.push({
+      event,
+      props: {
+        ...this.superProps,
+        ...props,
+        sessionId: this.sessionId,
+        network: profile.network,
+      },
+      deviceId,
+      userId: this.userId,
+      platform: profile.platform,
+      appVersion: config.appVersion,
+      brand: profile.brand,
+      manufacturer: profile.manufacturer,
+      model: profile.model,
+      osName: profile.osName,
+      osVersion: profile.osVersion,
+      locale: profile.locale,
+      timezone: profile.timezone,
+      network: profile.network,
+      sessionId: this.sessionId,
+      durationMs,
+      ts: new Date().toISOString(),
+    });
+    if (this.queue.length > MAX_QUEUE) {
+      this.queue = this.queue.slice(-MAX_QUEUE);
+    }
+    writeJson(QUEUE_FILE, this.queue).catch(() => undefined);
+    if (this.queue.length >= FLUSH_AT) {
+      await this.flush();
+      return;
+    }
+    this.scheduleFlush();
+  }
+
+  async flush() {
+    if (this.flushing || !this.queue.length) {
+      return;
+    }
+    this.flushing = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const batch = this.queue.slice(0, 50);
+    this.queue = this.queue.slice(batch.length);
+    try {
+      await request('/v1/track', {method: 'POST', body: {events: batch}});
+      writeJson(QUEUE_FILE, this.queue).catch(() => undefined);
+    } catch {
+      this.queue = batch.concat(this.queue).slice(0, MAX_QUEUE);
+      writeJson(QUEUE_FILE, this.queue).catch(() => undefined);
+      this.scheduleFlush();
+    } finally {
+      this.flushing = false;
+      if (this.queue.length >= FLUSH_AT) {
+        this.flush().catch(() => undefined);
+      }
+    }
+  }
+
+  start() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
+    void this.boot();
+  }
+
+  private async boot() {
+    const [queued, stored] = await Promise.all([
+      readJson<Queued[]>(QUEUE_FILE, []),
+      readJson<Record<string, unknown>>(SUPER_FILE, {}),
+    ]);
+    this.queue = Array.isArray(queued) ? queued.slice(-MAX_QUEUE) : [];
+    this.superProps = stored && typeof stored === 'object' ? stored : {};
+    const found = getIdentity();
+    const current = getConfig().appVersion;
+    if (found?.isNew) {
+      await this.track(ReservedEvents.install, {first: true});
+    } else if (found?.previousVersion && found.previousVersion !== current) {
+      await this.track(ReservedEvents.update, {from: found.previousVersion, to: current});
+    }
+    this.openSession(true);
+    this.listenLifecycle();
+    await this.flush();
+  }
+
+  private openSession(cold: boolean) {
+    if (this.sessionOpen) {
+      return;
+    }
+    this.sessionOpen = true;
+    this.sessionId = newSessionId();
+    this.sessionStarted = Date.now();
+    this.track(ReservedEvents.start, {cold, sessionId: this.sessionId}).catch(() => undefined);
+  }
+
+  private closeSession() {
+    if (!this.sessionOpen) {
+      return;
+    }
+    this.sessionOpen = false;
+    const durationMs = Math.max(0, Date.now() - this.sessionStarted);
+    this.track(ReservedEvents.end, {sessionId: this.sessionId, durationMs}).catch(() => undefined);
+    this.flush().catch(() => undefined);
+  }
+
+  private scheduleFlush() {
+    if (this.timer) {
+      return;
+    }
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.flush().catch(() => undefined);
+    }, FLUSH_MS);
+  }
+
+  private listenLifecycle() {
+    const rn = native();
+    if (rn?.AppState) {
+      rn.AppState.addEventListener('change', (state: string) => {
+        if (state === 'background' || state === 'inactive') {
+          this.closeSession();
+        }
+        if (state === 'active') {
+          this.openSession(false);
+        }
+      });
+      return;
+    }
+    if (typeof document === 'undefined') {
+      return;
+    }
+    document.addEventListener('visibilitychange', () => {
+      if (document.hidden) {
+        this.closeSession();
+        return;
+      }
+      this.openSession(false);
+    });
+  }
+}
+
+export const analytics = new AnalyticsModule();

package/src/auth.ts

@@ -0,0 +1,93 @@
+import type {LeiaoConfig} from './core/config';
+import type {LeiaoModule} from './core/module';
+import {request} from './core/request';
+import {analytics, ReservedEvents} from './analytics';
+import {ready as deviceReady, getDeviceId} from './identity';
+import {push} from './push';
+
+class AuthModule implements LeiaoModule {
+  userId = '';
+
+  configure(config: LeiaoConfig): void {
+    const fromPush = config.push && typeof config.push === 'object' ? config.push.userId : '';
+    if (fromPush) {
+      this.userId = fromPush;
+    }
+  }
+
+  reset() {
+    this.userId = '';
+  }
+
+  async anonymous() {
+    const deviceId = await deviceReady();
+    const data = await request<{userId: string}>('/v1/auth/anonymous', {
+      method: 'POST',
+      body: {deviceId},
+    });
+    this.bind(data.userId);
+    return data;
+  }
+
+  async sendOtp(target: string, channel: 'sms' | 'email' = 'sms') {
+    return request('/v1/auth/otp/send', {method: 'POST', body: {target, channel}});
+  }
+
+  async verifyOtp(target: string, code: string, channel: 'sms' | 'email' = 'sms') {
+    const data = await request<{userId: string; provider: string}>('/v1/auth/otp/verify', {
+      method: 'POST',
+      body: {target, code, channel, deviceId: getDeviceId()},
+    });
+    this.bind(data.userId, data.provider || 'otp');
+    return data;
+  }
+
+  async wechat(code: string) {
+    const data = await request<{userId: string}>('/v1/auth/wechat', {
+      method: 'POST',
+      body: {code, deviceId: getDeviceId()},
+    });
+    this.bind(data.userId, 'wechat');
+    return data;
+  }
+
+  async apple(identityToken: string) {
+    const data = await request<{userId: string}>('/v1/auth/apple', {
+      method: 'POST',
+      body: {identityToken, deviceId: getDeviceId()},
+    });
+    this.bind(data.userId, 'apple');
+    return data;
+  }
+
+  async google(idToken: string) {
+    const data = await request<{userId: string}>('/v1/auth/google', {
+      method: 'POST',
+      body: {idToken, deviceId: getDeviceId()},
+    });
+    this.bind(data.userId, 'google');
+    return data;
+  }
+
+  async logout() {
+    await analytics.track(ReservedEvents.logout).catch(() => undefined);
+    const data = await request<{userId: string}>('/v1/auth/logout', {
+      method: 'POST',
+      body: {deviceId: getDeviceId()},
+    });
+    this.bind(data.userId);
+    return data;
+  }
+
+  private bind(userId: string, provider?: string) {
+    this.userId = userId;
+    analytics.identify(userId);
+    if (provider) {
+      analytics.login(provider);
+    }
+    push.userId = userId;
+    push.register().catch(() => undefined);
+  }
+}
+
+export const auth = new AuthModule();

package/src/core/config.ts

@@ -0,0 +1,122 @@
+export type HotUpdateOptions = {
+  /** 热更环境，只能是 production / staging，和安装渠道 channel 不是一回事。 */
+  channel?: 'production' | 'staging';
+  /** 热更安装完是否自动重启加载新包，默认 true。 */
+  restart?: boolean;
+};
+
+export type PushOptions = {
+  userId?: string;
+  deviceId?: string;
+  pollMs?: number;
+};
+
+export type ModuleName = 'hotUpdate' | 'push' | 'analytics' | 'auth';
+
+export type LeiaoConfig = {
+  serverUrl: string;
+  appKey?: string;
+  app?: string;
+  appVersion: string;
+  channel?: string;
+  deviceId?: string;
+  clientId?: string;
+  timeoutMs?: number;
+  modules?: ModuleName[];
+  hotUpdate?: boolean | HotUpdateOptions;
+  push?: boolean | PushOptions;
+  analytics?: boolean;
+  auth?: boolean;
+};
+
+let current: LeiaoConfig | null = null;
+
+function nativePlatform() {
+  try {
+    const rn = require('react-native') as {Platform?: {OS: string}};
+    return rn?.Platform?.OS || '';
+  } catch {
+    return '';
+  }
+}
+
+function enabled(value: unknown, fallback: boolean) {
+  if (value === false) {
+    return false;
+  }
+  if (value === undefined) {
+    return fallback;
+  }
+  return true;
+}
+
+export function resolveModules(config: LeiaoConfig): ModuleName[] {
+  if (config.modules?.length) {
+    return config.modules;
+  }
+  const native = nativePlatform() === 'ios' || nativePlatform() === 'android';
+  const names: ModuleName[] = [];
+  if (enabled(config.hotUpdate, native)) {
+    names.push('hotUpdate');
+  }
+  if (enabled(config.push, true)) {
+    names.push('push');
+  }
+  if (enabled(config.analytics, true)) {
+    names.push('analytics');
+  }
+  if (enabled(config.auth, true)) {
+    names.push('auth');
+  }
+  return names;
+}
+
+function resolveHotUpdate(config: LeiaoConfig): LeiaoConfig['hotUpdate'] {
+  if (config.hotUpdate === false) {
+    return undefined;
+  }
+  const fromInit =
+    config.channel === 'production' || config.channel === 'staging' ? config.channel : undefined;
+  const given = config.hotUpdate === true || config.hotUpdate === undefined ? {} : config.hotUpdate;
+  const channel = given.channel || fromInit || 'production';
+  if (channel !== 'production' && channel !== 'staging') {
+    throw new Error('hotUpdate.channel 只能是 production 或 staging');
+  }
+  return {...given, channel};
+}
+
+function resolveTimeout(value: unknown) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) {
+    return 12000;
+  }
+  return Math.min(60000, Math.max(1000, Math.round(n)));
+}
+
+export function setConfig(config: LeiaoConfig): LeiaoConfig {
+  const appKey = String(config.appKey || config.app || '').trim();
+  if (!config.serverUrl || !appKey || !config.appVersion) {
+    throw new Error('Leiao.init 需要 serverUrl、appKey、appVersion');
+  }
+  current = {
+    ...config,
+    timeoutMs: resolveTimeout(config.timeoutMs),
+    appKey,
+    modules: resolveModules(config),
+    serverUrl: config.serverUrl.replace(/\/$/, ''),
+    hotUpdate: resolveHotUpdate(config),
+    push: config.push === true ? {} : config.push === false ? undefined : config.push,
+  };
+  return current;
+}
+
+export function resetConfig() {
+  current = null;
+}
+
+export function getConfig(): LeiaoConfig {
+  if (!current) {
+    throw new Error('请先调用 Leiao.init({ serverUrl, appKey, appVersion })');
+  }
+  return current;
+}

package/src/core/index.ts

@@ -0,0 +1,4 @@
+export type {HotUpdateOptions, LeiaoConfig, ModuleName, PushOptions} from './config';
+export {getConfig, setConfig} from './config';
+export {request} from './request';
+export type {LeiaoModule} from './module';

package/src/core/module.ts

@@ -0,0 +1,5 @@
+import type {LeiaoConfig} from './config';
+
+export type LeiaoModule = {
+  configure(config: LeiaoConfig): void;
+};

package/src/core/request.ts

@@ -0,0 +1,84 @@
+import {getConfig} from './config';
+
+export type RequestOptions = Omit<RequestInit, 'body'> & {
+  query?: Record<string, string | number | boolean | undefined | null>;
+  body?: RequestInit['body'] | Record<string, unknown>;
+};
+
+export async function request<T>(path: string, options: RequestOptions = {}): Promise<T> {
+  const config = getConfig();
+  const {query, headers, body, ...init} = options;
+  const url = buildUrl(config.serverUrl, path, query);
+  const merged = new Headers(headers);
+  merged.set('x-app-key', config.appKey || '');
+  let payload = body;
+
+  if (body && typeof body === 'object' && !(body instanceof ArrayBuffer) && !isFetchBody(body)) {
+    merged.set('content-type', merged.get('content-type') || 'application/json');
+    payload = JSON.stringify(body);
+  }
+
+  let lastError: Error | null = null;
+  for (let attempt = 0; attempt <= 2; attempt += 1) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), config.timeoutMs || 12000);
+    try {
+      const response = await fetch(url, {
+        ...init,
+        headers: merged,
+        body: payload as RequestInit['body'],
+        signal: controller.signal,
+      });
+      const text = await response.text();
+      let data: {error?: string} = {};
+      try {
+        data = text ? (JSON.parse(text) as {error?: string}) : {};
+      } catch {
+        data = {};
+      }
+      if (!response.ok) {
+        const error = Object.assign(new Error(String(data.error || `请求失败 (${response.status})`)), {status: response.status});
+        throw error;
+      }
+      if (response.status === 204) {
+        return undefined as T;
+      }
+      return data as T;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const status = Number((error as {status?: number}).status || 0);
+      if (status >= 400 && status < 500 && status !== 429) {
+        throw lastError;
+      }
+      if (attempt < 2) {
+        await new Promise(resolve => setTimeout(resolve, 400 * (attempt + 1)));
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throw lastError || new Error('请求失败');
+}
+
+function buildUrl(serverUrl: string, path: string, query?: RequestOptions['query']): string {
+  const url = path.startsWith('http') ? path : `${serverUrl}${path.startsWith('/') ? '' : '/'}${path}`;
+  if (!query) {
+    return url;
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value != null && value !== '') {
+      params.set(key, String(value));
+    }
+  }
+  const qs = params.toString();
+  return qs ? `${url}${url.includes('?') ? '&' : '?'}${qs}` : url;
+}
+
+function isFetchBody(value: object): boolean {
+  return (
+    (typeof FormData !== 'undefined' && value instanceof FormData) ||
+    (typeof Blob !== 'undefined' && value instanceof Blob) ||
+    (typeof URLSearchParams !== 'undefined' && value instanceof URLSearchParams)
+  );
+}