@banta/sdk 5.2.5 → 5.4.0

package/esm2020/lib/chat-backend.mjs

@@ -0,0 +1,194 @@
+import { Inject, Injectable } from "@angular/core";
+import { CommentsOrder, DurableSocket, FilterMode, buildQuery } from "@banta/common";
+import { ChatBackendBase } from "./chat-backend-base";
+import { ChatSource } from "./chat-source";
+import { BANTA_SDK_OPTIONS } from "./sdk-options";
+import { PLATFORM_ID } from "@angular/core";
+import { isPlatformServer } from "@angular/common";
+import { StaticChatSource } from "./static-chat-source";
+import * as i0 from "@angular/core";
+export class ChatBackend extends ChatBackendBase {
+    constructor(options, platformId) {
+        super();
+        this.options = options;
+        this.platformId = platformId;
+    }
+    get serviceUrl() {
+        return `${this.options?.serviceUrl ?? 'http://localhost:3422'}`;
+    }
+    async connectToService() {
+        let socket = new DurableSocket(`${this.serviceUrl.replace(/^http/, 'ws')}/socket`);
+        await new Promise((resolve, reject) => {
+            socket.onopen = () => {
+                resolve();
+            };
+            socket.onclose = e => {
+                if (e.code === 503) {
+                    console.error(`Failed to connect to chat service!`);
+                    reject(e);
+                }
+            };
+        });
+        socket.onerror = undefined;
+        return socket;
+    }
+    isServer() {
+        if (typeof localStorage !== 'undefined' && localStorage['banta:debug:useStaticSource'] === '1')
+            return true;
+        return isPlatformServer(this.platformId);
+    }
+    /**
+     * Check if we are currently running inside a Googlebot user agent or via the Google inspection tool in Search Console.
+     * We'll use this to avoid WebSockets so that comments can be indexable.
+     * @returns
+     */
+    isGooglebot() {
+        return typeof navigator !== 'undefined' && (navigator.userAgent.includes('Googlebot')
+            || navigator.userAgent.includes('Google-InspectionTool'));
+    }
+    async getSourceForTopic(topicId, options) {
+        // In some cases we need to do a single REST request to fetch the messages 
+        // and not use Banta's socket RPC since the open ended lifetime of a WebSocket connection 
+        // does not match the use case.
+        // - When running in SSR
+        // - When running in Googlebot (Googlebot also doesn't support WebSockets anyway)
+        if (this.isServer() || this.isGooglebot()) {
+            return new StaticChatSource(this, topicId, undefined, options);
+        }
+        else {
+            return await new ChatSource(this, topicId, undefined, { sortOrder: CommentsOrder.NEWEST, filterMode: FilterMode.ALL, ...options })
+                .bind(await this.connectToService());
+        }
+    }
+    async getSourceForThread(topicId, messageId, options) {
+        // When running on the server platform, we're just going to do a single REST request to fetch the messages 
+        // and not use Banta's socket RPC.
+        if (this.isServer()) {
+            return new StaticChatSource(this, topicId, messageId, options);
+        }
+        else {
+            return await new ChatSource(this, topicId, messageId, { sortOrder: CommentsOrder.NEWEST, filterMode: FilterMode.ALL, ...options })
+                .bind(await this.connectToService());
+        }
+    }
+    /**
+     * Get the count of the given topic
+     * @param topicId
+     * @returns
+     */
+    async getSourceCountForTopic(topicId) {
+        try {
+            let topic = await this.getTopic(topicId);
+            return topic?.messageCount ?? 0;
+        }
+        catch (e) {
+            console.error(`[Banta/${topicId}] Failed to get message count for topic:`);
+            console.error(e);
+            return undefined;
+        }
+    }
+    /**
+     * Get the count of the given topics.
+     * @param topicId Topics to count messages on. Maximum of 1000.
+     * @returns
+     */
+    async getSourceCountForTopics(topicIds) {
+        try {
+            let topics = await this.getTopicsById(topicIds);
+            return Object.fromEntries(topics.map(topic => [topic.id, topic.messageCount ?? 0]));
+        }
+        catch (e) {
+            console.error(`[Banta/Topics] Failed to get message count for topics '${topicIds.join(',')}]':`);
+            console.error(e);
+            return undefined;
+        }
+    }
+    /**
+     * Get information about the given topic.
+     * @param topicId
+     * @returns The topic object, or undefined if no such topic was found.
+     */
+    async getTopic(topicId) {
+        let response = await fetch(`${this.serviceUrl}/topics/${topicId}`);
+        if (response.status === 404)
+            return undefined;
+        if (response.status >= 400)
+            throw new Error(`Failed to fetch topic: ${response.status}`);
+        return await response.json();
+    }
+    /**
+     * Get information about the given topics
+     * @param topicIds The topic IDs to look up. Maximum of 1000.
+     * @returns An array of matching topic objects.
+     */
+    async getTopicsById(topicIds) {
+        if (topicIds.length > 1000)
+            throw new Error(`Cannot look up more than 1000 topics at a time.`);
+        let response = await fetch(`${this.serviceUrl}/topics?ids=${encodeURIComponent(topicIds.join(','))}`);
+        if (response.status >= 400)
+            throw new Error(`Failed to fetch topic: ${response.status}`);
+        return await response.json();
+    }
+    /**
+     * Get a set of messages from the given topic.
+     * @param topicId
+     * @returns
+     */
+    async getMessages(topicId, sort, filter, offset, limit) {
+        let response = await fetch(`${this.serviceUrl}/topics/${topicId}/messages?${buildQuery({ sort, filter, offset, limit })}`);
+        if (response.status >= 400)
+            throw new Error(`Failed to fetch messages for topic: ${response.status}`);
+        return await response.json();
+    }
+    /**
+     * Get a set of messages from the given topic.
+     * @param topicId
+     * @returns
+     */
+    async getReplies(parentMessageId, sort, filter, offset, limit) {
+        let response = await fetch(`${this.serviceUrl}/messages/${parentMessageId}/replies?${buildQuery({ sort, filter, offset, limit })}`);
+        if (response.status >= 400)
+            throw new Error(`Failed to fetch replies: ${response.status}`);
+        return await response.json();
+    }
+    refreshMessage(message) {
+        throw new Error("Method not implemented.");
+    }
+    getMessage(topicId, messageId) {
+        throw new Error("Method not implemented.");
+    }
+    getSubMessage(topicId, parentMessageId, messageId) {
+        throw new Error("Method not implemented.");
+    }
+    watchMessage(message, handler) {
+        throw new Error("Method not implemented.");
+    }
+    async getCardForUrl(url) {
+        let response = await fetch(`${this.serviceUrl}/urls`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                url
+            })
+        });
+        if (response.status == 404)
+            return null;
+        if (response.status >= 400)
+            throw new Error(`Failed to retrieve URL card: ${response.status}. Body: '${await response.text()}'`);
+        return await response.json();
+    }
+}
+ChatBackend.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ChatBackend, deps: [{ token: BANTA_SDK_OPTIONS }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+ChatBackend.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ChatBackend });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ChatBackend, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BANTA_SDK_OPTIONS]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat-backend.js","sourceRoot":"","sources":["../../../../projects/sdk/src/lib/chat-backend.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from \"@angular/core\";\r\nimport { ChatMessage, CommentsOrder, DurableSocket, FilterMode, Notification, Topic, UrlCard, User, Vote, buildQuery } from \"@banta/common\";\r\nimport { Observable } from \"rxjs\";\r\nimport { ChatBackendBase, ChatSourceOptions } from \"./chat-backend-base\";\r\nimport { ChatSource } from \"./chat-source\";\r\nimport { ChatSourceBase } from \"./chat-source-base\";\r\nimport { BANTA_SDK_OPTIONS, SdkOptions } from \"./sdk-options\";\r\nimport { PLATFORM_ID } from \"@angular/core\";\r\nimport { isPlatformServer } from \"@angular/common\";\r\nimport { StaticChatSource } from \"./static-chat-source\";\r\n\r\n@Injectable()\r\nexport class ChatBackend extends ChatBackendBase {\r\n    constructor(\r\n        @Inject(BANTA_SDK_OPTIONS) private options: SdkOptions,\r\n        @Inject(PLATFORM_ID) private platformId\r\n    ) {\r\n        super();\r\n    }\r\n\r\n    get serviceUrl() {\r\n        return `${this.options?.serviceUrl ?? 'http://localhost:3422'}`;\r\n    }\r\n\r\n    private async connectToService() {\r\n        let socket = new DurableSocket(`${this.serviceUrl.replace(/^http/, 'ws')}/socket`);\r\n        await new Promise<void>((resolve, reject) => {\r\n            socket.onopen = () => {\r\n                resolve();\r\n            }\r\n\r\n            socket.onclose = e => {\r\n                if (e.code === 503) {\r\n                    console.error(`Failed to connect to chat service!`);\r\n                    reject(e);\r\n                }\r\n            }\r\n        });\r\n\r\n        socket.onerror = undefined;\r\n\r\n        return socket;\r\n    }\r\n\r\n    private isServer() {\r\n        if (typeof localStorage !== 'undefined' && localStorage['banta:debug:useStaticSource'] === '1')\r\n            return true;\r\n\r\n        return isPlatformServer(this.platformId);\r\n    }\r\n\r\n    /**\r\n     * Check if we are currently running inside a Googlebot user agent or via the Google inspection tool in Search Console.\r\n     * We'll use this to avoid WebSockets so that comments can be indexable.\r\n     * @returns \r\n     */\r\n    private isGooglebot() {\r\n        return typeof navigator !== 'undefined' && (\r\n            navigator.userAgent.includes('Googlebot')\r\n            || navigator.userAgent.includes('Google-InspectionTool')\r\n        );\r\n    }\r\n\r\n    async getSourceForTopic(topicId: string, options?: ChatSourceOptions): Promise<ChatSourceBase> {\r\n        // In some cases we need to do a single REST request to fetch the messages \r\n        // and not use Banta's socket RPC since the open ended lifetime of a WebSocket connection \r\n        // does not match the use case.\r\n        // - When running in SSR\r\n        // - When running in Googlebot (Googlebot also doesn't support WebSockets anyway)\r\n\r\n        if (this.isServer() || this.isGooglebot()) {\r\n            return new StaticChatSource(this, topicId, undefined, options);\r\n        } else {\r\n            return await new ChatSource(this, topicId, undefined, { sortOrder: CommentsOrder.NEWEST, filterMode: FilterMode.ALL, ...options })\r\n                .bind(await this.connectToService());\r\n        }\r\n    }\r\n\r\n    async getSourceForThread(topicId: string, messageId: string, options?: ChatSourceOptions): Promise<ChatSourceBase> {\r\n        // When running on the server platform, we're just going to do a single REST request to fetch the messages \r\n        // and not use Banta's socket RPC.\r\n        \r\n        if (this.isServer()) {\r\n            return new StaticChatSource(this, topicId, messageId, options);\r\n        } else {\r\n            return await new ChatSource(this, topicId, messageId, { sortOrder: CommentsOrder.NEWEST, filterMode: FilterMode.ALL, ...options })\r\n                .bind(await this.connectToService());\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Get the count of the given topic\r\n     * @param topicId \r\n     * @returns \r\n     */\r\n    async getSourceCountForTopic(topicId: string): Promise<number> {\r\n        try {\r\n            let topic = await this.getTopic(topicId);\r\n            return topic?.messageCount ?? 0;\r\n        } catch (e) {\r\n            console.error(`[Banta/${topicId}] Failed to get message count for topic:`);\r\n            console.error(e);\r\n            return undefined;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Get the count of the given topics. \r\n     * @param topicId Topics to count messages on. Maximum of 1000.\r\n     * @returns \r\n     */\r\n    async getSourceCountForTopics(topicIds: string[]): Promise<Record<string, number>> {\r\n        try {\r\n            let topics = await this.getTopicsById(topicIds);\r\n            return Object.fromEntries(topics.map(topic => [ topic.id, topic.messageCount ?? 0 ]));\r\n        } catch (e) {\r\n            console.error(`[Banta/Topics] Failed to get message count for topics '${topicIds.join(',')}]':`);\r\n            console.error(e);\r\n            return undefined;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Get information about the given topic. \r\n     * @param topicId \r\n     * @returns The topic object, or undefined if no such topic was found.\r\n     */\r\n    async getTopic(topicId: string): Promise<Topic | undefined> {\r\n        let response = await fetch(`${this.serviceUrl}/topics/${topicId}`)\r\n        if (response.status === 404)\r\n            return undefined;\r\n        if (response.status >= 400)\r\n            throw new Error(`Failed to fetch topic: ${response.status}`)\r\n\r\n        return <Topic> await response.json();\r\n    }\r\n\r\n    /**\r\n     * Get information about the given topics\r\n     * @param topicIds The topic IDs to look up. Maximum of 1000.\r\n     * @returns An array of matching topic objects.\r\n     */\r\n    async getTopicsById(topicIds: string[]): Promise<Topic[]> {\r\n        if (topicIds.length > 1000)\r\n            throw new Error(`Cannot look up more than 1000 topics at a time.`);\r\n\r\n        let response = await fetch(`${this.serviceUrl}/topics?ids=${encodeURIComponent(topicIds.join(','))}`)\r\n        if (response.status >= 400)\r\n            throw new Error(`Failed to fetch topic: ${response.status}`)\r\n\r\n        return <Topic[]> await response.json();\r\n    }\r\n\r\n    /**\r\n     * Get a set of messages from the given topic.\r\n     * @param topicId \r\n     * @returns \r\n     */\r\n    async getMessages(\r\n        topicId: string, \r\n        sort?: CommentsOrder, \r\n        filter?: FilterMode, \r\n        offset?: number, \r\n        limit?: number\r\n    ): Promise<ChatMessage[]> {\r\n        let response = await fetch(\r\n            `${this.serviceUrl}/topics/${topicId}/messages?${ buildQuery({ sort, filter, offset, limit }) }`\r\n        );\r\n\r\n        if (response.status >= 400)\r\n            throw new Error(`Failed to fetch messages for topic: ${response.status}`)\r\n\r\n        return <ChatMessage[]> await response.json();\r\n    }\r\n\r\n    /**\r\n     * Get a set of messages from the given topic.\r\n     * @param topicId \r\n     * @returns \r\n     */\r\n    async getReplies(\r\n        parentMessageId: string,\r\n        sort?: CommentsOrder, \r\n        filter?: FilterMode, \r\n        offset?: number, \r\n        limit?: number\r\n    ): Promise<ChatMessage[]> {\r\n        let response = await fetch(\r\n            `${this.serviceUrl}/messages/${parentMessageId}/replies?${ buildQuery({ sort, filter, offset, limit }) }`\r\n        );\r\n\r\n        if (response.status >= 400)\r\n            throw new Error(`Failed to fetch replies: ${response.status}`)\r\n\r\n        return <ChatMessage[]> await response.json();\r\n    }\r\n\r\n    refreshMessage(message: ChatMessage): Promise<ChatMessage> {\r\n        throw new Error(\"Method not implemented.\");\r\n    }\r\n    \r\n    getMessage(topicId: string, messageId: string): Promise<ChatMessage> {\r\n        throw new Error(\"Method not implemented.\");\r\n    }\r\n    getSubMessage(topicId: string, parentMessageId: string, messageId: string): Promise<ChatMessage> {\r\n        throw new Error(\"Method not implemented.\");\r\n    }\r\n    watchMessage(message: ChatMessage, handler: (message: ChatMessage) => void): () => void {\r\n        throw new Error(\"Method not implemented.\");\r\n    }\r\n    notificationsChanged: Observable<Notification[]>;\r\n    newNotification: Observable<Notification>;\r\n    \r\n    async getCardForUrl(url: string): Promise<UrlCard> {\r\n        let response = await fetch(`${this.serviceUrl}/urls`, {\r\n            method: 'POST',\r\n            headers: {\r\n                'Content-Type': 'application/json'\r\n            },\r\n            body: JSON.stringify({\r\n                url\r\n            })\r\n        });\r\n\r\n        if (response.status == 404)\r\n            return null;\r\n        \r\n        if (response.status >= 400)\r\n            throw new Error(`Failed to retrieve URL card: ${response.status}. Body: '${await response.text()}'`);\r\n\r\n        return await response.json();\r\n    }\r\n}"]}

