leiao 1.0.0

package/src/device.ts

@@ -0,0 +1,373 @@
+import {getConfig} from './core/config';
+import {request} from './core/request';
+import {ready as deviceReady} from './identity';
+
+export type DeviceProfile = {
+  platform: 'ios' | 'android' | 'web';
+  brand: string;
+  manufacturer: string;
+  model: string;
+  osName: string;
+  osVersion: string;
+  locale: string;
+  timezone: string;
+  screen: string;
+  network: string;
+  channel: string;
+  debug: boolean;
+  isEmulator: boolean;
+  isTablet: boolean;
+};
+
+type Rn = {
+  Platform?: {
+    OS: string;
+    Version?: string | number;
+    isPad?: boolean;
+    constants?: Record<string, unknown>;
+  };
+  Dimensions?: {get: (key: string) => {width: number; height: number}};
+  PixelRatio?: {get: () => number};
+  I18nManager?: {localeIdentifier?: string; getConstants?: () => {localeIdentifier?: string}};
+};
+
+type Extra = {
+  userId?: string;
+  alias?: string;
+  tags?: string[];
+  vendorChannel?: string;
+  vendorToken?: string;
+  fcmToken?: string;
+  apnsToken?: string;
+  webPush?: unknown;
+  bundleVersion?: number;
+};
+
+let cached: Omit<DeviceProfile, 'network' | 'channel'> | null = null;
+let network = '';
+let networkWatching = false;
+
+function native(): Rn | null {
+  try {
+    return require('react-native');
+  } catch {
+    return null;
+  }
+}
+
+function text(value: unknown) {
+  return String(value || '').trim();
+}
+
+function timezone() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || '';
+  } catch {
+    return '';
+  }
+}
+
+function localeOf(rn: Rn | null) {
+  const fromI18n = text(rn?.I18nManager?.getConstants?.()?.localeIdentifier || rn?.I18nManager?.localeIdentifier);
+  if (fromI18n) {
+    return fromI18n.replace('_', '-');
+  }
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().locale || '';
+  } catch {
+    return typeof navigator !== 'undefined' ? text(navigator.language) : '';
+  }
+}
+
+function screenOf(rn: Rn | null) {
+  try {
+    const size = rn?.Dimensions?.get('screen');
+    const scale = rn?.PixelRatio?.get() || 1;
+    if (size) {
+      return `${Math.round(size.width)}x${Math.round(size.height)}@${scale}`;
+    }
+  } catch {
+    //
+  }
+  const screen = (globalThis as {screen?: {width?: number; height?: number}}).screen;
+  if (screen?.width && screen?.height) {
+    return `${Math.round(screen.width)}x${Math.round(screen.height)}`;
+  }
+  return '';
+}
+
+function isDebug() {
+  return typeof __DEV__ !== 'undefined' && Boolean(__DEV__);
+}
+
+function isEmulator(constants: Record<string, unknown>, platform: string, model: string) {
+  const info = optionalInfo();
+  if (typeof info?.isEmulatorSync === 'function') {
+    try {
+      return Boolean(info.isEmulatorSync());
+    } catch {
+      //
+    }
+  }
+  if (platform !== 'android') {
+    return false;
+  }
+  const fingerprint = text(constants.Fingerprint).toLowerCase();
+  const key = `${model} ${text(constants.Brand)} ${text(constants.Product)}`.toLowerCase();
+  return fingerprint.includes('generic') || fingerprint.includes('emulator') || key.includes('sdk') || key.includes('emulator');
+}
+
+function isTablet(rn: Rn, platform: string) {
+  if (platform === 'ios') {
+    return Boolean(rn.Platform?.isPad);
+  }
+  try {
+    const size = rn.Dimensions?.get('screen');
+    if (size) {
+      return Math.min(size.width, size.height) >= 600;
+    }
+  } catch {
+    //
+  }
+  return text(rn.Platform?.constants?.uiMode).toLowerCase() === 'tablet';
+}
+
+function optionalInfo() {
+  try {
+    return require('react-native-device-info') as {
+      getBrand?: () => string;
+      getModel?: () => string;
+      getSystemName?: () => string;
+      getSystemVersion?: () => string;
+      getManufacturerSync?: () => string;
+      getDeviceId?: () => string;
+      isEmulatorSync?: () => boolean;
+    };
+  } catch {
+    return null;
+  }
+}
+
+function optionalNetInfo() {
+  try {
+    return require('@react-native-community/netinfo').default as {
+      fetch: () => Promise<{type?: string}>;
+      addEventListener: (fn: (state: {type?: string}) => void) => void;
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function watchNetwork() {
+  if (networkWatching) {
+    return;
+  }
+  networkWatching = true;
+  const net = optionalNetInfo();
+  if (!net) {
+    return;
+  }
+  net.fetch().then(state => {
+    network = text(state?.type);
+  }).catch(() => undefined);
+  net.addEventListener(state => {
+    network = text(state?.type);
+  });
+}
+
+function normalizeBrand(raw: string, platform: string) {
+  if (platform === 'web') {
+    return 'web';
+  }
+  if (platform === 'ios') {
+    return 'apple';
+  }
+  const key = raw.toLowerCase().replace(/[^a-z0-9]+/g, '');
+  const aliases: Array<[string, string]> = [
+    ['huawei', 'huawei'],
+    ['honor', 'honor'],
+    ['xiaomi', 'xiaomi'],
+    ['redmi', 'xiaomi'],
+    ['poco', 'xiaomi'],
+    ['oppo', 'oppo'],
+    ['oneplus', 'oppo'],
+    ['realme', 'oppo'],
+    ['vivo', 'vivo'],
+    ['iqoo', 'vivo'],
+    ['meizu', 'meizu'],
+    ['samsung', 'samsung'],
+    ['google', 'google'],
+    ['pixel', 'google'],
+  ];
+  for (const [alias, brand] of aliases) {
+    if (key.includes(alias)) {
+      return brand;
+    }
+  }
+  return key ? 'other' : 'other';
+}
+
+function webProfile(): DeviceProfile {
+  const nav = globalThis.navigator as
+    | {userAgent?: string; language?: string; userAgentData?: {platform?: string}}
+    | undefined;
+  const ua = text(nav?.userAgent);
+  let osName = 'Web';
+  let osVersion = '';
+  if (/Windows NT 10/i.test(ua)) {
+    osName = 'Windows';
+    osVersion = '10+';
+  } else if (/Mac OS X (\d+[._]\d+)/i.test(ua)) {
+    osName = 'macOS';
+    osVersion = RegExp.$1.replace('_', '.');
+  } else if (/Android (\d+(?:\.\d+)?)/i.test(ua)) {
+    osName = 'Android';
+    osVersion = RegExp.$1;
+  } else if (/CPU (?:iPhone )?OS (\d+[._]\d+)/i.test(ua)) {
+    osName = 'iOS';
+    osVersion = RegExp.$1.replace('_', '.');
+  } else if (nav?.userAgentData?.platform) {
+    osName = String(nav.userAgentData.platform);
+  }
+  let model = 'Browser';
+  if (/Edg\//.test(ua)) {
+    model = 'Edge';
+  } else if (/Chrome\//.test(ua)) {
+    model = 'Chrome';
+  } else if (/Safari\//.test(ua) && !/Chrome\//.test(ua)) {
+    model = 'Safari';
+  } else if (/Firefox\//.test(ua)) {
+    model = 'Firefox';
+  }
+  return {
+    platform: 'web',
+    brand: 'web',
+    manufacturer: 'web',
+    model,
+    osName,
+    osVersion,
+    locale: localeOf(null),
+    timezone: timezone(),
+    screen: screenOf(null),
+    network: '',
+    channel: '',
+    debug: isDebug(),
+    isEmulator: false,
+    isTablet: false,
+  };
+}
+
+function iosModel(constants: Record<string, unknown>, isPad?: boolean) {
+  const idiom = text(constants.interfaceIdiom).toLowerCase();
+  if (idiom === 'pad' || isPad) {
+    return 'iPad';
+  }
+  if (idiom === 'tv') {
+    return 'Apple TV';
+  }
+  if (idiom === 'vision') {
+    return 'Apple Vision';
+  }
+  return 'iPhone';
+}
+
+export function collectDeviceProfile(): DeviceProfile {
+  const live = liveFields();
+  if (!cached) {
+    cached = collectStatic();
+  }
+  return {...cached, ...live};
+}
+
+function liveFields() {
+  let current = network;
+  if (!current && typeof navigator !== 'undefined') {
+    const connection = (navigator as {connection?: {effectiveType?: string}; onLine?: boolean}).connection;
+    if (navigator.onLine === false) {
+      current = 'none';
+    } else {
+      current = text(connection?.effectiveType) || (navigator.onLine ? 'online' : '');
+    }
+  }
+  let channel = '';
+  try {
+    channel = String(getConfig().channel || '');
+  } catch {
+    channel = '';
+  }
+  return {network: current, channel};
+}
+
+function collectStatic(): Omit<DeviceProfile, 'network' | 'channel'> {
+  const rn = native();
+  if (!rn?.Platform) {
+    const web = webProfile();
+    const {network: _n, channel: _c, ...rest} = web;
+    return rest;
+  }
+  const os = rn.Platform.OS;
+  const platform = os === 'android' ? 'android' : os === 'ios' ? 'ios' : 'web';
+  if (platform === 'web') {
+    const web = webProfile();
+    const {network: _n, channel: _c, ...rest} = web;
+    return rest;
+  }
+  const constants = rn.Platform.constants || {};
+  const info = optionalInfo();
+  const manufacturer = text(
+    info?.getManufacturerSync?.() ||
+      info?.getBrand?.() ||
+      constants.Manufacturer ||
+      constants.Brand ||
+      (platform === 'ios' ? 'Apple' : ''),
+  );
+  const model = text(
+    info?.getModel?.() ||
+      constants.Model ||
+      constants.model ||
+      info?.getDeviceId?.() ||
+      (platform === 'ios' ? iosModel(constants, rn.Platform.isPad) : ''),
+  );
+  const osName = text(info?.getSystemName?.() || constants.systemName || (platform === 'ios' ? 'iOS' : 'Android'));
+  const osVersion = text(
+    info?.getSystemVersion?.() ||
+      constants.osVersion ||
+      constants.Release ||
+      (platform === 'android' ? constants.Release : rn.Platform.Version),
+  );
+  return {
+    platform,
+    brand: normalizeBrand(manufacturer || model, platform),
+    manufacturer: manufacturer || (platform === 'ios' ? 'Apple' : ''),
+    model,
+    osName,
+    osVersion,
+    locale: localeOf(rn),
+    timezone: timezone(),
+    screen: screenOf(rn),
+    debug: isDebug(),
+    isEmulator: isEmulator(constants, platform, model),
+    isTablet: isTablet(rn, platform),
+  };
+}
+
+export function getDeviceProfile() {
+  return collectDeviceProfile();
+}
+
+export async function registerDevice(extra: Extra = {}) {
+  const config = getConfig();
+  const deviceId = await deviceReady();
+  const profile = collectDeviceProfile();
+  await request('/v1/devices/register', {
+    method: 'POST',
+    body: {
+      deviceId,
+      appVersion: config.appVersion,
+      ...profile,
+      ...extra,
+    },
+  });
+  return deviceId;
+}

package/src/identity.ts

@@ -0,0 +1,112 @@
+import type {LeiaoConfig} from './core/config';
+import {readText, writeText} from './storage';
+
+const DEVICE_FILE = 'leiao-device-id';
+
+export type DeviceIdentity = {
+  deviceId: string;
+  isNew: boolean;
+  previousVersion: string;
+};
+
+type Stored = {
+  deviceId: string;
+  appVersion: string;
+};
+
+let cached = '';
+let pending: Promise<string> | null = null;
+let override = '';
+let appVersion = '';
+let identity: DeviceIdentity | null = null;
+
+export function configureIdentity(config: LeiaoConfig) {
+  appVersion = String(config.appVersion || '');
+  const fromPush = config.push && typeof config.push === 'object' ? config.push.deviceId : '';
+  override = String(config.deviceId || config.clientId || fromPush || '').trim();
+  pending = null;
+  cached = override;
+  identity = null;
+}
+
+export function resetIdentity() {
+  cached = '';
+  pending = null;
+  override = '';
+  appVersion = '';
+  identity = null;
+}
+
+export function getDeviceId() {
+  return cached;
+}
+
+export function getIdentity() {
+  return identity;
+}
+
+export function ready(): Promise<string> {
+  if (cached && identity) {
+    return Promise.resolve(cached);
+  }
+  if (!pending) {
+    pending = loadOrCreate().catch(error => {
+      pending = null;
+      throw error;
+    });
+  }
+  return pending;
+}
+
+function newDeviceId() {
+  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 `dev_${uuid.replace(/-/g, '')}`;
+}
+
+function parseStored(raw: string): Stored | null {
+  const text = String(raw || '').trim();
+  if (!text) {
+    return null;
+  }
+  if (text.startsWith('{')) {
+    try {
+      const data = JSON.parse(text) as Partial<Stored>;
+      if (data.deviceId) {
+        return {deviceId: String(data.deviceId), appVersion: String(data.appVersion || '')};
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  return {deviceId: text, appVersion: ''};
+}
+
+async function loadOrCreate() {
+  if (override) {
+    cached = override;
+    identity = {deviceId: override, isNew: false, previousVersion: ''};
+    await persist(cached, appVersion);
+    return cached;
+  }
+  const stored = parseStored(await readText(DEVICE_FILE));
+  if (stored) {
+    cached = stored.deviceId;
+    identity = {deviceId: cached, isNew: false, previousVersion: stored.appVersion};
+    if (stored.appVersion !== appVersion) {
+      await persist(cached, appVersion);
+    }
+    return cached;
+  }
+  cached = newDeviceId();
+  identity = {deviceId: cached, isNew: true, previousVersion: ''};
+  await persist(cached, appVersion);
+  return cached;
+}
+
+async function persist(deviceId: string, version: string) {
+  await writeText(DEVICE_FILE, JSON.stringify({deviceId, appVersion: version} satisfies Stored));
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+export type {HotUpdateOptions, LeiaoConfig, PushOptions} from './core/config';
+export type {
+  CheckResponse,
+  HotUpdateInfo,
+  NoUpdateInfo,
+  PromptTheme,
+  StoreUpdateInfo,
+  UpdateState,
+  UpdateStateListener,
+} from './updates/types';
+export type {UpdatePromptContext, UpdatePromptProps, UpdatePromptTheme} from './update-ui';
+export {UpdatePrompt} from './update-ui';
+export type {PushListener, PushMessage, VendorTokenInput} from './push';
+export {ReservedEvents, analytics} from './analytics';
+export type {DeviceIdentity} from './identity';
+export type {DeviceProfile} from './device';
+export {auth} from './auth';
+export {updates} from './updates';
+export {push, detectBrand} from './push';
+export type {InitResult} from './runtime';
+
+import {Leiao as Runtime} from './runtime';
+import {UpdatePrompt} from './update-ui';
+
+export const Leiao = {
+  ...Runtime,
+  UpdatePrompt,
+};

package/src/modules/push.ts

@@ -0,0 +1,2 @@
+export {detectBrand, push} from '../push';
+export type {PushListener, PushMessage, VendorTokenInput} from '../push';