mezon-light-sdk 1.0.3 → 1.0.4

package/dist/socket.gen.js

@@ -1,327 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultSocket = exports.ConnectionState = void 0;
-const utils_1 = require("./utils");
-const web_socket_adapter_pb_1 = require("./web_socket_adapter_pb");
-/** A socket connection to Mezon server implemented with the DOM's WebSocket API. */
-let __hasConnectedOnce = false;
-exports.ConnectionState = {
-    DISCONNECTED: "disconnected",
-    CONNECTING: "connecting",
-    CONNECTED: "connected",
-};
-class DefaultSocket {
-    constructor(host, port, useSSL = false, verbose = false, adapter = new web_socket_adapter_pb_1.WebSocketAdapterPb(), sendTimeoutMs = DefaultSocket.DefaultSendTimeoutMs) {
-        this.host = host;
-        this.port = port;
-        this.useSSL = useSSL;
-        this.verbose = verbose;
-        this.adapter = adapter;
-        this.sendTimeoutMs = sendTimeoutMs;
-        this.cIds = {};
-        this.nextCid = 1;
-        this._heartbeatTimeoutMs = DefaultSocket.DefaultHeartbeatTimeoutMs;
-        this._connectionState = exports.ConnectionState.DISCONNECTED;
-    }
-    generatecid() {
-        const cid = this.nextCid.toString();
-        ++this.nextCid;
-        return cid;
-    }
-    isOpen() {
-        return this._connectionState === exports.ConnectionState.CONNECTED;
-    }
-    connect(session, createStatus = false, platform = "", connectTimeoutMs = DefaultSocket.DefaultConnectTimeoutMs, signal) {
-        if (this._connectionState === exports.ConnectionState.CONNECTED) {
-            return Promise.resolve(session);
-        }
-        if (this._connectionState === exports.ConnectionState.CONNECTING && this._connectPromise) {
-            return this._connectPromise;
-        }
-        this.clearConnectTimeout();
-        this._connectionState = exports.ConnectionState.CONNECTING;
-        const scheme = this.useSSL ? "wss://" : "ws://";
-        this.adapter.connect(scheme, this.host, this.port, createStatus, session.token, platform, signal);
-        this.adapter.onClose = (evt) => {
-            this._connectionState = exports.ConnectionState.DISCONNECTED;
-            this.stopHeartbeatLoop();
-            this.clearConnectTimeout();
-            this.ondisconnect(evt);
-        };
-        this.adapter.onMessage = async (message) => {
-            if (this.verbose && window && window.console) {
-                console.log("Response: %o", JSON.stringify(message));
-            }
-            /** Inbound message from server. */
-            if (!message.cid) {
-                if (message.channel_message) {
-                    const channelMessage = createChannelMessageFromEvent(message);
-                    this.onchannelmessage(channelMessage);
-                }
-                else {
-                    if (this.verbose && window && window.console) {
-                        console.log("Unrecognized message received: %o", message);
-                    }
-                }
-            }
-            else {
-                const executor = this.cIds[message.cid];
-                if (!executor) {
-                    if (this.verbose && window && window.console) {
-                        console.error("No promise executor for message: %o", message);
-                    }
-                    return;
-                }
-                delete this.cIds[message.cid];
-                if (message.error) {
-                    executor.reject(message.error);
-                }
-                else {
-                    executor.resolve(message);
-                }
-            }
-        };
-        const connectPromise = new Promise((resolve, reject) => {
-            this.adapter.onOpen = (evt) => {
-                if (this.verbose && window && window.console) {
-                    console.log(evt);
-                }
-                const isReconnect = __hasConnectedOnce;
-                __hasConnectedOnce = true;
-                this.clearConnectTimeout();
-                this._connectionState = exports.ConnectionState.CONNECTED;
-                this.startHeartbeatLoop();
-                this._connectPromise = undefined;
-                resolve(session);
-                if (isReconnect) {
-                    this.onreconnect(evt);
-                }
-            };
-            this.adapter.onError = (evt) => {
-                this._connectionState = exports.ConnectionState.DISCONNECTED;
-                this.stopHeartbeatLoop();
-                this.clearConnectTimeout();
-                this.onerror(evt);
-                this._connectPromise = undefined;
-                this.adapter.close();
-                reject(evt);
-            };
-            this._connectTimeoutTimer = setTimeout(() => {
-                // if promise has resolved by now, the reject() is a no-op
-                this._connectionState = exports.ConnectionState.DISCONNECTED;
-                this.stopHeartbeatLoop();
-                this.adapter.close();
-                this._connectPromise = undefined;
-                reject("The socket timed out when trying to connect.");
-                this._connectTimeoutTimer = undefined;
-            }, connectTimeoutMs);
-        });
-        this._connectPromise = connectPromise;
-        return this._connectPromise;
-    }
-    disconnect(fireDisconnectEvent = true) {
-        this._connectionState = exports.ConnectionState.DISCONNECTED;
-        this.stopHeartbeatLoop();
-        if (this.adapter.isOpen()) {
-            this.adapter.close();
-        }
-        if (fireDisconnectEvent) {
-            this.ondisconnect({});
-        }
-    }
-    setHeartbeatTimeoutMs(ms) {
-        this._heartbeatTimeoutMs = ms;
-    }
-    getHeartbeatTimeoutMs() {
-        return this._heartbeatTimeoutMs;
-    }
-    onreconnect(evt) {
-        if (this.verbose && window && window.console) {
-            console.log(evt);
-        }
-    }
-    ondisconnect(evt) {
-        if (this.verbose && window && window.console) {
-            console.log(evt);
-        }
-    }
-    onerror(evt) {
-        this._connectionState = exports.ConnectionState.DISCONNECTED;
-        this.stopHeartbeatLoop();
-        if (this.verbose && window && window.console) {
-            console.log(evt);
-        }
-    }
-    onheartbeattimeout() {
-        if (this.verbose && window && window.console) {
-            console.log("Heartbeat timeout.");
-        }
-    }
-    onchannelmessage(channelMessage) {
-        if (this.verbose && window && window.console) {
-            console.log(channelMessage);
-        }
-    }
-    // onuserchanneladded(user: UserChannelAddedEvent) {
-    //   if (this.verbose && window && window.console) {
-    //     console.log(user);
-    //   }
-    // }
-    send(message, sendTimeout = DefaultSocket.DefaultSendTimeoutMs) {
-        const untypedMessage = message;
-        return new Promise((resolve, reject) => {
-            if (!this.adapter.isOpen()) {
-                reject("Socket connection has not been established yet.");
-            }
-            else {
-                if (untypedMessage.channel_message_send) {
-                    untypedMessage.channel_message_send.content = JSON.stringify(untypedMessage.channel_message_send.content);
-                }
-                else if (untypedMessage.channel_message_update) {
-                    untypedMessage.channel_message_update.content = JSON.stringify(untypedMessage.channel_message_update.content);
-                }
-                else if (untypedMessage.ephemeral_message_send) {
-                    untypedMessage.ephemeral_message_send.message.content = JSON.stringify(untypedMessage.ephemeral_message_send.message?.content);
-                }
-                else if (untypedMessage.quick_menu_event) {
-                    untypedMessage.quick_menu_event.message.content = JSON.stringify(untypedMessage.quick_menu_event.message?.content);
-                }
-                const cid = this.generatecid();
-                this.cIds[cid] = { resolve, reject };
-                if (sendTimeout !== Infinity && sendTimeout > 0) {
-                    setTimeout(() => {
-                        reject("The socket timed out while waiting for a response.");
-                    }, sendTimeout);
-                }
-                untypedMessage.cid = cid;
-                this.adapter.send(untypedMessage);
-            }
-        });
-    }
-    async joinChat(clan_id, channel_id, channel_type, is_public) {
-        const response = await this.send({
-            channel_join: {
-                clan_id: clan_id,
-                channel_id: channel_id,
-                channel_type: channel_type,
-                is_public: is_public,
-            },
-        });
-        return response.channel;
-    }
-    async leaveChat(clan_id, channel_id, channel_type, is_public) {
-        return this.send({
-            channel_leave: {
-                clan_id: clan_id,
-                channel_id: channel_id,
-                channel_type: channel_type,
-                is_public: is_public,
-            },
-        });
-    }
-    async writeChatMessage(clan_id, channel_id, mode, is_public, content, attachments, anonymous_message, mention_everyone, avatar, code, topic_id) {
-        const response = await this.send({
-            channel_message_send: {
-                clan_id: clan_id,
-                channel_id: channel_id,
-                mode: mode,
-                is_public: is_public,
-                content: content,
-                reactions: [],
-                mentions: [],
-                attachments: attachments,
-                references: [],
-                anonymous_message: anonymous_message,
-                mention_everyone: mention_everyone,
-                avatar: avatar,
-                code: code,
-                topic_id: topic_id,
-            },
-        }, Infinity);
-        return response.channel_message_ack;
-    }
-    async pingPong() {
-        if (!this.isOpen()) {
-            this._connectionState = exports.ConnectionState.DISCONNECTED;
-            this.stopHeartbeatLoop();
-            return;
-        }
-        try {
-            await this.send({ ping: {} }, this._heartbeatTimeoutMs);
-        }
-        catch {
-            this._connectionState = exports.ConnectionState.DISCONNECTED;
-            this.stopHeartbeatLoop();
-            if (this.adapter.isOpen()) {
-                if (window && window.console) {
-                    console.error("Server unreachable from heartbeat.");
-                }
-                this.onheartbeattimeout();
-                this.adapter.close();
-            }
-            return;
-        }
-        this.startHeartbeatLoop();
-    }
-    startHeartbeatLoop() {
-        this.stopHeartbeatLoop();
-        this._heartbeatTimer = setTimeout(() => this.pingPong(), this._heartbeatTimeoutMs);
-    }
-    stopHeartbeatLoop() {
-        if (this._heartbeatTimer !== undefined) {
-            clearTimeout(this._heartbeatTimer);
-            this._heartbeatTimer = undefined;
-        }
-    }
-    clearConnectTimeout() {
-        if (this._connectTimeoutTimer !== undefined) {
-            clearTimeout(this._connectTimeoutTimer);
-            this._connectTimeoutTimer = undefined;
-        }
-    }
-}
-exports.DefaultSocket = DefaultSocket;
-DefaultSocket.DefaultHeartbeatTimeoutMs = 10000;
-DefaultSocket.DefaultSendTimeoutMs = 10000;
-DefaultSocket.DefaultConnectTimeoutMs = 30000;
-function createChannelMessageFromEvent(message) {
-    var content, attachments;
-    try {
-        content = (0, utils_1.safeJSONParse)(message.channel_message.content);
-    }
-    catch (e) {
-        console.log("content is invalid", e);
-    }
-    try {
-        attachments = (0, utils_1.decodeAttachments)(message.channel_message.attachments);
-    }
-    catch (e) {
-        console.log("attachments is invalid", e);
-    }
-    var e = {
-        id: message.id || message.channel_message.message_id,
-        avatar: message.channel_message.avatar,
-        channel_id: message.channel_message.channel_id,
-        mode: message.channel_message.mode,
-        channel_label: message.channel_message.channel_label,
-        clan_id: message.channel_message.clan_id,
-        code: message.channel_message.code,
-        message_id: message.channel_message.message_id,
-        sender_id: message.channel_message.sender_id,
-        update_time: message.channel_message.update_time,
-        clan_logo: message.channel_message.clan_logo,
-        category_name: message.channel_message.category_name,
-        username: message.channel_message.username,
-        clan_nick: message.channel_message.clan_nick,
-        clan_avatar: message.channel_message.clan_avatar,
-        display_name: message.channel_message.display_name,
-        content: content,
-        attachments: attachments?.attachments,
-        hide_editted: message.channel_message.hide_editted,
-        is_public: message.channel_message.is_public,
-        create_time_seconds: message.channel_message.create_time_seconds,
-        update_time_seconds: message.channel_message.update_time_seconds,
-        topic_id: message.channel_message.topic_id,
-    };
-    return e;
-}

