@appthen/sdk-web 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @appthen/sdk-web
+ *
+ * V0 Web 适配：
+ * - HttpAdapter: fetch
+ * - AuthProvider: localStorage / memory
+ * - RealtimeAdapter: socket.io conversation room adapter
+ */
+import { ChatHubClient, type AuthProvider, type HttpAdapter, type HttpRequestOptions, type HttpResponse, type RealtimeAdapter, type RealtimeSubscription } from '@appthen/sdk-core';
+export { SDK_VERSION } from '@appthen/sdk-core';
+export * from '@appthen/sdk-core';
+export declare class FetchHttpAdapter implements HttpAdapter {
+    private readonly baseUrl;
+    constructor(baseUrl: string);
+    request<T>(options: HttpRequestOptions): Promise<HttpResponse<T>>;
+}
+export declare class LocalStorageAuthProvider implements AuthProvider {
+    private readonly storageKey;
+    constructor(storageKey?: string);
+    getToken(): Promise<string | null>;
+    setToken(token: string | null): Promise<void>;
+}
+export declare class MemoryAuthProvider implements AuthProvider {
+    private token;
+    constructor(token?: string | null);
+    getToken(): Promise<string | null>;
+    setToken(token: string | null): Promise<void>;
+}
+export declare class NoopRealtimeAdapter implements RealtimeAdapter {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+}
+export interface ConversationSocketEvent {
+    eventName?: string;
+    room?: string;
+    conversationId?: string;
+    message?: unknown;
+    userId?: string;
+    participants?: string[];
+    participantCount?: number;
+    isTyping?: boolean;
+    senderSubjectId?: string;
+    messageId?: string;
+    readAt?: string;
+    [key: string]: unknown;
+}
+export interface SocketIoConversationRealtimeAdapterOptions {
+    url: string;
+    account?: () => string | null | Promise<string | null>;
+    roomPrefix?: string;
+    eventName?: string;
+}
+export declare class SocketIoConversationRealtimeAdapter implements RealtimeAdapter {
+    private readonly options;
+    private socket;
+    private connectPromise;
+    private activeRooms;
+    private subscriptions;
+    private globalListeners;
+    constructor(options: SocketIoConversationRealtimeAdapterOptions);
+    private get roomPrefix();
+    private get messageEventName();
+    private getConversationRoom;
+    private getAccount;
+    private ensureSocket;
+    private emitJoin;
+    private emitLeave;
+    private joinActiveRooms;
+    connect(token?: string | null): Promise<void>;
+    disconnect(): Promise<void>;
+    /**
+     * 加入任意房间（如跨设备同步用的同主体设备房间）。纳入 activeRooms 引用计数，
+     * 断线重连时会自动重新加入。
+     */
+    joinRoom(room: string): Promise<void>;
+    leaveRoom(room: string): Promise<void>;
+    /**
+     * 注册全局 socket 事件监听（所有房间均会转发），返回退订函数。
+     * 用于接收跨设备同步等非会话作用域的事件。
+     */
+    onGlobalEvent(handler: (event: Record<string, unknown>) => void): () => void;
+    subscribeConversation(conversationId: string): Promise<RealtimeSubscription<ConversationSocketEvent>>;
+    publishConversationEvent(conversationId: string, event: Record<string, unknown>): Promise<void>;
+}
+export interface CreateWebChatHubClientOptions {
+    baseUrl: string;
+    auth?: AuthProvider;
+    realtime?: RealtimeAdapter;
+}
+export declare function createChatHubClient(options: CreateWebChatHubClientOptions): ChatHubClient;

package/dist/index.js

