@banta/sdk 4.9.1 → 5.0.1

package/{esm2020 → esm2022}/lib/chat/chat.module.mjs

@@ -1,51 +1,51 @@
-import { NgModule } from "@angular/core";
-import { ChatMessageComponent } from './chat-message/chat-message.component';
-import { ChatViewComponent } from './chat-view/chat-view.component';
-import { BantaChatComponent } from './banta-chat/banta-chat.component';
-import { CommonModule } from '@angular/common';
-import { FormsModule } from '@angular/forms';
-import { EmojiModule } from '../emoji';
-import { LiveChatMessageComponent } from './live-chat-message.component';
-import { MatButtonModule } from '@angular/material/button';
-import { MatIconModule } from '@angular/material/icon';
-import * as i0 from "@angular/core";
-const COMPONENTS = [
-    ChatMessageComponent,
-    LiveChatMessageComponent,
-    ChatViewComponent,
-    BantaChatComponent
-];
-export class ChatModule {
-}
-ChatModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ChatModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ChatModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: ChatModule, declarations: [ChatMessageComponent,
-        LiveChatMessageComponent,
-        ChatViewComponent,
-        BantaChatComponent], imports: [CommonModule,
-        FormsModule,
-        MatIconModule,
-        MatButtonModule,
-        EmojiModule], exports: [ChatMessageComponent,
-        LiveChatMessageComponent,
-        ChatViewComponent,
-        BantaChatComponent] });
-ChatModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ChatModule, imports: [CommonModule,
-        FormsModule,
-        MatIconModule,
-        MatButtonModule,
-        EmojiModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: ChatModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: COMPONENTS,
-                    imports: [
-                        CommonModule,
-                        FormsModule,
-                        MatIconModule,
-                        MatButtonModule,
-                        EmojiModule
-                    ],
-                    exports: COMPONENTS
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+import { NgModule } from "@angular/core";
+import { ChatMessageComponent } from './chat-message/chat-message.component';
+import { ChatViewComponent } from './chat-view/chat-view.component';
+import { BantaChatComponent } from './banta-chat/banta-chat.component';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { EmojiModule } from '../emoji';
+import { LiveChatMessageComponent } from './live-chat-message.component';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    ChatMessageComponent,
+    LiveChatMessageComponent,
+    ChatViewComponent,
+    BantaChatComponent
+];
+export class ChatModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ChatModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.8", ngImport: i0, type: ChatModule, declarations: [ChatMessageComponent,
+            LiveChatMessageComponent,
+            ChatViewComponent,
+            BantaChatComponent], imports: [CommonModule,
+            FormsModule,
+            MatIconModule,
+            MatButtonModule,
+            EmojiModule], exports: [ChatMessageComponent,
+            LiveChatMessageComponent,
+            ChatViewComponent,
+            BantaChatComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ChatModule, imports: [CommonModule,
+            FormsModule,
+            MatIconModule,
+            MatButtonModule,
+            EmojiModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ChatModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: COMPONENTS,
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        MatIconModule,
+                        MatButtonModule,
+                        EmojiModule
+                    ],
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/chat/index.mjs

@@ -1,6 +1,6 @@
-export * from './chat-message/chat-message.component';
-export * from './live-chat-message.component';
-export * from './chat-view/chat-view.component';
-export * from './banta-chat/banta-chat.component';
-export * from './chat.module';
+export * from './chat-message/chat-message.component';
+export * from './live-chat-message.component';
+export * from './chat-view/chat-view.component';
+export * from './banta-chat/banta-chat.component';
+export * from './chat.module';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zZGsvc3JjL2xpYi9jaGF0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NoYXQtbWVzc2FnZS9jaGF0LW1lc3NhZ2UuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9saXZlLWNoYXQtbWVzc2FnZS5jb21wb25lbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NoYXQtdmlldy9jaGF0LXZpZXcuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9iYW50YS1jaGF0L2JhbnRhLWNoYXQuY29tcG9uZW50JztcclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vY2hhdC5tb2R1bGUnOyJdfQ==

package/esm2022/lib/chat/live-chat-message.component.mjs

@@ -0,0 +1,80 @@
+import { Component, Input, Output } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../chat-backend-base";
+import * as i2 from "@angular/common";
+import * as i3 from "./chat-message/chat-message.component";
+export class LiveChatMessageComponent {
+    constructor(backend) {
+        this.backend = backend;
+        this._upvoted = new Subject();
+        this._reported = new Subject();
+        this._selected = new Subject();
+    }
+    get upvoted() {
+        return this._upvoted;
+    }
+    get reported() {
+        return this._reported;
+    }
+    get selected() {
+        return this._selected;
+    }
+    get message() {
+        return this._message;
+    }
+    set message(value) {
+        let originalId = null;
+        if (this._message)
+            originalId = this._message.id;
+        this._message = value;
+        if (value && originalId === value.id) {
+            return;
+        }
+        if (this.unsubscribe)
+            this.unsubscribe();
+        if (value) {
+            this.unsubscribe = this.backend.watchMessage(value, message => this.message = message);
+        }
+    }
+    report() {
+        this._reported.next();
+    }
+    upvote() {
+        this._upvoted.next();
+    }
+    select() {
+        this._selected.next();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: LiveChatMessageComponent, deps: [{ token: i1.ChatBackendBase }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: LiveChatMessageComponent, selector: "banta-live-chat-message", inputs: { message: "message" }, outputs: { upvoted: "upvoted", reported: "reported", selected: "selected" }, ngImport: i0, template: `
+        <banta-chat-message 
+            *ngIf="message"
+            [message]="message"
+            (upvoted)="upvote()"
+            (reported)="report()"
+            (selected)="select()"
+            ></banta-chat-message>
+    `, isInline: true, styles: [""], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.ChatMessageComponent, selector: "banta-chat-message", inputs: ["message"], outputs: ["userSelected", "selected", "reported", "upvoted"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: LiveChatMessageComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'banta-live-chat-message', template: `
+        <banta-chat-message 
+            *ngIf="message"
+            [message]="message"
+            (upvoted)="upvote()"
+            (reported)="report()"
+            (selected)="select()"
+            ></banta-chat-message>
+    ` }]
+        }], ctorParameters: () => [{ type: i1.ChatBackendBase }], propDecorators: { upvoted: [{
+                type: Output
+            }], reported: [{
+                type: Output
+            }], selected: [{
+                type: Output
+            }], message: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGl2ZS1jaGF0LW1lc3NhZ2UuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2RrL3NyYy9saWIvY2hhdC9saXZlLWNoYXQtbWVzc2FnZS5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpELE9BQU8sRUFBRSxPQUFPLEVBQWMsTUFBTSxNQUFNLENBQUM7Ozs7O0FBZ0IzQyxNQUFNLE9BQU8sd0JBQXdCO0lBQ2pDLFlBQ1ksT0FBeUI7UUFBekIsWUFBTyxHQUFQLE9BQU8sQ0FBa0I7UUFNN0IsYUFBUSxHQUFHLElBQUksT0FBTyxFQUFRLENBQUM7UUFDL0IsY0FBUyxHQUFHLElBQUksT0FBTyxFQUFRLENBQUM7UUFDaEMsY0FBUyxHQUFHLElBQUksT0FBTyxFQUFRLENBQUM7SUFMeEMsQ0FBQztJQU9ELElBQ0ksT0FBTztRQUNQLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUN6QixDQUFDO0lBRUQsSUFDSSxRQUFRO1FBQ1IsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDO0lBQzFCLENBQUM7SUFFRCxJQUNJLFFBQVE7UUFDUixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUM7SUFDMUIsQ0FBQztJQUVELElBQ0ksT0FBTztRQUNQLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUN6QixDQUFDO0lBSUQsSUFBSSxPQUFPLENBQUMsS0FBSztRQUNiLElBQUksVUFBVSxHQUFHLElBQUksQ0FBQztRQUN0QixJQUFJLElBQUksQ0FBQyxRQUFRO1lBQ2IsVUFBVSxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDO1FBRWxDLElBQUksQ0FBQyxRQUFRLEdBQUcsS0FBSyxDQUFDO1FBRXRCLElBQUksS0FBSyxJQUFJLFVBQVUsS0FBSyxLQUFLLENBQUMsRUFBRSxFQUFFLENBQUM7WUFDbkMsT0FBTztRQUNYLENBQUM7UUFFRCxJQUFJLElBQUksQ0FBQyxXQUFXO1lBQ2hCLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUV2QixJQUFJLEtBQUssRUFBRSxDQUFDO1lBQ1IsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQyxDQUFDO1FBQzNGLENBQUM7SUFDTCxDQUFDO0lBRUQsTUFBTTtRQUNGLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDMUIsQ0FBQztJQUVELE1BQU07UUFDRixJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3pCLENBQUM7SUFFRCxNQUFNO1FBQ0YsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUMxQixDQUFDOzhHQS9EUSx3QkFBd0I7a0dBQXhCLHdCQUF3Qiw0S0FYdkI7Ozs7Ozs7O0tBUVQ7OzJGQUdRLHdCQUF3QjtrQkFicEMsU0FBUzsrQkFDSSx5QkFBeUIsWUFDekI7Ozs7Ozs7O0tBUVQ7b0ZBZ0JHLE9BQU87c0JBRFYsTUFBTTtnQkFNSCxRQUFRO3NCQURYLE1BQU07Z0JBTUgsUUFBUTtzQkFEWCxNQUFNO2dCQU1ILE9BQU87c0JBRFYsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQsIE91dHB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBDaGF0TWVzc2FnZSB9IGZyb20gJ0BiYW50YS9jb21tb24nO1xyXG5pbXBvcnQgeyBTdWJqZWN0LCBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IENoYXRCYWNrZW5kQmFzZSB9IGZyb20gJy4uL2NoYXQtYmFja2VuZC1iYXNlJztcclxuXHJcbkBDb21wb25lbnQoe1xyXG4gICAgc2VsZWN0b3I6ICdiYW50YS1saXZlLWNoYXQtbWVzc2FnZScsXHJcbiAgICB0ZW1wbGF0ZTogYFxyXG4gICAgICAgIDxiYW50YS1jaGF0LW1lc3NhZ2UgXHJcbiAgICAgICAgICAgICpuZ0lmPVwibWVzc2FnZVwiXHJcbiAgICAgICAgICAgIFttZXNzYWdlXT1cIm1lc3NhZ2VcIlxyXG4gICAgICAgICAgICAodXB2b3RlZCk9XCJ1cHZvdGUoKVwiXHJcbiAgICAgICAgICAgIChyZXBvcnRlZCk9XCJyZXBvcnQoKVwiXHJcbiAgICAgICAgICAgIChzZWxlY3RlZCk9XCJzZWxlY3QoKVwiXHJcbiAgICAgICAgICAgID48L2JhbnRhLWNoYXQtbWVzc2FnZT5cclxuICAgIGAsXHJcbiAgICBzdHlsZXM6IFtgYF1cclxufSlcclxuZXhwb3J0IGNsYXNzIExpdmVDaGF0TWVzc2FnZUNvbXBvbmVudCB7XHJcbiAgICBjb25zdHJ1Y3RvcihcclxuICAgICAgICBwcml2YXRlIGJhY2tlbmQgOiBDaGF0QmFja2VuZEJhc2VcclxuICAgICkge1xyXG5cclxuICAgIH1cclxuXHJcbiAgICBwcml2YXRlIF9tZXNzYWdlIDogQ2hhdE1lc3NhZ2U7XHJcbiAgICBwcml2YXRlIF91cHZvdGVkID0gbmV3IFN1YmplY3Q8dm9pZD4oKTtcclxuICAgIHByaXZhdGUgX3JlcG9ydGVkID0gbmV3IFN1YmplY3Q8dm9pZD4oKTtcclxuICAgIHByaXZhdGUgX3NlbGVjdGVkID0gbmV3IFN1YmplY3Q8dm9pZD4oKTtcclxuXHJcbiAgICBAT3V0cHV0KClcclxuICAgIGdldCB1cHZvdGVkKCkgOiBPYnNlcnZhYmxlPHZvaWQ+IHtcclxuICAgICAgICByZXR1cm4gdGhpcy5fdXB2b3RlZDtcclxuICAgIH1cclxuICAgIFxyXG4gICAgQE91dHB1dCgpXHJcbiAgICBnZXQgcmVwb3J0ZWQoKSA6IE9ic2VydmFibGU8dm9pZD4ge1xyXG4gICAgICAgIHJldHVybiB0aGlzLl9yZXBvcnRlZDtcclxuICAgIH1cclxuXHJcbiAgICBAT3V0cHV0KClcclxuICAgIGdldCBzZWxlY3RlZCgpIDogT2JzZXJ2YWJsZTx2b2lkPiB7XHJcbiAgICAgICAgcmV0dXJuIHRoaXMuX3NlbGVjdGVkO1xyXG4gICAgfVxyXG4gICAgXHJcbiAgICBASW5wdXQoKVxyXG4gICAgZ2V0IG1lc3NhZ2UoKSA6IENoYXRNZXNzYWdlIHtcclxuICAgICAgICByZXR1cm4gdGhpcy5fbWVzc2FnZTtcclxuICAgIH1cclxuXHJcbiAgICBwcml2YXRlIHVuc3Vic2NyaWJlIDogRnVuY3Rpb247XHJcblxyXG4gICAgc2V0IG1lc3NhZ2UodmFsdWUpIHtcclxuICAgICAgICBsZXQgb3JpZ2luYWxJZCA9IG51bGw7XHJcbiAgICAgICAgaWYgKHRoaXMuX21lc3NhZ2UpXHJcbiAgICAgICAgICAgIG9yaWdpbmFsSWQgPSB0aGlzLl9tZXNzYWdlLmlkO1xyXG4gICAgICAgIFxyXG4gICAgICAgIHRoaXMuX21lc3NhZ2UgPSB2YWx1ZTtcclxuXHJcbiAgICAgICAgaWYgKHZhbHVlICYmIG9yaWdpbmFsSWQgPT09IHZhbHVlLmlkKSB7XHJcbiAgICAgICAgICAgIHJldHVybjtcclxuICAgICAgICB9XHJcblxyXG4gICAgICAgIGlmICh0aGlzLnVuc3Vic2NyaWJlKVxyXG4gICAgICAgICAgICB0aGlzLnVuc3Vic2NyaWJlKCk7XHJcbiAgICAgICAgXHJcbiAgICAgICAgaWYgKHZhbHVlKSB7XHJcbiAgICAgICAgICAgIHRoaXMudW5zdWJzY3JpYmUgPSB0aGlzLmJhY2tlbmQud2F0Y2hNZXNzYWdlKHZhbHVlLCBtZXNzYWdlID0+IHRoaXMubWVzc2FnZSA9IG1lc3NhZ2UpO1xyXG4gICAgICAgIH1cclxuICAgIH1cclxuXHJcbiAgICByZXBvcnQoKSB7XHJcbiAgICAgICAgdGhpcy5fcmVwb3J0ZWQubmV4dCgpO1xyXG4gICAgfVxyXG4gICAgXHJcbiAgICB1cHZvdGUoKSB7XHJcbiAgICAgICAgdGhpcy5fdXB2b3RlZC5uZXh0KCk7XHJcbiAgICB9XHJcblxyXG4gICAgc2VsZWN0KCkge1xyXG4gICAgICAgIHRoaXMuX3NlbGVjdGVkLm5leHQoKTtcclxuICAgIH1cclxufSJdfQ==

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

@@ -1,31 +1,31 @@
-import { BehaviorSubject } from 'rxjs';
-export class ChatBackendBase {
-    constructor() {
-        this._userChanged = new BehaviorSubject(null);
-        this._attachmentScrapers = [];
-        this._attachmentResolvers = [];
-    }
-    get userChanged() {
-        return this._userChanged;
-    }
-    set user(user) {
-        this._user = user;
-        this._userChanged.next(user);
-    }
-    get user() {
-        return this._user;
-    }
-    registerAttachmentScraper(scraper) {
-        this._attachmentScrapers.push(scraper);
-    }
-    registerAttachmentResolver(resolver) {
-        this._attachmentResolvers.push(resolver);
-    }
-    get attachmentScrapers() {
-        return this._attachmentScrapers.slice();
-    }
-    get attachmentResolvers() {
-        return this._attachmentResolvers.slice();
-    }
-}
+import { BehaviorSubject } from 'rxjs';
+export class ChatBackendBase {
+    constructor() {
+        this._userChanged = new BehaviorSubject(null);
+        this._attachmentScrapers = [];
+        this._attachmentResolvers = [];
+    }
+    get userChanged() {
+        return this._userChanged;
+    }
+    set user(user) {
+        this._user = user;
+        this._userChanged.next(user);
+    }
+    get user() {
+        return this._user;
+    }
+    registerAttachmentScraper(scraper) {
+        this._attachmentScrapers.push(scraper);
+    }
+    registerAttachmentResolver(resolver) {
+        this._attachmentResolvers.push(resolver);
+    }
+    get attachmentScrapers() {
+        return this._attachmentScrapers.slice();
+    }
+    get attachmentResolvers() {
+        return this._attachmentResolvers.slice();
+    }
+}
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/chat-backend.mjs

@@ -0,0 +1,163 @@
+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 topic
+     * @param topicId
+     * @returns
+     */
+    async getTopic(topicId) {
+        let response = await fetch(`${this.serviceUrl}/topics/${topicId}`);
+        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();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ChatBackend, deps: [{ token: BANTA_SDK_OPTIONS }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ChatBackend }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: ChatBackend, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ 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 topic\r\n     * @param topicId \r\n     * @returns \r\n     */\r\n    async getTopic(topicId: string): Promise<Topic> {\r\n        let response = await fetch(`${this.serviceUrl}/topics/${topicId}`)\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/{esm2020 → esm2022}/lib/chat-source-base.mjs

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