package/{esm2022 → esm2020}/lib/chat-source-base.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/chat-source.mjs

@@ -0,0 +1,233 @@
+import { __decorate } from "tslib";
+import { BehaviorSubject, Subject, Subscription } from "rxjs";
+import { RpcEvent, SocketRPC } from "@banta/common";
+import { v4 as uuid } from "uuid";
+export class ChatSource extends SocketRPC {
+    constructor(backend, identifier, parentIdentifier, options) {
+        super();
+        this.backend = backend;
+        this.identifier = identifier;
+        this.parentIdentifier = parentIdentifier;
+        this.subscription = new Subscription();
+        this.readonly = false;
+        this.canLoadMore = true;
+        this._state = 'connecting';
+        this._connectionStateChanged = new Subject();
+        this._connectionStateChanged$ = this._connectionStateChanged.asObservable();
+        this.wasRestored = false;
+        this.subscribeAttempt = 0;
+        this._signInState = 'signed-out';
+        this._signInStateChanged = new BehaviorSubject(this._signInState);
+        this._signInStateChanged$ = this._signInStateChanged.asObservable();
+        this.messageMap = new Map();
+        this._messageReceived = new Subject();
+        this._messageUpdated = new Subject();
+        this._messageSent = new Subject();
+        this._messageObserved = new Subject();
+        this.messages = [];
+        this.options = options ?? {};
+        this.ready = new Promise(resolve => this.markReady = resolve);
+    }
+    get sortOrder() {
+        return this.options?.sortOrder;
+    }
+    get filterMode() {
+        return this.options?.filterMode;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        this._state = value;
+        setTimeout(() => this._connectionStateChanged.next(this._state));
+    }
+    get connectionStateChanged() { return this._connectionStateChanged$; }
+    async bind(socket) {
+        super.bind(socket);
+        this.subscription.add(this.backend.userChanged.subscribe(() => this.authenticate()));
+        socket.addEventListener('open', async () => {
+            console.log(`[Banta/${this.identifier}] Socket is open`);
+        });
+        socket.addEventListener('error', async () => {
+            console.log(`[Banta/${this.identifier}] Socket error`);
+        });
+        socket.addEventListener('lost', async () => {
+            this.state = 'lost';
+        });
+        socket.addEventListener('restore', async () => {
+            this.wasRestored = true;
+            await this.authenticate();
+            await this.subscribeToTopic();
+        });
+        try {
+            await this.subscribeToTopic();
+        }
+        catch (e) {
+            console.error(`[Banta/ChatSource] Error during initial subscribeToTopic: ${e.message}`);
+        }
+        return this;
+    }
+    mapOrUpdateMessages(messages) {
+        return messages.map(message => this.mapOrUpdateMessage(message));
+    }
+    mapOrUpdateMessage(message) {
+        let existingMessage = this.messageMap.get(message.id);
+        if (existingMessage) {
+            message = Object.assign(existingMessage, message);
+        }
+        else {
+            this.messageMap.set(message.id, message);
+            this._messageObserved.next(message);
+        }
+        return message;
+    }
+    async getExistingMessages() {
+        try {
+            let messages = await this.idempotentPeer.getExistingMessages(this.options.initialMessageCount ?? 20);
+            messages = this.mapOrUpdateMessages(messages);
+            return messages;
+        }
+        catch (e) {
+            console.error(`[Banta/${this.identifier}] Error occurred while trying to get existing messages:`);
+            console.error(e);
+            return [];
+        }
+    }
+    async ensureConnection(errorMessage) {
+        // let reason = `Connection to chat services is not currently available.`;
+        // if (this.state !== 'connected' && this.state !== 'restored') {
+        //     if (errorMessage)
+        //         throw new Error(`${errorMessage}: ${reason}`);
+        //     else
+        //         throw new Error(`${reason}`);
+        // }
+    }
+    async editMessage(messageId, text) {
+        await this.ensureConnection();
+        await this.peer.editMessage(messageId, text);
+    }
+    get errorState() {
+        return this._errorState;
+    }
+    async subscribeToTopic() {
+        try {
+            await this.immediatePeer.subscribe(this.identifier, this.parentIdentifier, this.options.sortOrder, this.options.filterMode, this.options.metadata ?? {});
+            this.subscribeAttempt = 0;
+            this._errorState = undefined;
+            this.state = this.wasRestored ? 'restored' : 'connected';
+            this.markReady();
+        }
+        catch (e) {
+            console.error(`[Banta/${this.identifier}] Error while subscribing to topic`);
+            console.error(e);
+            this.state = 'lost';
+            this._errorState = 'server-issue';
+            this.subscribeAttempt += 1;
+            let delay = Math.min(30 * 1000, (3 * 1000 * this.subscribeAttempt) * (1 + Math.random()));
+            console.error(`[Banta/${this.identifier}] Waiting ${delay}ms before attempting to reconnect...`);
+            setTimeout(() => {
+                if (this.state === 'lost') {
+                    console.info(`Attempting reconnection after error in subscribeToTopic...`);
+                    this.reconnect();
+                }
+            }, delay);
+            throw e;
+        }
+    }
+    get signInState() { return this._signInState; }
+    get signInStateChanged() { return this._signInStateChanged$; }
+    setSignInState(state) {
+        this._signInState = state;
+        this._signInStateChanged.next(state);
+    }
+    async authenticate() {
+        this.setSignInState('signing-in');
+        if (this.backend.user) {
+            try {
+                // console.log(`Artificial delay...`);
+                // await new Promise(r => setTimeout(r, 30_000));
+                // console.log(`Artificial delay complete...`);
+                await this.immediatePeer.authenticate(this.backend.user?.token);
+                this.setSignInState('signed-in');
+            }
+            catch (e) {
+                console.error(`[Banta] Could not authenticate:`);
+                console.error(e);
+                this.setSignInState('signed-out');
+            }
+        }
+    }
+    close() {
+        super.close();
+        this.subscription.unsubscribe();
+    }
+    onPermissions(permissions) {
+        window.bantaPermissionsDebug = permissions;
+        this.permissions = permissions;
+    }
+    onChatMessage(message) {
+        if (this.messageMap.has(message.id)) {
+            return this.mapOrUpdateMessage(message);
+        }
+        else if (!message.hidden) {
+            // Only process non-hidden messages through here. 
+            // Hidden messages may be sent to us when they become hidden (ie moderation is occurring).
+            // But if we never had the message to begin with, we should discard it.
+            this.messageMap.set(message.id, message);
+            this._messageReceived.next(message);
+        }
+    }
+    get messageReceived() { return this._messageReceived.asObservable(); }
+    get messageUpdated() { return this._messageUpdated.asObservable(); }
+    get messageSent() { return this._messageSent.asObservable(); }
+    get messageObserved() { return this._messageObserved.asObservable(); }
+    async send(message) {
+        await this.ensureConnection();
+        message.id ?? (message.id = uuid());
+        return await this.idempotentPeer.sendMessage(message);
+    }
+    async loadAfter(message, count) {
+        if (!message)
+            return;
+        if (!message.pagingCursor)
+            return [];
+        return this.mapOrUpdateMessages(await this.idempotentPeer.loadAfter(Number(message.pagingCursor), count));
+    }
+    async get(id) {
+        if (this.messageMap.has(id))
+            return this.messageMap.get(id);
+        await this.ensureConnection(`Could not get message`);
+        let message = await this.idempotentPeer.getMessage(id);
+        if (this.messageMap.has(id)) {
+            let existingMessage = this.messageMap.get(id);
+            Object.assign(existingMessage, message);
+            message = existingMessage;
+        }
+        else {
+            this.messageMap.set(id, message);
+        }
+        return message;
+    }
+    async getCount() {
+        return await this.idempotentPeer.getCount();
+    }
+    async likeMessage(messageId) {
+        await this.ensureConnection();
+        return await this.idempotentPeer.likeMessage(messageId);
+    }
+    async unlikeMessage(messageId) {
+        await this.ensureConnection();
+        return await this.idempotentPeer.unlikeMessage(messageId);
+    }
+    async deleteMessage(messageId) {
+        await this.ensureConnection();
+        return await this.idempotentPeer.deleteMessage(messageId);
+    }
+}
+__decorate([
+    RpcEvent()
+], ChatSource.prototype, "onPermissions", null);
+__decorate([
+    RpcEvent()
+], ChatSource.prototype, "onChatMessage", null);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chat-source.js","sourceRoot":"","sources":["../../../../projects/sdk/src/lib/chat-source.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChatMessage, ChatPermissions, CommentsOrder, DurableSocket, User } from \"@banta/common\";\r\nimport { BehaviorSubject, Subject, Subscription } from \"rxjs\";\r\nimport { RpcEvent, SocketRPC } from \"@banta/common\";\r\nimport { ChatSourceBase } from \"./chat-source-base\";\r\nimport { ChatBackend } from \"./chat-backend\";\r\nimport { v4 as uuid } from \"uuid\";\r\nimport { ChatSourceOptions } from \"./chat-backend-base\";\r\n\r\nexport type SignInState = 'signed-out' | 'signed-in' | 'signing-in';\r\n\r\nexport class ChatSource extends SocketRPC implements ChatSourceBase {\r\n    constructor(\r\n        readonly backend: ChatBackend,\r\n        readonly identifier: string,\r\n        readonly parentIdentifier: string,\r\n        options: ChatSourceOptions\r\n    ) {\r\n        super();\r\n        this.options = options ?? {};\r\n        this.ready = new Promise<void>(resolve => this.markReady = resolve);\r\n    }\r\n\r\n    private options: ChatSourceOptions;\r\n    private subscription = new Subscription();\r\n    private markReady: () => void;\r\n\r\n    readonly = false;\r\n    canLoadMore = true;\r\n\r\n    ready: Promise<void>;\r\n\r\n    permissions: ChatPermissions;\r\n    private _state: 'connected' | 'connecting' | 'lost' | 'restored' = 'connecting';\r\n\r\n    get sortOrder() {\r\n        return this.options?.sortOrder;\r\n    }\r\n\r\n    get filterMode() {\r\n        return this.options?.filterMode;\r\n    }\r\n\r\n    get state() {\r\n        return this._state;\r\n    }\r\n\r\n    set state(value) {\r\n        this._state = value;\r\n        setTimeout(() => this._connectionStateChanged.next(this._state));\r\n    }\r\n\r\n    private _connectionStateChanged = new Subject<'connected' | 'connecting' | 'lost' | 'restored'>();\r\n    private _connectionStateChanged$ = this._connectionStateChanged.asObservable();\r\n    get connectionStateChanged() { return this._connectionStateChanged$; }\r\n\r\n    private wasRestored = false;\r\n\r\n    async bind(socket: DurableSocket): Promise<this> {\r\n        super.bind(socket);\r\n\r\n        this.subscription.add(this.backend.userChanged.subscribe(() => this.authenticate()));\r\n\r\n        socket.addEventListener('open', async () => {\r\n            console.log(`[Banta/${this.identifier}] Socket is open`);\r\n        });\r\n\r\n        socket.addEventListener('error', async () => {\r\n            console.log(`[Banta/${this.identifier}] Socket error`);\r\n        });\r\n\r\n        socket.addEventListener('lost', async () => {\r\n            this.state = 'lost';\r\n        });\r\n\r\n        socket.addEventListener('restore', async () => {\r\n            this.wasRestored = true;\r\n            await this.authenticate();\r\n            await this.subscribeToTopic();\r\n        });\r\n\r\n        try {\r\n            await this.subscribeToTopic();\r\n        } catch (e) {\r\n            console.error(`[Banta/ChatSource] Error during initial subscribeToTopic: ${e.message}`);\r\n        }\r\n        \r\n        return this;\r\n    }\r\n\r\n    private mapOrUpdateMessages(messages: ChatMessage[]): ChatMessage[] {\r\n        return messages.map(message => this.mapOrUpdateMessage(message));\r\n    }\r\n\r\n    private mapOrUpdateMessage(message: ChatMessage): ChatMessage {\r\n        let existingMessage = this.messageMap.get(message.id);\r\n        if (existingMessage) {\r\n            message = Object.assign(existingMessage, message);\r\n        } else {\r\n            this.messageMap.set(message.id, message);\r\n            this._messageObserved.next(message);\r\n        }\r\n\r\n        return message;\r\n    }\r\n\r\n    async getExistingMessages(): Promise<ChatMessage[]> {\r\n        try {\r\n            let messages = await this.idempotentPeer.getExistingMessages(this.options.initialMessageCount ?? 20);\r\n            messages = this.mapOrUpdateMessages(messages);\r\n            return messages;\r\n        } catch (e) {\r\n            console.error(`[Banta/${this.identifier}] Error occurred while trying to get existing messages:`);\r\n            console.error(e);\r\n            return [];\r\n        }\r\n    }\r\n\r\n    private async ensureConnection(errorMessage?: string) {\r\n        // let reason = `Connection to chat services is not currently available.`;\r\n        // if (this.state !== 'connected' && this.state !== 'restored') {\r\n        //     if (errorMessage)\r\n        //         throw new Error(`${errorMessage}: ${reason}`);\r\n        //     else\r\n        //         throw new Error(`${reason}`);\r\n        // }\r\n    }\r\n\r\n    async editMessage(messageId: string, text: string): Promise<void> {\r\n        await this.ensureConnection();\r\n        await this.peer.editMessage(messageId, text);\r\n    }\r\n\r\n    private subscribeAttempt = 0;\r\n    private _errorState: string;\r\n\r\n    get errorState() {\r\n        return this._errorState;\r\n    }\r\n\r\n    async subscribeToTopic() {\r\n        try {\r\n            await this.immediatePeer.subscribe(\r\n                this.identifier, this.parentIdentifier, this.options.sortOrder, \r\n                this.options.filterMode,\r\n                this.options.metadata ?? {}\r\n            );\r\n            this.subscribeAttempt = 0;\r\n            this._errorState = undefined;\r\n            this.state = this.wasRestored ? 'restored' : 'connected';\r\n            this.markReady();\r\n\r\n        } catch (e) {\r\n            console.error(`[Banta/${this.identifier}] Error while subscribing to topic`);\r\n            console.error(e);\r\n\r\n            this.state = 'lost';\r\n            this._errorState = 'server-issue';\r\n\r\n            this.subscribeAttempt += 1;\r\n            let delay = Math.min(30*1000, (3*1000 * this.subscribeAttempt) * (1 + Math.random()));\r\n            console.error(`[Banta/${this.identifier}] Waiting ${delay}ms before attempting to reconnect...`);\r\n\r\n            setTimeout(() => {\r\n                if (this.state === 'lost') {\r\n                    console.info(`Attempting reconnection after error in subscribeToTopic...`);\r\n                    this.reconnect();\r\n                }\r\n            }, delay);\r\n\r\n            throw e;\r\n        }\r\n    }\r\n\r\n    private _signInState: SignInState = 'signed-out';\r\n    private _signInStateChanged = new BehaviorSubject<SignInState>(this._signInState);\r\n    private _signInStateChanged$ = this._signInStateChanged.asObservable();\r\n\r\n    get signInState() { return this._signInState; }\r\n    get signInStateChanged() { return this._signInStateChanged$; }\r\n\r\n    private setSignInState(state: SignInState) {\r\n        this._signInState = state;\r\n        this._signInStateChanged.next(state);\r\n    }\r\n    async authenticate() {\r\n        this.setSignInState('signing-in');\r\n        if (this.backend.user) {\r\n            try {\r\n                // console.log(`Artificial delay...`);\r\n                // await new Promise(r => setTimeout(r, 30_000));\r\n                // console.log(`Artificial delay complete...`);\r\n                await this.immediatePeer.authenticate(this.backend.user?.token);\r\n                this.setSignInState('signed-in');\r\n            } catch (e) {\r\n                console.error(`[Banta] Could not authenticate:`);\r\n                console.error(e);\r\n                this.setSignInState('signed-out');\r\n            }\r\n        }\r\n    }\r\n\r\n    close(): void {\r\n        super.close();\r\n        this.subscription.unsubscribe();\r\n    }\r\n\r\n    @RpcEvent()\r\n    onPermissions(permissions: ChatPermissions) {\r\n        (window as any).bantaPermissionsDebug = permissions;\r\n        this.permissions = permissions;\r\n    }\r\n\r\n    @RpcEvent()\r\n    onChatMessage(message: ChatMessage) {\r\n        if (this.messageMap.has(message.id)) {\r\n            return this.mapOrUpdateMessage(message);\r\n        } else if (!message.hidden) {\r\n            // Only process non-hidden messages through here. \r\n            // Hidden messages may be sent to us when they become hidden (ie moderation is occurring).\r\n            // But if we never had the message to begin with, we should discard it.\r\n            this.messageMap.set(message.id, message);\r\n            this._messageReceived.next(message);\r\n        }\r\n    }\r\n\r\n    private messageMap = new Map<string, ChatMessage>();\r\n    private _messageReceived = new Subject<ChatMessage>();\r\n    private _messageUpdated = new Subject<ChatMessage>();\r\n    private _messageSent = new Subject<ChatMessage>();\r\n    private _messageObserved = new Subject<ChatMessage>();\r\n\r\n    get messageReceived() { return this._messageReceived.asObservable(); }\r\n    get messageUpdated() { return this._messageUpdated.asObservable(); }\r\n    get messageSent() { return this._messageSent.asObservable(); }\r\n    get messageObserved() { return this._messageObserved.asObservable(); }\r\n\r\n    messages: ChatMessage[] = [];\r\n\r\n    async send(message: ChatMessage): Promise<ChatMessage> {\r\n        await this.ensureConnection();\r\n        message.id ??= uuid();\r\n        return await this.idempotentPeer.sendMessage(message);\r\n    }\r\n\r\n    async loadAfter(message: ChatMessage, count: number): Promise<ChatMessage[]> {\r\n        if (!message)\r\n            return;\r\n\r\n        if (!message.pagingCursor)\r\n            return [];\r\n        \r\n        return this.mapOrUpdateMessages(\r\n            await this.idempotentPeer.loadAfter(Number(message.pagingCursor), count)\r\n        );\r\n    }\r\n\r\n    async get(id: string): Promise<ChatMessage> {\r\n        if (this.messageMap.has(id))\r\n            return this.messageMap.get(id);\r\n        \r\n        await this.ensureConnection(`Could not get message`);\r\n        let message = await this.idempotentPeer.getMessage(id);\r\n\r\n        if (this.messageMap.has(id)) {\r\n            let existingMessage = this.messageMap.get(id);\r\n            Object.assign(existingMessage, message);\r\n            message = existingMessage;\r\n        } else {\r\n            this.messageMap.set(id, message);\r\n        }\r\n\r\n        return message;\r\n    }\r\n\r\n    async getCount(): Promise<number> {\r\n        return await this.idempotentPeer.getCount();\r\n    }\r\n\r\n    async likeMessage(messageId: string): Promise<void> {\r\n        await this.ensureConnection();\r\n        return await this.idempotentPeer.likeMessage(messageId);\r\n    }\r\n\r\n    async unlikeMessage(messageId: string): Promise<void> {\r\n        await this.ensureConnection();\r\n        return await this.idempotentPeer.unlikeMessage(messageId);\r\n    }\r\n\r\n    async deleteMessage(messageId: string): Promise<void> {\r\n        await this.ensureConnection();\r\n        return await this.idempotentPeer.deleteMessage(messageId);\r\n    }\r\n\r\n}"]}

