mezon-light-sdk 1.0.2 → 1.0.3

package/dist/utils.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeAttachments = exports.safeJSONParse = exports.buildFetchOptions = void 0;
+const tsproto = __importStar(require("./proto/api"));
+function buildFetchOptions(method, options, bodyJson) {
+    const fetchOptions = { ...{ method: method }, ...options };
+    fetchOptions.headers = { ...options.headers };
+    if (typeof XMLHttpRequest !== "undefined") {
+        const descriptor = Object.getOwnPropertyDescriptor(XMLHttpRequest.prototype, "withCredentials");
+        // in Cocos Creator, XMLHttpRequest.withCredentials is not writable, so make the fetch
+        // polyfill avoid writing to it.
+        if (!descriptor?.set) {
+            fetchOptions.credentials = "cocos-ignore"; // string value is arbitrary, cannot be 'omit' or 'include
+        }
+    }
+    //fetchOptions.headers["connect-protocol-version"] = "1";
+    if (!Object.keys(fetchOptions.headers).includes("Accept")) {
+        fetchOptions.headers["Accept"] = "application/proto";
+    }
+    if (!Object.keys(fetchOptions.headers).includes("Content-Type")) {
+        fetchOptions.headers["Content-Type"] = "application/proto";
+    }
+    Object.keys(fetchOptions.headers).forEach((key) => {
+        if (!fetchOptions.headers[key]) {
+            delete fetchOptions.headers[key];
+        }
+    });
+    if (bodyJson) {
+        fetchOptions.body = bodyJson;
+    }
+    return fetchOptions;
+}
+exports.buildFetchOptions = buildFetchOptions;
+function safeJSONParse(raw) {
+    if (raw === null || raw === undefined)
+        return { t: raw };
+    let jsonStr;
+    if (raw instanceof Uint8Array) {
+        jsonStr = new TextDecoder().decode(raw);
+    }
+    else if (typeof raw === "string") {
+        jsonStr = raw;
+    }
+    else {
+        return typeof raw === "object" ? raw : { t: raw };
+    }
+    if (!jsonStr || jsonStr === "" || jsonStr === "[]") {
+        return { t: jsonStr };
+    }
+    try {
+        return JSON.parse(jsonStr);
+    }
+    catch (error) {
+        try {
+            const fixedJsonStr = jsonStr.replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+            return JSON.parse(fixedJsonStr);
+        }
+        catch (e) {
+            console.error("JSON Parse failed completely:", { original: jsonStr, error: e });
+            return { t: jsonStr };
+        }
+    }
+}
+exports.safeJSONParse = safeJSONParse;
+const isEmpty = (data) => {
+    return !data || data === null || data === undefined || data === "" || data === "[]";
+};
+function decodeAttachments(data) {
+    if (isEmpty(data))
+        return;
+    // 91 is '[' (JSON Array) | 123 is '{' (JSON Object)
+    const firstByte = data[0];
+    const isJson = firstByte === 91 || firstByte === 123;
+    if (isJson) {
+        return safeJSONParse(data);
+    }
+    try {
+        const buffer = data;
+        const uintBuffer = new Uint8Array(buffer);
+        const attachments = tsproto.MessageAttachmentList.decode(uintBuffer);
+        return attachments;
+    }
+    catch (error) {
+        return safeJSONParse(data);
+    }
+}
+exports.decodeAttachments = decodeAttachments;

package/dist/web_socket_adapter_pb.d.ts

@@ -0,0 +1,69 @@
+/**
+ * An interface used by Mezon's web socket to determine the payload protocol.
+ */
+export interface WebSocketAdapter {
+    /**
+     * Dispatched when the web socket closes.
+     */
+    onClose: SocketCloseHandler | null;
+    /**
+     * Dispatched when the web socket receives an error.
+     */
+    onError: SocketErrorHandler | null;
+    /**
+     * Dispatched when the web socket receives a normal message.
+     */
+    onMessage: SocketMessageHandler | null;
+    /**
+     * Dispatched when the web socket opens.
+     */
+    onOpen: SocketOpenHandler | null;
+    isOpen(): boolean;
+    close(): void;
+    connect(scheme: string, host: string, port: string, createStatus: boolean, token: string, platform: string, signal?: AbortSignal): void;
+    send(message: any): void;
+}
+/**
+ * SocketCloseHandler defines a lambda that handles WebSocket close events.
+ */
+export interface SocketCloseHandler {
+    (this: WebSocket, evt: CloseEvent): void;
+}
+/**
+ * SocketErrorHandler defines a lambda that handles responses from the server via WebSocket
+ * that indicate an error.
+ */
+export interface SocketErrorHandler {
+    (this: WebSocket, evt: Event): void;
+}
+/**
+ * SocketMessageHandler defines a lambda that handles valid WebSocket messages.
+ */
+export interface SocketMessageHandler {
+    (message: any): void;
+}
+/**
+ * SocketOpenHandler defines a lambda that handles WebSocket open events.
+ */
+export interface SocketOpenHandler {
+    (this: WebSocket, evt: Event): void;
+}
+/**
+ * A protocol buffer socket adapter that accepts and transmits payloads using the protobuf binary wire format.
+ */
+export declare class WebSocketAdapterPb implements WebSocketAdapter {
+    private _socket?;
+    constructor();
+    get onClose(): SocketCloseHandler | null;
+    set onClose(value: SocketCloseHandler | null);
+    get onError(): SocketErrorHandler | null;
+    set onError(value: SocketErrorHandler | null);
+    get onMessage(): SocketMessageHandler | null;
+    set onMessage(value: SocketMessageHandler | null);
+    get onOpen(): SocketOpenHandler | null;
+    set onOpen(value: SocketOpenHandler | null);
+    isOpen(): boolean;
+    close(): void;
+    connect(scheme: string, host: string, port: string, createStatus: boolean, token: string, platform: string, signal?: AbortSignal): void;
+    send(msg: any): void;
+}