@@ -0,0 +1,396 @@
+/**
+ * @appthen/sdk-web
+ *
+ * V0 Web 适配：
+ * - HttpAdapter: fetch
+ * - AuthProvider: localStorage / memory
+ * - RealtimeAdapter: socket.io conversation room adapter
+ */
+import { io } from 'socket.io-client';
+import { ChatHubClient, } from '@appthen/sdk-core';
+export { SDK_VERSION } from '@appthen/sdk-core';
+export * from '@appthen/sdk-core';
+function joinUrl(baseUrl, path) {
+    if (/^https?:\/\//.test(path)) {
+        return path;
+    }
+    const normalizedBase = baseUrl.replace(/\/+$/, '');
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${normalizedBase}${normalizedPath}`;
+}
+function appendQuery(url, query) {
+    if (!query) {
+        return url;
+    }
+    const params = new URLSearchParams();
+    Object.entries(query).forEach(([key, value]) => {
+        if (value === undefined) {
+            return;
+        }
+        params.set(key, String(value));
+    });
+    const serialized = params.toString();
+    return serialized ? `${url}?${serialized}` : url;
+}
+function isJsonResponse(contentType) {
+    return typeof contentType === 'string' && contentType.includes('application/json');
+}
+export class FetchHttpAdapter {
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl;
+    }
+    async request(options) {
+        const url = appendQuery(joinUrl(this.baseUrl, options.path), options.query);
+        const response = await fetch(url, {
+            method: options.method,
+            headers: {
+                ...(options.body ? { 'Content-Type': 'application/json' } : {}),
+                ...(options.headers || {}),
+            },
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+        });
+        const contentType = response.headers.get('content-type');
+        const data = isJsonResponse(contentType)
+            ? (await response.json())
+            : (await response.text());
+        if (!response.ok) {
+            const error = new Error(`HTTP ${response.status} for ${options.method} ${options.path}`);
+            error.response = data;
+            throw error;
+        }
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        return {
+            status: response.status,
+            data,
+            headers,
+        };
+    }
+}
+export class LocalStorageAuthProvider {
+    constructor(storageKey = 'chat-hub:token') {
+        this.storageKey = storageKey;
+    }
+    async getToken() {
+        if (typeof globalThis.localStorage === 'undefined') {
+            return null;
+        }
+        return globalThis.localStorage.getItem(this.storageKey);
+    }
+    async setToken(token) {
+        if (typeof globalThis.localStorage === 'undefined') {
+            return;
+        }
+        if (token) {
+            globalThis.localStorage.setItem(this.storageKey, token);
+        }
+        else {
+            globalThis.localStorage.removeItem(this.storageKey);
+        }
+    }
+}
+export class MemoryAuthProvider {
+    constructor(token = null) {
+        this.token = token;
+    }
+    async getToken() {
+        return this.token;
+    }
+    async setToken(token) {
+        this.token = token;
+    }
+}
+export class NoopRealtimeAdapter {
+    async connect() {
+        return;
+    }
+    async disconnect() {
+        return;
+    }
+}
+class SocketConversationSubscription {
+    constructor(onClose) {
+        this.onClose = onClose;
+        this.queue = [];
+        this.waiters = [];
+        this.closed = false;
+    }
+    push(event) {
+        if (this.closed) {
+            return;
+        }
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter({ value: event, done: false });
+            return;
+        }
+        this.queue.push(event);
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        await this.onClose();
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter?.({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                if (this.queue.length > 0) {
+                    return {
+                        value: this.queue.shift(),
+                        done: false,
+                    };
+                }
+                if (this.closed) {
+                    return {
+                        value: undefined,
+                        done: true,
+                    };
+                }
+                return new Promise((resolve) => {
+                    this.waiters.push(resolve);
+                });
+            },
+            return: async () => {
+                await this.close();
+                return {
+                    value: undefined,
+                    done: true,
+                };
+            },
+        };
+    }
+}
+export class SocketIoConversationRealtimeAdapter {
+    constructor(options) {
+        this.options = options;
+        this.socket = null;
+        this.connectPromise = null;
+        this.activeRooms = new Map();
+        this.subscriptions = new Map();
+        this.globalListeners = new Set();
+    }
+    get roomPrefix() {
+        return this.options.roomPrefix || 'hub:conversation:';
+    }
+    get messageEventName() {
+        return this.options.eventName || 'message';
+    }
+    getConversationRoom(conversationId) {
+        return `${this.roomPrefix}${conversationId}`;
+    }
+    async getAccount() {
+        return (await this.options.account?.()) || 'anonymous';
+    }
+    async ensureSocket(token) {
+        if (this.socket?.connected) {
+            return this.socket;
+        }
+        if (this.connectPromise) {
+            await this.connectPromise;
+            return this.socket;
+        }
+        this.connectPromise = new Promise((resolve, reject) => {
+            const socket = io(this.options.url, {
+                autoConnect: false,
+                transports: ['websocket'],
+                query: token ? { token } : {},
+            });
+            const cleanup = () => {
+                socket.off('connect', handleConnect);
+                socket.off('connect_error', handleError);
+            };
+            const handleConnect = async () => {
+                cleanup();
+                this.socket = socket;
+                socket.on(this.messageEventName, (payload) => {
+                    const evtName = payload && typeof payload === 'object'
+                        ? payload.eventName
+                        : undefined;
+                    if (typeof console !== 'undefined') {
+                        console.info('[chat-hub-realtime] message event', String(evtName || '?'), payload?.room || '');
+                    }
+                    this.globalListeners.forEach((listener) => listener(payload));
+                    const room = payload?.room;
+                    if (!room) {
+                        return;
+                    }
+                    const roomSubscriptions = this.subscriptions.get(room);
+                    if (!roomSubscriptions || roomSubscriptions.size === 0) {
+                        return;
+                    }
+                    roomSubscriptions.forEach((subscription) => {
+                        subscription.push(payload);
+                    });
+                });
+                socket.on('connect', async () => {
+                    await this.joinActiveRooms();
+                });
+                await this.joinActiveRooms();
+                resolve();
+            };
+            const handleError = (error) => {
+                cleanup();
+                socket.close();
+                reject(error);
+            };
+            socket.once('connect', handleConnect);
+            socket.once('connect_error', handleError);
+            socket.connect();
+        });
+        try {
+            await this.connectPromise;
+        }
+        finally {
+            this.connectPromise = null;
+        }
+        return this.socket;
+    }
+    async emitJoin(room) {
+        const socket = this.socket;
+        if (!socket?.connected) {
+            // 连接未就绪时等待就绪后再 join，避免静默跳过导致收不到房间事件
+            try {
+                await this.ensureSocket();
+            }
+            catch {
+                return;
+            }
+            const readySocket = this.socket;
+            if (!readySocket?.connected) {
+                if (typeof console !== 'undefined') {
+                    console.warn('[chat-hub-realtime] join skipped: socket not connected', room);
+                }
+                return;
+            }
+            readySocket.emit('join', {
+                room,
+                account: await this.getAccount(),
+            });
+            if (typeof console !== 'undefined') {
+                console.info('[chat-hub-realtime] joined room', room);
+            }
+            return;
+        }
+        socket.emit('join', {
+            room,
+            account: await this.getAccount(),
+        });
+        if (typeof console !== 'undefined') {
+            console.info('[chat-hub-realtime] joined room', room);
+        }
+    }
+    async emitLeave(room) {
+        const socket = this.socket;
+        if (!socket?.connected) {
+            return;
+        }
+        socket.emit('leave', {
+            room,
+            account: await this.getAccount(),
+        });
+    }
+    async joinActiveRooms() {
+        await Promise.all(Array.from(this.activeRooms.keys()).map((room) => this.emitJoin(room)));
+    }
+    async connect(token) {
+        await this.ensureSocket(token);
+    }
+    async disconnect() {
+        const socket = this.socket;
+        this.socket = null;
+        this.connectPromise = null;
+        this.globalListeners.clear();
+        if (socket) {
+            socket.removeAllListeners();
+            socket.disconnect();
+        }
+    }
+    /**
+     * 加入任意房间（如跨设备同步用的同主体设备房间）。纳入 activeRooms 引用计数，
+     * 断线重连时会自动重新加入。
+     */
+    async joinRoom(room) {
+        await this.ensureSocket();
+        const current = this.activeRooms.get(room) || 0;
+        this.activeRooms.set(room, current + 1);
+        if (current === 0) {
+            await this.emitJoin(room);
+        }
+    }
+    async leaveRoom(room) {
+        const current = this.activeRooms.get(room) || 0;
+        const next = Math.max(current - 1, 0);
+        if (next === 0) {
+            this.activeRooms.delete(room);
+            await this.emitLeave(room);
+        }
+        else {
+            this.activeRooms.set(room, next);
+        }
+    }
+    /**
+     * 注册全局 socket 事件监听（所有房间均会转发），返回退订函数。
+     * 用于接收跨设备同步等非会话作用域的事件。
+     */
+    onGlobalEvent(handler) {
+        this.globalListeners.add(handler);
+        return () => {
+            this.globalListeners.delete(handler);
+        };
+    }
+    async subscribeConversation(conversationId) {
+        await this.ensureSocket();
+        const room = this.getConversationRoom(conversationId);
+        const currentRefCount = this.activeRooms.get(room) || 0;
+        this.activeRooms.set(room, currentRefCount + 1);
+        // 每次订阅都显式 join（socket.join 幂等）：避免"此前 join 过 → 计数非 0 跳过 join"
+        // 导致 socket 重连后不在房间、收不到事件的历史遗留坑。
+        await this.emitJoin(room);
+        const subscription = new SocketConversationSubscription(async () => {
+            const roomSubscriptions = this.subscriptions.get(room);
+            roomSubscriptions?.delete(subscription);
+            if (roomSubscriptions && roomSubscriptions.size === 0) {
+                this.subscriptions.delete(room);
+            }
+            const nextRefCount = Math.max((this.activeRooms.get(room) || 1) - 1, 0);
+            if (nextRefCount === 0) {
+                this.activeRooms.delete(room);
+                await this.leaveRoom(room);
+            }
+            else {
+                this.activeRooms.set(room, nextRefCount);
+            }
+        });
+        const roomSubscriptions = this.subscriptions.get(room) || new Set();
+        roomSubscriptions.add(subscription);
+        this.subscriptions.set(room, roomSubscriptions);
+        return subscription;
+    }
+    async publishConversationEvent(conversationId, event) {
+        const socket = await this.ensureSocket();
+        const account = await this.getAccount();
+        const room = this.getConversationRoom(conversationId);
+        socket?.emit('message', {
+            room,
+            conversationId,
+            userId: account,
+            ...event,
+        });
+    }
+}
+export function createChatHubClient(options) {
+    const clientOptions = {
+        http: new FetchHttpAdapter(options.baseUrl),
+        auth: options.auth || new LocalStorageAuthProvider(),
+        realtime: options.realtime || new NoopRealtimeAdapter(),
+    };
+    return new ChatHubClient(clientOptions);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@appthen/sdk-web",
+  "version": "0.0.0",
+  "description": "AppThen Conversation Hub SDK - Web platform adapter (fetch + socket.io-client)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@appthen/sdk-core": "0.0.0"
+  },
+  "peerDependencies": {
+    "socket.io-client": "^4.7.0"
+  },
+  "sideEffects": false,
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  }
+}