simplex-chat 0.1.1 → 0.2.1

package/dist/index.mjs

@@ -1,585 +0,0 @@
-class Sem {
-    constructor(permits) {
-        this.permits = permits;
-        this.promises = [];
-    }
-    signal() {
-        this.permits += 1;
-        if (this.promises.length > 0)
-            this.promises.pop()();
-    }
-    async wait() {
-        if (this.permits === 0 || this.promises.length > 0) {
-            await new Promise((r) => this.promises.unshift(r));
-        }
-        this.permits -= 1;
-    }
-}
-const queueClosed = Symbol();
-class ABQueueError extends Error {
-}
-class ABQueue {
-    constructor(maxSize) {
-        this.maxSize = maxSize;
-        this.queue = [];
-        this.enqClosed = false;
-        this.deqClosed = false;
-        this.enq = new Sem(0);
-        this.deq = new Sem(maxSize);
-    }
-    [Symbol.asyncIterator]() {
-        return this;
-    }
-    enqueue(x) {
-        return this._enqueue(x);
-    }
-    async _enqueue(x) {
-        if (this.enqClosed)
-            throw new ABQueueError("enqueue: queue closed");
-        await this.deq.wait();
-        this.queue.push(x);
-        this.enq.signal();
-    }
-    async dequeue() {
-        if (this.deqClosed)
-            throw new ABQueueError("dequeue: queue closed");
-        this.deq.signal();
-        await this.enq.wait();
-        const x = this.queue.shift();
-        if (x === queueClosed) {
-            this.deqClosed = true;
-            throw new ABQueueError("dequeue: queue closed");
-        }
-        return x;
-    }
-    async close() {
-        await this._enqueue(queueClosed);
-        this.enqClosed = true;
-    }
-    async next() {
-        if (this.deqClosed)
-            return { done: true };
-        try {
-            return { value: await this.dequeue() };
-        }
-        catch (e) {
-            if (e instanceof ABQueueError)
-                return { done: true };
-            throw e;
-        }
-    }
-}
-
-class TransportError extends Error {
-}
-class Transport {
-    constructor(qSize) {
-        this.queue = new ABQueue(qSize);
-    }
-    [Symbol.asyncIterator]() {
-        return this;
-    }
-    async read() {
-        return this.queue.dequeue();
-    }
-    async next() {
-        return this.queue.next();
-    }
-}
-class WSTransport extends Transport {
-    constructor(sock, timeout, qSize) {
-        super(qSize);
-        this.sock = sock;
-        this.timeout = timeout;
-    }
-    static connect(url, timeout, qSize) {
-        const sock = new WebSocket(url);
-        const t = new WSTransport(sock, timeout, qSize);
-        sock.onmessage = async ({ data }) => await t.queue.enqueue(data);
-        sock.onclose = async () => await t.queue.close();
-        sock.onerror = () => sock.close();
-        return withTimeout(timeout, () => new Promise((r) => (sock.onopen = () => r(t))));
-    }
-    close() {
-        this.sock.close();
-        return Promise.resolve();
-    }
-    write(data) {
-        const buffered = this.sock.bufferedAmount;
-        this.sock.send(data);
-        return withTimeout(this.timeout, async () => {
-            while (this.sock.bufferedAmount > buffered)
-                await delay();
-        });
-    }
-    async readBinary(size) {
-        const data = await this.read();
-        if (typeof data == "string")
-            throw new TransportError("invalid text block: expected binary");
-        if (data.byteLength !== size)
-            throw new TransportError("invalid block size");
-        return data;
-    }
-}
-function withTimeout(ms, action) {
-    return Promise.race([
-        action(),
-        (async () => {
-            await delay(ms);
-            throw new Error("timeout");
-        })(),
-    ]);
-}
-class ChatResponseError extends Error {
-    constructor(message, data) {
-        super(message);
-        this.message = message;
-        this.data = data;
-    }
-}
-class ChatTransport extends Transport {
-    constructor(ws, timeout, qSize) {
-        super(qSize);
-        this.ws = ws;
-        this.timeout = timeout;
-    }
-    static async connect(srv, timeout, qSize) {
-        const ws = await WSTransport.connect(`ws://${srv.host}:${srv.port || "80"}`, timeout, qSize);
-        const c = new ChatTransport(ws, timeout, qSize);
-        processWSQueue(c, ws).then(noop, noop);
-        return c;
-    }
-    async close() {
-        await this.ws.close();
-    }
-    async write(cmd) {
-        return this.ws.write(JSON.stringify(cmd));
-    }
-}
-function noop() { }
-async function processWSQueue(c, ws) {
-    var _a;
-    for await (const data of ws) {
-        const str = data instanceof Promise ? await data : data;
-        if (typeof str != "string") {
-            await c.queue.enqueue(new ChatResponseError("websocket data is not a string"));
-            continue;
-        }
-        let resp;
-        try {
-            const data = JSON.parse(str);
-            if (typeof ((_a = data === null || data === void 0 ? void 0 : data.resp) === null || _a === void 0 ? void 0 : _a.type) == "string") {
-                resp = data;
-            }
-            else {
-                resp = new ChatResponseError("invalid response format", str);
-            }
-        }
-        catch (err) {
-            resp = new ChatResponseError(err.message, str);
-        }
-        await c.queue.enqueue(resp);
-    }
-    await c.queue.close();
-}
-function delay(ms) {
-    return new Promise((r) => setTimeout(r, ms));
-}
-
-var ChatType;
-(function (ChatType) {
-    ChatType["CTDirect"] = "@";
-    ChatType["CTGroup"] = "#";
-    ChatType["CTContactRequest"] = "<@";
-})(ChatType || (ChatType = {}));
-var DeleteMode;
-(function (DeleteMode) {
-    DeleteMode["DMBroadcast"] = "broadcast";
-    DeleteMode["DMInternal"] = "internal";
-})(DeleteMode || (DeleteMode = {}));
-function cmdString(cmd) {
-    switch (cmd.type) {
-        case "showActiveUser":
-            return "/u";
-        case "createActiveUser":
-            return `/u ${JSON.stringify(cmd.profile)}`;
-        case "startChat":
-            return "/_start";
-        case "setFilesFolder":
-            return `/_files_folder ${cmd.filePath}`;
-        case "apiGetChats":
-            return "/_get chats";
-        case "apiGetChat":
-            return `/_get chat ${cmd.chatType}${cmd.chatId}${paginationStr(cmd.pagination)}`;
-        case "apiSendMessage":
-            return `/_send ${cmd.chatType}${cmd.chatId}${tagged("file", cmd.filePath)}${tagged("quoted", cmd.quotedItem)} json ${JSON.stringify(cmd.msgContent)}`;
-        case "apiUpdateChatItem":
-            return `/_update item ${cmd.chatType}${cmd.chatId} ${cmd.chatItemId} json ${JSON.stringify(cmd.msgContent)}`;
-        case "apiDeleteChatItem":
-            return `/_delete item ${cmd.chatType}${cmd.chatId} ${cmd.chatItemId} ${cmd.deleteMode}`;
-        case "apiChatRead":
-            return `/_read chat ${cmd.chatType}${cmd.chatId} from=${cmd.fromItem} to=${cmd.toItem}`;
-        case "apiDeleteChat":
-            return `/_delete ${cmd.chatType}${cmd.chatId}`;
-        case "apiAcceptContact":
-            return `/_accept ${cmd.contactReqId}`;
-        case "apiRejectContact":
-            return `/_reject ${cmd.contactReqId}`;
-        case "apiUpdateProfile":
-            return `/_profile ${JSON.stringify(cmd.profile)}`;
-        case "apiParseMarkdown":
-            return `/_parse ${cmd.text}`;
-        case "getUserSMPServers":
-            return "/smp_servers";
-        case "setUserSMPServers":
-            return `/smp_servers ${cmd.servers.join(",") || "default"}`;
-        case "addContact":
-            return "/connect";
-        case "connect":
-            return `/connect ${cmd.connReq}`;
-        case "connectSimplex":
-            return "/simplex";
-        case "createMyAddress":
-            return "/address";
-        case "deleteMyAddress":
-            return "/delete_address";
-        case "showMyAddress":
-            return "/show_address";
-        case "addressAutoAccept":
-            return `/auto_accept ${cmd.enable ? "on" : "off"}`;
-    }
-}
-function paginationStr(cp) {
-    const base = "after" in cp ? ` after=${cp.after}` : "before" in cp ? ` before=${cp.before}` : "";
-    return base + ` count=${cp.count}`;
-}
-function tagged(tag, x) {
-    return x ? ` ${tag}=${x}` : "";
-}
-var CIDeleteMode;
-(function (CIDeleteMode) {
-    CIDeleteMode["Broadcast"] = "broadcast";
-    CIDeleteMode["Internal"] = "internal";
-})(CIDeleteMode || (CIDeleteMode = {}));
-
-class ChatCommandError extends Error {
-    constructor(message, response) {
-        super(message);
-        this.message = message;
-        this.response = response;
-    }
-}
-class ChatClient {
-    constructor(server, config, msgQ, client, transport) {
-        this.server = server;
-        this.config = config;
-        this.msgQ = msgQ;
-        this.client = client;
-        this.transport = transport;
-        this._connected = true;
-        this.clientCorrId = 0;
-        this.sentCommands = new Map();
-    }
-    static async create(server, cfg, msgQ) {
-        const transport = await ChatTransport.connect(server, cfg.tcpTimeout, cfg.qSize);
-        const client = runClient().then(noop, noop);
-        const c = new ChatClient(server, cfg, msgQ, client, transport);
-        return c;
-        async function runClient() {
-            for await (const t of transport) {
-                const apiResp = t instanceof Promise ? await t : t;
-                if (apiResp instanceof ChatResponseError) {
-                    console.log("chat response error: ", apiResp);
-                }
-                else {
-                    const { corrId, resp } = apiResp;
-                    if (corrId) {
-                        const req = c.sentCommands.get(corrId);
-                        if (req) {
-                            c.sentCommands.delete(corrId);
-                            if (resp.type == "chatCmdError") {
-                                req.reject(resp);
-                            }
-                            else {
-                                req.resolve(resp);
-                            }
-                        }
-                        else {
-                            // TODO send error to errQ?
-                            console.log("no command sent for chat response: ", apiResp);
-                        }
-                    }
-                    else {
-                        await msgQ.enqueue(resp);
-                    }
-                }
-            }
-            c._connected = false;
-        }
-    }
-    sendChatCommand(command) {
-        const corrId = ++this.clientCorrId;
-        const t = { corrId, cmd: cmdString(command) };
-        this.transport.write(t).then(noop, noop);
-        return new Promise((resolve, reject) => this.sentCommands.set(corrId, { resolve, reject }));
-    }
-    async disconnect() {
-        await this.transport.close();
-        await this.client;
-    }
-    async getActiveUser() {
-        const r = await this.sendChatCommand({ type: "showActiveUser" });
-        switch (r.type) {
-            case "activeUser":
-                return r.user;
-            case "chatCmdError":
-                if (r.chatError.type == "error" && r.chatError.errorType.type == "noActiveUser")
-                    return undefined;
-                throw new ChatCommandError("unexpected response error", r);
-            default:
-                throw new ChatCommandError("unexpected response", r);
-        }
-    }
-    async createActiveUser(profile) {
-        const r = await this.sendChatCommand({ type: "createActiveUser", profile });
-        if (r.type == "activeUser")
-            return r.user;
-        throw new ChatCommandError("unexpected response", r);
-    }
-    async apiStartChat() {
-        const r = await this.sendChatCommand({ type: "startChat" });
-        if (r.type != "chatStarted")
-            throw new ChatCommandError("unexpected response", r);
-    }
-    // func apiGetChats() throws -> [Chat] {
-    //     let r = chatSendCmdSync(.apiGetChats)
-    //     if case let .apiChats(chats) = r { return chats.map { Chat.init($0) } }
-    //     throw r
-    // }
-    // func apiGetChat(type: ChatType, id: Int64) throws -> Chat {
-    //     let r = chatSendCmdSync(.apiGetChat(type: type, id: id))
-    //     if case let .apiChat(chat) = r { return Chat.init(chat) }
-    //     throw r
-    // }
-    // async sendMessage(type: ChatType, id: number, msg: C.MsgContent)
-    // func apiSendMessage(type: ChatType, id: Int64, quotedItemId: Int64?, msg: MsgContent) async throws -> ChatItem {
-    //     let chatModel = ChatModel.shared
-    //     let cmd: ChatCommand
-    //     if let itemId = quotedItemId {
-    //         cmd = .apiSendMessageQuote(type: type, id: id, itemId: itemId, msg: msg)
-    //     } else {
-    //         cmd = .apiSendMessage(type: type, id: id, msg: msg)
-    //     }
-    //     let r: ChatResponse
-    //     if type == .direct {
-    //         var cItem: ChatItem!
-    //         let endTask = beginBGTask({ if cItem != nil { chatModel.messageDelivery.removeValue(forKey: cItem.id) } })
-    //         r = await chatSendCmd(cmd, bgTask: false)
-    //         if case let .newChatItem(aChatItem) = r {
-    //             cItem = aChatItem.chatItem
-    //             chatModel.messageDelivery[cItem.id] = endTask
-    //             return cItem
-    //         }
-    //         endTask()
-    //     } else {
-    //         r = await chatSendCmd(cmd, bgDelay: msgDelay)
-    //         if case let .newChatItem(aChatItem) = r {
-    //             return aChatItem.chatItem
-    //         }
-    //     }
-    //     throw r
-    // }
-    // func apiUpdateChatItem(type: ChatType, id: Int64, itemId: Int64, msg: MsgContent) async throws -> ChatItem {
-    //   let r = await chatSendCmd(.apiUpdateChatItem(type: type, id: id, itemId: itemId, msg: msg), bgDelay: msgDelay)
-    //   if case let .chatItemUpdated(aChatItem) = r { return aChatItem.chatItem }
-    //   throw r
-    // }
-    // func apiDeleteChatItem(type: ChatType, id: Int64, itemId: Int64, mode: CIDeleteMode) async throws -> ChatItem {
-    //     let r = await chatSendCmd(.apiDeleteChatItem(type: type, id: id, itemId: itemId, mode: mode), bgDelay: msgDelay)
-    //     if case let .chatItemDeleted(_, toChatItem) = r { return toChatItem.chatItem }
-    //     throw r
-    // }
-    // func getUserSMPServers() throws -> [String] {
-    //     let r = chatSendCmdSync(.getUserSMPServers)
-    //     if case let .userSMPServers(smpServers) = r { return smpServers }
-    //     throw r
-    // }
-    // func setUserSMPServers(smpServers: [String]) async throws {
-    //     let r = await chatSendCmd(.setUserSMPServers(smpServers: smpServers))
-    //     if case .cmdOk = r { return }
-    //     throw r
-    // }
-    // func apiAddContact() throws -> String {
-    //     let r = chatSendCmdSync(.addContact, bgTask: false)
-    //     if case let .invitation(connReqInvitation) = r { return connReqInvitation }
-    //     throw r
-    // }
-    // func apiConnect(connReq: String) async throws -> Bool {
-    //     let r = await chatSendCmd(.connect(connReq: connReq))
-    //     let am = AlertManager.shared
-    //     switch r {
-    //     case .sentConfirmation: return true
-    //     case .sentInvitation: return true
-    //     case let .contactAlreadyExists(contact):
-    //         am.showAlertMsg(
-    //             title: "Contact already exists",
-    //             message: "You are already connected to \(contact.displayName) via this link."
-    //         )
-    //         return false
-    //     case .chatCmdError(.error(.invalidConnReq)):
-    //         am.showAlertMsg(
-    //             title: "Invalid connection link",
-    //             message: "Please check that you used the correct link or ask your contact to send you another one."
-    //         )
-    //         return false
-    //     case .chatCmdError(.errorAgent(.BROKER(.TIMEOUT))):
-    //         am.showAlertMsg(
-    //             title: "Connection timeout",
-    //             message: "Please check your network connection and try again."
-    //         )
-    //         return false
-    //     case .chatCmdError(.errorAgent(.BROKER(.NETWORK))):
-    //         am.showAlertMsg(
-    //             title: "Connection error",
-    //             message: "Please check your network connection and try again."
-    //         )
-    //         return false
-    //     default: throw r
-    //     }
-    // }
-    // func apiDeleteChat(type: ChatType, id: Int64) async throws {
-    //     let r = await chatSendCmd(.apiDeleteChat(type: type, id: id), bgTask: false)
-    //     if case .contactDeleted = r { return }
-    //     throw r
-    // }
-    // func apiUpdateProfile(profile: Profile) async throws -> Profile? {
-    //     let r = await chatSendCmd(.apiUpdateProfile(profile: profile))
-    //     switch r {
-    //     case .userProfileNoChange: return nil
-    //     case let .userProfileUpdated(_, toProfile): return toProfile
-    //     default: throw r
-    //     }
-    // }
-    // func apiParseMarkdown(text: String) throws -> [FormattedText]? {
-    //     let r = chatSendCmdSync(.apiParseMarkdown(text: text))
-    //     if case let .apiParsedMarkdown(formattedText) = r { return formattedText }
-    //     throw r
-    // }
-    // func apiCreateUserAddress() async throws -> String {
-    //     let r = await chatSendCmd(.createMyAddress)
-    //     if case let .userContactLinkCreated(connReq) = r { return connReq }
-    //     throw r
-    // }
-    // func apiDeleteUserAddress() async throws {
-    //     let r = await chatSendCmd(.deleteMyAddress)
-    //     if case .userContactLinkDeleted = r { return }
-    //     throw r
-    // }
-    // func apiGetUserAddress() async throws -> String? {
-    //     let r = await chatSendCmd(.showMyAddress)
-    //     switch r {
-    //     case let .userContactLink(connReq):
-    //         return connReq
-    //     case .chatCmdError(chatError: .errorStore(storeError: .userContactLinkNotFound)):
-    //         return nil
-    //     default: throw r
-    //     }
-    // }
-    // func apiAcceptContactRequest(contactReqId: Int64) async throws -> Contact {
-    //     let r = await chatSendCmd(.apiAcceptContact(contactReqId: contactReqId))
-    //     if case let .acceptingContactRequest(contact) = r { return contact }
-    //     throw r
-    // }
-    // func apiRejectContactRequest(contactReqId: Int64) async throws {
-    //     let r = await chatSendCmd(.apiRejectContact(contactReqId: contactReqId))
-    //     if case .contactRequestRejected = r { return }
-    //     throw r
-    // }
-    // func apiChatRead(type: ChatType, id: Int64, itemRange: (Int64, Int64)) async throws {
-    //     let r = await chatSendCmd(.apiChatRead(type: type, id: id, itemRange: itemRange))
-    //     if case .cmdOk = r { return }
-    //     throw r
-    // }
-    // func acceptContactRequest(_ contactRequest: UserContactRequest) async {
-    //     do {
-    //         let contact = try await apiAcceptContactRequest(contactReqId: contactRequest.apiId)
-    //         let chat = Chat(chatInfo: ChatInfo.direct(contact: contact), chatItems: [])
-    //         DispatchQueue.main.async { ChatModel.shared.replaceChat(contactRequest.id, chat) }
-    //     } catch let error {
-    //         logger.error("acceptContactRequest error: \(error.localizedDescription)")
-    //     }
-    // }
-    // func rejectContactRequest(_ contactRequest: UserContactRequest) async {
-    //     do {
-    //         try await apiRejectContactRequest(contactReqId: contactRequest.apiId)
-    //         DispatchQueue.main.async { ChatModel.shared.removeChat(contactRequest.id) }
-    //     } catch let error {
-    //         logger.error("rejectContactRequest: \(error.localizedDescription)")
-    //     }
-    // }
-    // func markChatRead(_ chat: Chat) async {
-    //     do {
-    //         let minItemId = chat.chatStats.minUnreadItemId
-    //         let itemRange = (minItemId, chat.chatItems.last?.id ?? minItemId)
-    //         let cInfo = chat.chatInfo
-    //         try await apiChatRead(type: cInfo.chatType, id: cInfo.apiId, itemRange: itemRange)
-    //         DispatchQueue.main.async { ChatModel.shared.markChatItemsRead(cInfo) }
-    //     } catch {
-    //         logger.error("markChatRead apiChatRead error: \(error.localizedDescription)")
-    //     }
-    // }
-    // func markChatItemRead(_ cInfo: ChatInfo, _ cItem: ChatItem) async {
-    //     do {
-    //         try await apiChatRead(type: cInfo.chatType, id: cInfo.apiId, itemRange: (cItem.id, cItem.id))
-    //         DispatchQueue.main.async { ChatModel.shared.markChatItemRead(cInfo, cItem) }
-    //     } catch {
-    //         logger.error("markChatItemRead apiChatRead error: \(error.localizedDescription)")
-    //     }
-    // }
-    // async createSMPQueue(rcvKey: SignKey, rcvPubKey: PublicKey<KeyType.Verify>): Promise<SMP.IDS> {
-    //   const pubKeyStr = new Uint8Array(await C.encodePubKey(rcvPubKey))
-    //   const resp = await this.sendSMPCommand(rcvKey, B.empty, SMP.cNEW(pubKeyStr))
-    //   if (resp.cmd === "IDS") return resp
-    //   throw new Error("unexpected response")
-    // }
-    // subscribeSMPQueue(rcvKey: SignKey, queueId: Uint8Array): Promise<void> {
-    //   return this.msgSMPCommand(rcvKey, queueId, SMP.cSUB())
-    // }
-    // async secureSMPQueue(rcvKey: SignKey, queueId: Uint8Array, sndPubKey: PublicKey<KeyType.Verify>): Promise<void> {
-    //   const pubKeyStr = new Uint8Array(await C.encodePubKey(sndPubKey))
-    //   return this.okSMPCommand(rcvKey, queueId, SMP.cKEY(pubKeyStr))
-    // }
-    // async sendSMPMessage(sndKey: SignKey | undefined, queueId: Uint8Array, msg: Uint8Array): Promise<void> {
-    //   const resp = await this.sendSMPCommand(sndKey, queueId, SMP.cSEND(msg))
-    //   if (resp.cmd !== "OK") throw new Error("unexpected response")
-    // }
-    // ackSMPMessage(rcvKey: SignKey, queueId: Uint8Array): Promise<void> {
-    //   return this.msgSMPCommand(rcvKey, queueId, SMP.cACK())
-    // }
-    // suspendSMPQueue(rcvKey: SignKey, queueId: Uint8Array): Promise<void> {
-    //   return this.okSMPCommand(rcvKey, queueId, SMP.cOFF())
-    // }
-    // deleteSMPQueue(rcvKey: SignKey, queueId: Uint8Array): Promise<void> {
-    //   return this.okSMPCommand(rcvKey, queueId, SMP.cDEL())
-    // }
-    // private async msgSMPCommand(rcvKey: SignKey, queueId: Uint8Array, command: SMPCommand<Client>): Promise<void> {
-    //   const resp = await this.sendSMPCommand(rcvKey, queueId, command)
-    //   switch (resp.cmd) {
-    //     case "OK":
-    //       return
-    //     case "MSG":
-    //       return this.msgQ.enqueue({server: this.server, queueId, command: resp})
-    //     default:
-    //       throw new Error("unexpected response")
-    //   }
-    // }
-    // private async okChatCommand(command: ChatCommand): Promise<void> {
-    //   const resp = await this.sendChatCommand(command)
-    //   if (resp.type !== "cmdOk") throw new ChatCommandError("unexpected response", resp)
-    // }
-    get connected() {
-        return this._connected;
-    }
-}
-
-export { ChatClient };