package/dist/socket.js

@@ -1,249 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LightSocket = exports.SocketError = void 0;
-const web_socket_adapter_pb_1 = require("./web_socket_adapter_pb");
-const constants_1 = require("./constants");
-/**
- * Error thrown when socket operations fail.
- */
-class SocketError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "SocketError";
-    }
-}
-exports.SocketError = SocketError;
-/**
- * Maps raw socket message data to a ChannelMessage interface.
- */
-function mapToChannelMessage(message) {
-    return {
-        ...message,
-        clan_id: String(message.clan_id ?? ""),
-        channel_id: String(message.channel_id ?? ""),
-        message_id: String(message.message_id ?? ""),
-        sender_id: String(message.sender_id ?? ""),
-        content: String(message.content ?? ""),
-        // reactions: [],
-        // mentions: [],
-        // attachments: Array.isArray(message.attachments) ? message.attachments : [],
-        // references: Array.isArray(message.references) ? message.references : [],
-        create_time_seconds: Number(message.create_time_seconds ?? 0),
-        update_time_seconds: Number(message.update_time_seconds ?? 0),
-        hide_editted: Boolean(message.hide_editted),
-    };
-}
-/**
- * Waits for a socket to be in a ready state with exponential backoff.
- *
- * @param socket - The socket to wait for
- * @param maxRetries - Maximum number of retry attempts
- * @param initialDelay - Initial delay in milliseconds
- * @throws {SocketError} If socket doesn't become ready within retry limit
- */
-async function waitForSocketReady(socket, maxRetries = constants_1.SOCKET_READY_MAX_RETRY, initialDelay = constants_1.SOCKET_READY_RETRY_DELAY) {
-    let retryCount = 0;
-    let delay = initialDelay;
-    // Type assertion to access internal adapter
-    const socketWithAdapter = socket;
-    while (retryCount < maxRetries) {
-        if (socketWithAdapter.adapter?.isOpen()) {
-            return;
-        }
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        delay *= 2; // Exponential backoff
-        retryCount++;
-    }
-    throw new SocketError(`Socket failed to connect after ${maxRetries} attempts (total wait: ~${Math.pow(2, maxRetries) * initialDelay}ms)`);
-}
-/**
- * LightSocket provides a simplified interface for Mezon real-time messaging.
- *
- * @example
- * ```typescript
- * const socket = new LightSocket(client.client, client.session);
- *
- * await socket.connect({
- *   onError: (err) => console.error('Socket error:', err),
- *   onDisconnect: () => console.log('Disconnected')
- * });
- *
- * socket.onChannelMessage((msg) => {
- *   console.log('Received message:', msg.content);
- * });
- *
- * await socket.joinDMChannel('channel-123');
- * await socket.sendDM({ channelId: 'channel-123', content: 'Hello!' });
- * ```
- */
-class LightSocket {
-    constructor(_client, _session) {
-        this._client = _client;
-        this._session = _session;
-        this._socket = null;
-        this._isConnected = false;
-        this._messageHandlers = [];
-    }
-    /**
-     * Gets whether the socket is currently connected.
-     */
-    get isConnected() {
-        return this._isConnected;
-    }
-    /**
-     * Gets the underlying socket instance.
-     * @throws {SocketError} If socket is not connected
-     */
-    get socket() {
-        if (!this._socket) {
-            throw new SocketError("Socket is not connected. Call connect() first.");
-        }
-        return this._socket;
-    }
-    /**
-     * Connects to the Mezon real-time server.
-     *
-     * @param options - Connection options including error handlers
-     * @throws {SocketError} If already connected or connection fails
-     */
-    async connect(options = {}) {
-        if (this._isConnected) {
-            throw new SocketError("Socket is already connected. Call disconnect() first.");
-        }
-        const { onError, onDisconnect, verbose = false } = options;
-        this._errorHandler = onError;
-        this._disconnectHandler = onDisconnect;
-        this._socket = this._client.createSocket(verbose, new web_socket_adapter_pb_1.WebSocketAdapterPb());
-        // Set up error handler
-        this._socket.onerror = (error) => {
-            this._errorHandler?.(error);
-        };
-        // Set up disconnect handler
-        this._socket.ondisconnect = () => {
-            this._isConnected = false;
-            this._disconnectHandler?.();
-        };
-        // Set up message handler that dispatches to all registered handlers
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this._socket.onchannelmessage = (channelMessage) => {
-            if (!channelMessage) {
-                this._errorHandler?.(new SocketError("Received null or undefined channel message"));
-                return;
-            }
-            this._messageHandlers.forEach((handler) => {
-                try {
-                    handler(channelMessage);
-                }
-                catch (error) {
-                    console.error("Error in message handler:", error);
-                }
-            });
-        };
-        await this._socket.connect(this._session, true, "0");
-        this._isConnected = true;
-    }
-    /**
-     * Disconnects from the Mezon server.
-     */
-    disconnect() {
-        if (this._socket) {
-            this._socket.disconnect(true);
-            this._socket = null;
-            this._isConnected = false;
-        }
-    }
-    /**
-     * Registers a handler for incoming channel messages.
-     * Multiple handlers can be registered and will all receive messages.
-     *
-     * @param handler - Callback function to handle messages
-     */
-    setChannelMessageHandler(cb) {
-        this.onChannelMessage(cb);
-    }
-    /**
-     * Registers a handler for incoming channel messages.
-     * Multiple handlers can be registered and will all receive messages.
-     *
-     * @param handler - Callback function to handle messages
-     * @returns A function to unsubscribe the handler
-     */
-    onChannelMessage(handler) {
-        this._messageHandlers.push(handler);
-        // Return unsubscribe function
-        return () => {
-            const index = this._messageHandlers.indexOf(handler);
-            if (index !== -1) {
-                this._messageHandlers.splice(index, 1);
-            }
-        };
-    }
-    /**
-    * Joins a DM channel to receive messages from it.
-    *
-    * @param channelId - The DM channel ID to join
-    * @throws {SocketError} If socket is not ready or join fails
-    */
-    async joinDMChannel(channelId) {
-        await waitForSocketReady(this.socket);
-        await this.socket.joinChat(constants_1.CLAN_DM, channelId, constants_1.CHANNEL_TYPE_DM, false);
-    }
-    /**
-     * Joins a group channel to receive messages from it.
-     *
-     * @param channelId - The group channel ID to join
-     * @throws {SocketError} If socket is not ready or join fails
-     */
-    async joinGroupChannel(channelId) {
-        await waitForSocketReady(this.socket);
-        await this.socket.joinChat(constants_1.CLAN_DM, channelId, constants_1.CHANNEL_TYPE_GROUP, false);
-    }
-    /**
-     * Leaves a DM channel.
-     *
-     * @param channelId - The DM channel ID to leave
-     */
-    async leaveDMChannel(channelId) {
-        await this.socket.leaveChat(constants_1.CLAN_DM, channelId, constants_1.CHANNEL_TYPE_DM, false);
-    }
-    /**
-     * Leaves a group channel.
-     *
-     * @param channelId - The group channel ID to leave
-     */
-    async leaveGroupChannel(channelId) {
-        await this.socket.leaveChat(constants_1.CLAN_DM, channelId, constants_1.CHANNEL_TYPE_GROUP, false);
-    }
-    /**
-     * Sends a direct message to a channel.
-     *
-     * @param options - Message options including channelId, content, and attachments
-     */
-    async sendDM(payload) {
-        const { channelId, content, attachments, hideLink = false } = payload;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        await this.socket.writeChatMessage(constants_1.CLAN_DM, channelId, constants_1.STREAM_MODE_DM, false, content, attachments, false, hideLink, "", 0);
-    }
-    /**
-     * Sends a direct message to a channel.
-     *
-     * @param options - Message options including channelId, content, and attachments
-     */
-    async sendGroup(payload) {
-        const { channelId, content, attachments, hideLink = false } = payload;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        await this.socket.writeChatMessage(constants_1.CLAN_DM, channelId, constants_1.STREAM_MODE_GROUP, false, content, attachments, false, hideLink, "", 0);
-    }
-    /**
-     * Sets the error handler for socket errors.
-     *
-     * @param handler - Error handler callback
-     */
-    setErrorHandler(handler) {
-        this._errorHandler = handler;
-        if (this._socket) {
-            this._socket.onerror = handler;
-        }
-    }
-}
-exports.LightSocket = LightSocket;