package/dist/web_socket_adapter_pb.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketAdapterPb = void 0;
+/**
+ * Copyright 2020 The Mezon Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const tsproto = __importStar(require("./proto/realtime"));
+/**
+ * A protocol buffer socket adapter that accepts and transmits payloads using the protobuf binary wire format.
+ */
+class WebSocketAdapterPb {
+    constructor() { }
+    get onClose() {
+        return this._socket.onclose;
+    }
+    set onClose(value) {
+        this._socket.onclose = value;
+    }
+    get onError() {
+        return this._socket.onerror;
+    }
+    set onError(value) {
+        this._socket.onerror = value;
+    }
+    get onMessage() {
+        return this._socket.onmessage;
+    }
+    set onMessage(value) {
+        if (value) {
+            this._socket.onmessage = (evt) => {
+                const buffer = evt.data;
+                const uintBuffer = new Uint8Array(buffer);
+                const envelope = tsproto.Envelope.decode(uintBuffer);
+                if (envelope.channel_message) {
+                    if (envelope.channel_message.code == undefined) {
+                        //protobuf plugin does not default-initialize missing Int32Value fields
+                        envelope.channel_message.code = 0;
+                    }
+                }
+                value(envelope);
+            };
+        }
+        else {
+            value = null;
+        }
+    }
+    get onOpen() {
+        return this._socket.onopen;
+    }
+    set onOpen(value) {
+        this._socket.onopen = value;
+    }
+    isOpen() {
+        return this._socket?.readyState == WebSocket.OPEN;
+    }
+    close() {
+        this._socket?.close();
+        this._socket = undefined;
+    }
+    connect(scheme, host, port, createStatus, token, platform, signal) {
+        if (signal) {
+            signal.addEventListener("abort", () => {
+                this.close();
+            });
+        }
+        const url = `${scheme}${host}:${port}/ws?lang=en&status=${encodeURIComponent(createStatus.toString())}&token=${encodeURIComponent(token)}&format=protobuf&platform=${encodeURIComponent(platform)}`;
+        this._socket = new WebSocket(url);
+        this._socket.binaryType = "arraybuffer";
+    }
+    send(msg) {
+        const envelopeWriter = tsproto.Envelope.encode(tsproto.Envelope.fromPartial(msg));
+        const encodedMsg = envelopeWriter.finish();
+        this._socket.send(encodedMsg);
+    }
+}
+exports.WebSocketAdapterPb = WebSocketAdapterPb;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mezon-light-sdk",
-  "version": "1.0.2",
-  "description": "Lightweigth SDK for mezon chat.",
+  "version": "1.0.3",
+  "description": "lightweight SDK for mezon chat.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -12,8 +12,7 @@
   },
   "dependencies": {
     "js-base64": "^3.7.8",
-    "mezon-js": "^2.13.58",
-    "mezon-js-protobuf": "^1.8.66"
+    "protobufjs": "^8.0.0"
   },
   "author": "mezonai",
   "license": "MIT",

package/dist/message.d.ts

@@ -1,19 +0,0 @@
-export interface ChannelMessage {
-    clan_id: string;
-    channel_id: string;
-    message_id: string;
-    code: number;
-    sender_id: string;
-    username: string;
-    avatar: string;
-    content: any;
-    create_time: string;
-    update_time: string;
-    display_name: string;
-    mentions: any[];
-    attachments: any[];
-    references: any[];
-    create_time_seconds: number;
-    update_time_seconds: number;
-    hide_editted: boolean;
-}