package/esm2020/lib/comments/attachment-button/attachment-button.component.mjs

@@ -0,0 +1,76 @@
+import { Component, Input, Output, ViewChild } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@banta/common";
+import * as i2 from "@angular/material/icon";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/material/tooltip";
+export class AttachmentButtonComponent {
+    constructor(cdnProvider) {
+        this.cdnProvider = cdnProvider;
+        //#region Properties
+        this._addedAttachment = new Subject();
+        this._attachmentError = new Subject();
+        //#endregion
+        //#region Inputs
+        this.disabled = false;
+    }
+    //#endregion
+    //#region Outputs
+    get addedAttachment() { return this._addedAttachment.asObservable(); }
+    get attachmentError() { return this._attachmentError.asObservable(); }
+    //#endregion
+    show() { this.fileInput.nativeElement.click(); }
+    async fileChange(event) {
+        const element = event.currentTarget;
+        if (element.files.length) {
+            console.log('[Banta] File Added to comment');
+            const file = element.files[0];
+            let publicURL;
+            let attachment = {
+                type: file.type,
+                url: undefined,
+                transientState: {
+                    uploading: true,
+                    error: false,
+                    errorMessage: undefined
+                }
+            };
+            this._addedAttachment.next(attachment);
+            try {
+                publicURL = await this.cdnProvider.uploadImage(file);
+            }
+            catch (e) {
+                attachment.transientState.error = true;
+                attachment.transientState.errorMessage = "Failed to upload";
+                console.error(`[Banta] Caught an error while uploading image to CDN:`);
+                console.error(e);
+                alert(e.message);
+                this._attachmentError.next(attachment);
+                return;
+            }
+            // If no URL was returned, then an error must have occurred. Presumably the CDN
+            // provider has conveyed an error to the user.
+            if (!publicURL)
+                return;
+            attachment.url = publicURL;
+            attachment.transientState = undefined;
+        }
+    }
+}
+AttachmentButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AttachmentButtonComponent, deps: [{ token: i1.CDNProvider }], target: i0.ɵɵFactoryTarget.Component });
+AttachmentButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: AttachmentButtonComponent, selector: "banta-attachment-button", inputs: { disabled: "disabled" }, outputs: { addedAttachment: "addedAttachment", attachmentError: "attachmentError" }, viewQueries: [{ propertyName: "fileInput", first: true, predicate: ["fileUpload"], descendants: true }], ngImport: i0, template: "<button matTooltip=\"Add an image or gif\" #button type=\"button\" mat-icon-button (click)=\"show()\" [disabled]=\"disabled\">\r\n\t<mat-icon>image</mat-icon>\r\n</button>\r\n<input style=\"display: none;\" #fileUpload [multiple]=\"false\"  (change)=\"fileChange($event)\" type=\"file\" >", styles: ["button{color:#666}\n"], dependencies: [{ kind: "component", type: i2.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i3.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { kind: "directive", type: i4.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AttachmentButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'banta-attachment-button', template: "<button matTooltip=\"Add an image or gif\" #button type=\"button\" mat-icon-button (click)=\"show()\" [disabled]=\"disabled\">\r\n\t<mat-icon>image</mat-icon>\r\n</button>\r\n<input style=\"display: none;\" #fileUpload [multiple]=\"false\"  (change)=\"fileChange($event)\" type=\"file\" >", styles: ["button{color:#666}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.CDNProvider }]; }, propDecorators: { disabled: [{
+                type: Input
+            }], addedAttachment: [{
+                type: Output
+            }], attachmentError: [{
+                type: Output
+            }], fileInput: [{
+                type: ViewChild,
+                args: ['fileUpload', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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