package/dist/types.d.ts

@@ -1,44 +0,0 @@
-import { ApiMessageAttachment } from "./api.gen";
-/**
- * Configuration for initializing a LightClient from existing tokens.
- */
-export interface ClientInitConfig {
-    /** Authentication token */
-    token: string;
-    /** Refresh token for session renewal */
-    refresh_token: string;
-    /** API URL for the Mezon server */
-    api_url: string;
-    /** User ID associated with the session */
-    user_id: string;
-    /** Server key for authentication (optional, uses default if not provided) */
-    serverkey?: string;
-}
-/**
- * Configuration for authenticating a new user.
- */
-export interface AuthenticateConfig {
-    /** ID token from identity provider */
-    id_token: string;
-    /** User ID to associate with the account */
-    user_id: string;
-    /** Username for the account */
-    username: string;
-    /** Server key for authentication (optional, uses default if not provided) */
-    serverkey?: string;
-    /** Custom gateway URL (optional, uses default if not provided) */
-    gateway_url?: string;
-}
-/**
- * Options for sending a message.
- */
-export interface SendMessagePayload {
-    /** The channel ID to send the message to */
-    channelId: string;
-    /** Message content */
-    content: unknown;
-    /** File/media attachments (optional) */
-    attachments?: ApiMessageAttachment[];
-    /** Whether to hide link previews (optional) */
-    hideLink?: boolean;
-}

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -1,3 +0,0 @@
-export declare function buildFetchOptions(method: string, options: any, bodyJson: string): any;
-export declare function safeJSONParse(raw: any): any;
-export declare function decodeAttachments(data: any): any;