leiao 1.0.0

package/src/push.ts

@@ -0,0 +1,239 @@
+import type {LeiaoConfig, PushOptions} from './core/config';
+import type {LeiaoModule} from './core/module';
+import {collectDeviceProfile, registerDevice} from './device';
+import {getDeviceId, ready as deviceReady} from './identity';
+import {updates} from './updates';
+import {request} from './core/request';
+import {readJson, writeJson} from './storage';
+
+const PUSH_FILE = 'leiao-push-state';
+
+export type PushMessage = {
+  id: string;
+  title: string;
+  body: string;
+  data: Record<string, string>;
+  extras?: Record<string, string>;
+  type?: string;
+  imageUrl?: string;
+  deepLink?: string;
+  sentAt: string;
+};
+
+export type PushListener = (message: PushMessage) => void;
+
+export type VendorTokenInput = {
+  channel?: string;
+  vendorToken?: string;
+  fcmToken?: string;
+  apnsToken?: string;
+  webPush?: unknown;
+};
+
+function native(): {AppState?: {addEventListener: Function}} | null {
+  try {
+    return require('react-native');
+  } catch {
+    return null;
+  }
+}
+
+class PushModule implements LeiaoModule {
+  private options: PushOptions = {};
+  private started = false;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private resumeBound = false;
+  private seen = new Set<string>();
+  private listeners = new Set<PushListener>();
+  private alias = '';
+  private tags: string[] = [];
+  private vendor: VendorTokenInput = {};
+  userId = '';
+
+  configure(config: LeiaoConfig): void {
+    this.options = config.push && typeof config.push === 'object' ? config.push : {};
+    if (this.options.userId) {
+      this.userId = this.options.userId;
+    }
+  }
+
+  reset() {
+    this.stop();
+    this.started = false;
+    this.resumeBound = false;
+    this.seen.clear();
+    this.alias = '';
+    this.tags = [];
+    this.vendor = {};
+    this.userId = '';
+    this.options = {};
+  }
+
+  detectBrand(): string {
+    return detectBrand();
+  }
+
+  onMessage(listener: PushListener): () => void {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  async start(): Promise<string> {
+    await this.restore();
+    const id = await this.register();
+    if (this.started) {
+      return id;
+    }
+    this.started = true;
+    this.armPoll();
+    const rn = native();
+    if (!this.resumeBound && rn?.AppState) {
+      this.resumeBound = true;
+      rn.AppState.addEventListener('change', (state: string) => {
+        if (state === 'active' && this.started) {
+          this.armPoll();
+          this.poll().catch(() => undefined);
+        }
+        if ((state === 'background' || state === 'inactive') && this.timer) {
+          clearInterval(this.timer);
+          this.timer = null;
+        }
+      });
+    }
+    return id;
+  }
+
+  stop(): void {
+    this.started = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  getDeviceId(): string {
+    return getDeviceId();
+  }
+
+  async ensureDeviceId(): Promise<string> {
+    return deviceReady();
+  }
+
+  async setAlias(alias: string): Promise<void> {
+    this.alias = String(alias || '').trim();
+    await this.persist();
+    await this.register();
+  }
+
+  async setTags(tags: string[]): Promise<void> {
+    this.tags = tags.map(item => String(item || '').trim()).filter(Boolean);
+    await this.persist();
+    await this.register();
+  }
+
+  async setVendorToken(input: VendorTokenInput): Promise<void> {
+    this.vendor = {...this.vendor, ...input};
+    await this.persist();
+    await this.register();
+  }
+
+  async register(): Promise<string> {
+    let bundleVersion = 0;
+    try {
+      bundleVersion = await updates.getInstalledVersion();
+    } catch {
+      bundleVersion = 0;
+    }
+    const deviceId = await registerDevice({
+      userId: this.userId || this.options.userId || '',
+      alias: this.alias,
+      tags: this.tags,
+      vendorChannel: this.vendor.channel || '',
+      vendorToken: this.vendor.vendorToken || '',
+      fcmToken: this.vendor.fcmToken || '',
+      apnsToken: this.vendor.apnsToken || '',
+      webPush: this.vendor.webPush,
+      bundleVersion,
+    });
+    await this.poll();
+    return deviceId;
+  }
+
+  async poll(): Promise<PushMessage[]> {
+    const deviceId = getDeviceId();
+    if (!deviceId) {
+      return [];
+    }
+    const result = await request<{messages: PushMessage[]}>('/v1/push/inbox', {
+      query: {deviceId},
+    });
+    const messages = result.messages || [];
+    const fresh = messages.filter(item => !this.seen.has(item.id));
+    if (fresh.length) {
+      const ids = fresh.map(item => item.id);
+      for (const item of fresh) {
+        this.seen.add(item.id);
+        for (const listener of this.listeners) {
+          listener(item);
+        }
+        this.report(item.id, 'arrive').catch(() => undefined);
+      }
+      await request('/v1/push/ack', {
+        method: 'POST',
+        body: {deviceId, messageIds: ids},
+      }).catch(() => undefined);
+    }
+    return messages;
+  }
+
+  async click(messageId: string): Promise<void> {
+    await this.report(messageId, 'click');
+  }
+
+  private async report(messageId: string, type: 'arrive' | 'click'): Promise<void> {
+    const deviceId = getDeviceId();
+    if (!deviceId || !messageId) {
+      return;
+    }
+    await request('/v1/push/events', {
+      method: 'POST',
+      body: {deviceId, messageId, type},
+    });
+  }
+
+  private async restore() {
+    const stored = await readJson<{alias?: string; tags?: string[]; vendor?: VendorTokenInput}>(PUSH_FILE, {});
+    if (stored.alias && !this.alias) {
+      this.alias = String(stored.alias);
+    }
+    if ((!this.tags.length) && Array.isArray(stored.tags)) {
+      this.tags = stored.tags.map(item => String(item || '').trim()).filter(Boolean);
+    }
+    if (stored.vendor && typeof stored.vendor === 'object') {
+      this.vendor = {...stored.vendor, ...this.vendor};
+    }
+  }
+
+  private persist() {
+    return writeJson(PUSH_FILE, {alias: this.alias, tags: this.tags, vendor: this.vendor});
+  }
+
+  private armPoll(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+    const ms = Math.max(this.options.pollMs || 8000, 3000);
+    this.timer = setInterval(() => {
+      this.poll().catch(() => undefined);
+    }, ms);
+  }
+}
+
+export const push = new PushModule();
+
+export function detectBrand(): string {
+  return collectDeviceProfile().brand;
+}
+

package/src/runtime.ts

@@ -0,0 +1,124 @@
+import {getConfig, resetConfig, setConfig, type LeiaoConfig, type ModuleName} from './core/config';
+import type {LeiaoModule} from './core/module';
+import {analytics} from './analytics';
+import {auth} from './auth';
+import {updates} from './updates';
+import {getDeviceProfile, registerDevice, watchNetwork} from './device';
+import {configureIdentity, getDeviceId, ready as deviceReady, resetIdentity} from './identity';
+import {push} from './push';
+import {clearMemoryStorage} from './storage';
+
+export type InitResult = {
+  deviceId: string;
+  userId: string;
+};
+
+const all: Record<ModuleName, LeiaoModule & {start?: () => unknown; reset?: () => void}> = {
+  hotUpdate: updates,
+  push,
+  analytics,
+  auth,
+};
+
+let resumeBound = false;
+
+async function retry<T>(fn: () => Promise<T>, attempts = 3): Promise<T> {
+  let last: Error | undefined;
+  for (let index = 0; index < attempts; index += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      last = error instanceof Error ? error : new Error(String(error));
+      if (index < attempts - 1) {
+        await new Promise(resolve => setTimeout(resolve, 200 * (index + 1)));
+      }
+    }
+  }
+  throw last || new Error('请求失败');
+}
+
+async function startModules(selected: ModuleName[]) {
+  if (selected.includes('auth')) {
+    await retry(() => auth.anonymous());
+  }
+  await retry(() => registerDevice({userId: auth.userId}));
+  if (selected.includes('analytics')) {
+    analytics.start();
+  }
+  if (selected.includes('push')) {
+    await retry(() => push.start());
+  }
+  if (selected.includes('hotUpdate')) {
+    updates.start();
+  }
+}
+
+function bindResume() {
+  if (resumeBound) {
+    return;
+  }
+  resumeBound = true;
+  try {
+    const rn = require('react-native') as {AppState?: {addEventListener: Function}};
+    rn?.AppState?.addEventListener('change', (state: string) => {
+      if (state !== 'active') {
+        return;
+      }
+      registerDevice({userId: auth.userId}).catch(() => undefined);
+      analytics.flush().catch(() => undefined);
+    });
+  } catch {
+    if (typeof document === 'undefined') {
+      return;
+    }
+    document.addEventListener('visibilitychange', () => {
+      if (!document.hidden) {
+        registerDevice({userId: auth.userId}).catch(() => undefined);
+        analytics.flush().catch(() => undefined);
+      }
+    });
+  }
+}
+
+export function resetLeiao() {
+  analytics.reset();
+  auth.reset();
+  push.reset();
+  updates.reset();
+  resetIdentity();
+  resetConfig();
+  clearMemoryStorage();
+  resumeBound = false;
+}
+
+export const Leiao = {
+  init(config: LeiaoConfig): Promise<InitResult> {
+    analytics.reset();
+    auth.reset();
+    push.reset();
+    updates.reset();
+    const next = setConfig(config);
+    configureIdentity(next);
+    const selected = next.modules || [];
+    for (const name of selected) {
+      all[name]?.configure(next);
+    }
+    return deviceReady().then(async deviceId => {
+      watchNetwork();
+      await retry(() => registerDevice());
+      await startModules(selected);
+      bindResume();
+      return {deviceId, userId: auth.userId};
+    });
+  },
+  reset: resetLeiao,
+  ready: deviceReady,
+  getDeviceId,
+  getDeviceProfile,
+  getUserId: () => auth.userId,
+  getConfig,
+  updates,
+  push,
+  analytics,
+  auth,
+};

package/src/storage.ts

@@ -0,0 +1,82 @@
+function webStorage() {
+  try {
+    return (
+      (globalThis as unknown as {localStorage?: {getItem(key: string): string | null; setItem(key: string, value: string): void}})
+        .localStorage || null
+    );
+  } catch {
+    return null;
+  }
+}
+
+function blobUtil() {
+  try {
+    return require('react-native-blob-util').default as {
+      fs: {dirs: {DocumentDir?: string}; exists: (path: string) => Promise<boolean>; readFile: Function; writeFile: Function};
+    };
+  } catch {
+    return null;
+  }
+}
+
+const memory = new Map<string, string>();
+
+export function clearMemoryStorage() {
+  memory.clear();
+}
+
+export async function readText(name: string): Promise<string> {
+  const storage = webStorage();
+  if (storage) {
+    return storage.getItem(name) || '';
+  }
+  const util = blobUtil();
+  const dir = util?.fs.dirs.DocumentDir;
+  if (!util || !dir) {
+    return memory.get(name) || '';
+  }
+  const file = `${dir}/${name}`;
+  try {
+    if (!(await util.fs.exists(file))) {
+      return '';
+    }
+    return String(await util.fs.readFile(file, 'utf8')).trim();
+  } catch {
+    return '';
+  }
+}
+
+export async function writeText(name: string, value: string): Promise<void> {
+  const storage = webStorage();
+  if (storage) {
+    storage.setItem(name, value);
+    return;
+  }
+  const util = blobUtil();
+  const dir = util?.fs.dirs.DocumentDir;
+  if (!util || !dir) {
+    memory.set(name, value);
+    return;
+  }
+  try {
+    await util.fs.writeFile(`${dir}/${name}`, value, 'utf8');
+  } catch {
+    memory.set(name, value);
+  }
+}
+
+export async function readJson<T>(name: string, fallback: T): Promise<T> {
+  const raw = await readText(name);
+  if (!raw) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(raw) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+export async function writeJson(name: string, value: unknown): Promise<void> {
+  await writeText(name, JSON.stringify(value));
+}