@banta/sdk 5.4.0 → 5.5.1

package/esm2022/lib/common/timer-pool.service.mjs

@@ -0,0 +1,85 @@
+import { __decorate } from "tslib";
+import { Injectable } from "@banta/common";
+/**
+ * Provides a way to hook in to a shared set of timers, instead of creating a timer per instance.
+ * This is very useful for cases where the update is not extremely time-sensitive, but happens at scale.
+ * The principal use case is the TimestampComponent. When several hundred (or several thousand) comments are
+ * being displayed, we do not want to trigger thousands of independent relative timestamp updates, because over
+ * time the updates will saturate the CPU since they don't perfectly align.
+ */
+let TimerPool = class TimerPool {
+    constructor() {
+        this.subscriptions = new Map();
+        this.newSubscriptions = new Map();
+        this.removedSubscriptions = new Map();
+    }
+    addTimer(interval, callback) {
+        if (interval <= 0) {
+            console.warn(`Refusing to set timer with interval of ${interval}!`);
+            return () => { };
+        }
+        let state;
+        let sizeWas = this.subscriptions.size;
+        if (!this.subscriptions.has(interval)) {
+            state = { subscribers: [] };
+            state.handle = setInterval(() => {
+                console.debug(`[Banta/TimerPool] Notifying ${state.subscribers.length} subs [${interval}ms]`);
+                state.subscribers.forEach(sub => sub());
+            }, interval);
+            this.subscriptions.set(interval, state);
+        }
+        else {
+            state = this.subscriptions.get(interval);
+        }
+        state.subscribers.push(callback);
+        // Debug information //////////////////////////
+        //
+        if (!this.newSubscriptions.has(interval))
+            this.newSubscriptions.set(interval, 0);
+        this.newSubscriptions.set(interval, (this.newSubscriptions.get(interval) ?? 0) + 1);
+        clearTimeout(this.newSubscriptionsNotice);
+        this.newSubscriptionsNotice = setTimeout(() => {
+            for (let [interval, count] of this.newSubscriptions) {
+                console.debug(`[Banta/TimerPool] ${count} new subscriptions to ${interval}ms [${state.subscribers.length} total]`);
+            }
+            this.newSubscriptions.clear();
+        });
+        //
+        ///////////////////////////////////////////////
+        if (sizeWas === 0) {
+            console.debug(`[Banta/TimerPool] No longer idle.`);
+        }
+        // Unsubscribe function 
+        return () => {
+            let state = this.subscriptions.get(interval);
+            if (!state)
+                return;
+            let index = state.subscribers.indexOf(callback);
+            if (index >= 0)
+                state.subscribers.splice(index, 1);
+            if (state.subscribers.length === 0) {
+                clearInterval(state.handle);
+                this.subscriptions.delete(interval);
+            }
+            if (!this.removedSubscriptions.has(interval))
+                this.removedSubscriptions.set(interval, 0);
+            this.removedSubscriptions.set(interval, (this.removedSubscriptions.get(interval) ?? 0) + 1);
+            // Debug information ////////////////////////////////////////////////////////////////////
+            clearTimeout(this.removedSubscriptionsNotice);
+            this.removedSubscriptionsNotice = setTimeout(() => {
+                for (let [interval, count] of this.removedSubscriptions) {
+                    let state = this.subscriptions.get(interval);
+                    console.debug(`[Banta/TimerPool] ${count} unsubscribed from ${interval}ms [${state?.subscribers?.length ?? 0} remain]`);
+                }
+                if (this.subscriptions.size === 0)
+                    console.debug(`[Banta/TimerPool] All subscriptions have been removed. Now idle.`);
+                this.removedSubscriptions.clear();
+            });
+        };
+    }
+};
+TimerPool = __decorate([
+    Injectable()
+], TimerPool);
+export { TimerPool };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timer-pool.service.js","sourceRoot":"","sources":["../../../../../projects/sdk/src/lib/common/timer-pool.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@banta/common\";\r\n\r\ninterface TimerState {\r\n    handle?;\r\n    subscribers: (() => void)[];\r\n}\r\n\r\n/**\r\n * Provides a way to hook in to a shared set of timers, instead of creating a timer per instance.\r\n * This is very useful for cases where the update is not extremely time-sensitive, but happens at scale.\r\n * The principal use case is the TimestampComponent. When several hundred (or several thousand) comments are \r\n * being displayed, we do not want to trigger thousands of independent relative timestamp updates, because over \r\n * time the updates will saturate the CPU since they don't perfectly align. \r\n */\r\n@Injectable()\r\nexport class TimerPool {\r\n    private subscriptions = new Map<number, TimerState>();\r\n\r\n    private newSubscriptionsNotice;\r\n    private newSubscriptions = new Map<number, number>();\r\n\r\n    private removedSubscriptionsNotice;\r\n    private removedSubscriptions = new Map<number, number>();\r\n\r\n    addTimer(interval: number, callback: () => void) {\r\n        if (interval <= 0) {\r\n            console.warn(`Refusing to set timer with interval of ${interval}!`);\r\n            return () => {};\r\n        }\r\n\r\n        let state: TimerState;\r\n        let sizeWas = this.subscriptions.size;\r\n\r\n        if (!this.subscriptions.has(interval)) {\r\n            state = { subscribers: [] };\r\n            state.handle = setInterval(() => {\r\n                console.debug(`[Banta/TimerPool] Notifying ${state.subscribers.length} subs [${interval}ms]`);\r\n                state.subscribers.forEach(sub => sub());\r\n            }, interval);\r\n            this.subscriptions.set(interval, state);\r\n        } else {\r\n            state = this.subscriptions.get(interval);\r\n        }\r\n\r\n        state.subscribers.push(callback);\r\n\r\n        // Debug information //////////////////////////\r\n        //\r\n\r\n        if (!this.newSubscriptions.has(interval))\r\n            this.newSubscriptions.set(interval, 0);\r\n        this.newSubscriptions.set(interval, (this.newSubscriptions.get(interval) ?? 0) + 1);\r\n\r\n        clearTimeout(this.newSubscriptionsNotice);\r\n        this.newSubscriptionsNotice = setTimeout(() => {\r\n            for (let [interval, count] of this.newSubscriptions) {\r\n                console.debug(`[Banta/TimerPool] ${count} new subscriptions to ${interval}ms [${state.subscribers.length} total]`);\r\n            }\r\n\r\n            this.newSubscriptions.clear();\r\n        });\r\n\r\n        //\r\n        ///////////////////////////////////////////////\r\n\r\n        if (sizeWas === 0) {\r\n            console.debug(`[Banta/TimerPool] No longer idle.`);\r\n        }\r\n\r\n        // Unsubscribe function \r\n\r\n        return () => {\r\n            let state = this.subscriptions.get(interval);\r\n            if (!state)\r\n                return;\r\n\r\n            let index = state.subscribers.indexOf(callback);\r\n            if (index >= 0)\r\n                state.subscribers.splice(index, 1);\r\n\r\n            if (state.subscribers.length === 0) {\r\n                clearInterval(state.handle);\r\n                this.subscriptions.delete(interval);\r\n            }\r\n\r\n            if (!this.removedSubscriptions.has(interval))\r\n                this.removedSubscriptions.set(interval, 0);\r\n            this.removedSubscriptions.set(interval, (this.removedSubscriptions.get(interval) ?? 0) + 1);\r\n\r\n            // Debug information ////////////////////////////////////////////////////////////////////\r\n\r\n            clearTimeout(this.removedSubscriptionsNotice);\r\n            this.removedSubscriptionsNotice = setTimeout(() => {\r\n                for (let [interval, count] of this.removedSubscriptions) {\r\n                    let state = this.subscriptions.get(interval);\r\n                    console.debug(`[Banta/TimerPool] ${count} unsubscribed from ${interval}ms [${state?.subscribers?.length ?? 0} remain]`);\r\n                }\r\n\r\n                if (this.subscriptions.size === 0)\r\n                    console.debug(`[Banta/TimerPool] All subscriptions have been removed. Now idle.`);\r\n\r\n                this.removedSubscriptions.clear();\r\n            });\r\n        };\r\n    }\r\n}"]}

package/esm2022/lib/common/timestamp.component.mjs

@@ -0,0 +1,124 @@
+import { Component, Input } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "../../lib/common/timer-pool.service";
+import * as i2 from "@angular/common";
+export class TimestampComponent {
+    constructor(timerPool) {
+        this.timerPool = timerPool;
+        this.relative = '';
+        this.tooltip = '';
+        this.timerInterval = 0;
+        this._destroyed = false;
+        this.showAbsolute = false;
+    }
+    ngOnDestroy() {
+        this._destroyed = true;
+        this.timerUnsubscribe?.();
+        this.timerUnsubscribe = undefined;
+    }
+    get value() {
+        return this._value;
+    }
+    update() {
+        if (this._destroyed)
+            return;
+        let now = Date.now();
+        let diff = now - this.value;
+        let minute = 1000 * 60;
+        let hour = minute * 60;
+        let day = hour * 24;
+        let week = day * 7;
+        let month = day * 30;
+        let year = day * 365;
+        this.showAbsolute = false;
+        let updateTime = 0;
+        if (diff > year) {
+            this.showAbsolute = true;
+            this.relative = 'abs';
+            return;
+        }
+        if (diff > month) {
+            let months = Math.floor(diff / month);
+            if (months === 1)
+                this.relative = `${months} month ago`;
+            else
+                this.relative = `${months} months ago`;
+        }
+        else if (diff > week) {
+            let weeks = Math.floor(diff / week);
+            if (weeks === 1)
+                this.relative = `${weeks} week ago`;
+            else
+                this.relative = `${weeks} weeks ago`;
+        }
+        else if (diff > day) {
+            let days = Math.floor(diff / day);
+            if (days === 1)
+                this.relative = `${days} day ago`;
+            else
+                this.relative = `${days} days ago`;
+        }
+        else if (diff > hour) {
+            let hours = Math.floor(diff / hour);
+            if (hours === 1)
+                this.relative = `${hours} hour ago`;
+            else
+                this.relative = `${hours} hours ago`;
+            updateTime = 1000 * 60 * 30;
+        }
+        else if (diff > minute) {
+            let minutes = Math.floor(diff / minute);
+            if (minutes === 1)
+                this.relative = `${minutes} minute ago`;
+            else
+                this.relative = `${minutes} minutes ago`;
+            updateTime = 1000 * 45;
+        }
+        else if (diff > 30_000) {
+            this.relative = `about a minute ago`;
+            updateTime = 1000 * 60;
+        }
+        else {
+            this.relative = `just now`;
+            updateTime = 1000 * 30;
+        }
+        if (typeof window !== 'undefined') {
+            if (this.timerInterval !== updateTime) {
+                this.timerInterval = updateTime;
+                this.timerUnsubscribe?.();
+                if (updateTime > 0) {
+                    this.timerUnsubscribe = this.timerPool.addTimer(updateTime, () => this.update());
+                }
+            }
+        }
+    }
+    set value(v) {
+        if (this._value !== v) {
+            this._value = v;
+            this.update();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: TimestampComponent, deps: [{ token: i1.TimerPool }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: TimestampComponent, selector: "banta-timestamp", inputs: { value: "value" }, ngImport: i0, template: `
+        <span *ngIf="showAbsolute" [title]="value | date : 'short'">
+            {{value | date : 'shortDate'}}
+        </span>
+        <span *ngIf="!showAbsolute" [title]="value | date : 'short'">
+            {{relative}}
+        </span>
+    `, isInline: true, styles: [""], dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i2.DatePipe, name: "date" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: TimestampComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'banta-timestamp', template: `
+        <span *ngIf="showAbsolute" [title]="value | date : 'short'">
+            {{value | date : 'shortDate'}}
+        </span>
+        <span *ngIf="!showAbsolute" [title]="value | date : 'short'">
+            {{relative}}
+        </span>
+    ` }]
+        }], ctorParameters: () => [{ type: i1.TimerPool }], propDecorators: { value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timestamp.component.js","sourceRoot":"","sources":["../../../../../projects/sdk/src/lib/common/timestamp.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input } from \"@angular/core\";\r\nimport { TimerPool } from \"../../lib/common/timer-pool.service\";\r\n\r\n@Component({\r\n    selector: 'banta-timestamp',\r\n    template: `\r\n        <span *ngIf=\"showAbsolute\" [title]=\"value | date : 'short'\">\r\n            {{value | date : 'shortDate'}}\r\n        </span>\r\n        <span *ngIf=\"!showAbsolute\" [title]=\"value | date : 'short'\">\r\n            {{relative}}\r\n        </span>\r\n    `,\r\n    styles: [``]\r\n})\r\nexport class TimestampComponent {\r\n    constructor(\r\n        private timerPool: TimerPool\r\n    ) {\r\n    }\r\n\r\n    private _value : number;\r\n    relative = '';\r\n    tooltip = '';\r\n\r\n    private timerUnsubscribe: () => void;\r\n    private timerInterval: number = 0;\r\n\r\n    private _destroyed = false;\r\n\r\n    ngOnDestroy() {\r\n        this._destroyed = true;\r\n        this.timerUnsubscribe?.();\r\n        this.timerUnsubscribe = undefined;\r\n    }\r\n\r\n    @Input()\r\n    get value() {\r\n        return this._value;\r\n    }\r\n\r\n    showAbsolute = false;\r\n\r\n    update() {\r\n        if (this._destroyed)\r\n            return;\r\n        \r\n        let now = Date.now();\r\n        let diff = now - this.value;\r\n        let minute = 1000*60;\r\n        let hour = minute * 60;\r\n        let day = hour * 24;\r\n        let week = day * 7;\r\n        let month = day * 30;\r\n        let year = day * 365;\r\n        this.showAbsolute = false;\r\n        let updateTime = 0;\r\n\r\n        if (diff > year) {\r\n            this.showAbsolute = true;\r\n            this.relative = 'abs';\r\n            return;\r\n        }\r\n\r\n        if (diff > month) {\r\n            let months = Math.floor(diff / month);\r\n\r\n            if (months === 1)\r\n                this.relative = `${months} month ago`;\r\n            else\r\n                this.relative = `${months} months ago`;\r\n            \r\n        } else if (diff > week) {\r\n            let weeks = Math.floor(diff / week);\r\n\r\n            if (weeks === 1)\r\n                this.relative = `${weeks} week ago`;\r\n            else\r\n                this.relative = `${weeks} weeks ago`;\r\n        } else if (diff > day) {\r\n            let days = Math.floor(diff / day);\r\n            if (days === 1)\r\n                this.relative = `${days} day ago`;\r\n            else\r\n                this.relative = `${days} days ago`;\r\n        } else if (diff > hour) {\r\n            let hours = Math.floor(diff / hour);\r\n            if (hours === 1)\r\n                this.relative = `${hours} hour ago`;\r\n            else\r\n                this.relative = `${hours} hours ago`;\r\n            \r\n            updateTime = 1000 * 60 * 30;\r\n        } else if (diff > minute) {\r\n            let minutes = Math.floor(diff / minute);\r\n            if (minutes === 1)\r\n                this.relative = `${minutes} minute ago`;\r\n            else\r\n                this.relative = `${minutes} minutes ago`;\r\n            updateTime = 1000 * 45;\r\n        } else if (diff > 30_000) {\r\n            this.relative = `about a minute ago`;\r\n            updateTime = 1000 * 60;\r\n        } else {\r\n            this.relative = `just now`;\r\n            updateTime = 1000 * 30;\r\n        }\r\n        \r\n        if (typeof window !== 'undefined') {\r\n            if (this.timerInterval !== updateTime) {\r\n                this.timerInterval = updateTime;\r\n                this.timerUnsubscribe?.();\r\n                if (updateTime > 0) {\r\n                    this.timerUnsubscribe = this.timerPool.addTimer(updateTime, () => this.update());\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    set value(v) {\r\n        if (this._value !== v) {\r\n            this._value = v;\r\n            this.update();\r\n        }\r\n    }\r\n}"]}

package/{esm2020 → esm2022}/lib/common/trust-resource-url.pipe.mjs

@@ -1,22 +1,22 @@
-import { Pipe } from '@angular/core';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/platform-browser";
-export class BantaTrustResourceUrlPipe {
-    constructor(sanitizer) {
-        this.sanitizer = sanitizer;
-    }
-    transform(value) {
-        if (!value)
-            return undefined;
-        return this.sanitizer.bypassSecurityTrustResourceUrl(value);
-    }
-}
-BantaTrustResourceUrlPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: BantaTrustResourceUrlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
-BantaTrustResourceUrlPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: BantaTrustResourceUrlPipe, name: "trustResourceUrl" });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: BantaTrustResourceUrlPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'trustResourceUrl'
-                }]
-        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJ1c3QtcmVzb3VyY2UtdXJsLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zZGsvc3JjL2xpYi9jb21tb24vdHJ1c3QtcmVzb3VyY2UtdXJsLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7OztBQU1wRCxNQUFNLE9BQU8seUJBQXlCO0lBQ2xDLFlBQ1ksU0FBdUI7UUFBdkIsY0FBUyxHQUFULFNBQVMsQ0FBYztJQUVuQyxDQUFDO0lBRUQsU0FBUyxDQUFDLEtBQWE7UUFDbkIsSUFBSSxDQUFDLEtBQUs7WUFDTixPQUFPLFNBQVMsQ0FBQztRQUVyQixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsOEJBQThCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDaEUsQ0FBQzs7dUhBWFEseUJBQXlCO3FIQUF6Qix5QkFBeUI7NEZBQXpCLHlCQUF5QjtrQkFIckMsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsa0JBQWtCO2lCQUMzQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgRG9tU2FuaXRpemVyIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XHJcblxyXG5AUGlwZSh7XHJcbiAgICBuYW1lOiAndHJ1c3RSZXNvdXJjZVVybCdcclxufSlcclxuZXhwb3J0IGNsYXNzIEJhbnRhVHJ1c3RSZXNvdXJjZVVybFBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcclxuICAgIGNvbnN0cnVjdG9yKFxyXG4gICAgICAgIHByaXZhdGUgc2FuaXRpemVyOiBEb21TYW5pdGl6ZXJcclxuICAgICkge1xyXG4gICAgfVxyXG5cclxuICAgIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nKSB7XHJcbiAgICAgICAgaWYgKCF2YWx1ZSlcclxuICAgICAgICAgICAgcmV0dXJuIHVuZGVmaW5lZDtcclxuXHJcbiAgICAgICAgcmV0dXJuIHRoaXMuc2FuaXRpemVyLmJ5cGFzc1NlY3VyaXR5VHJ1c3RSZXNvdXJjZVVybCh2YWx1ZSk7XHJcbiAgICB9XHJcbn0iXX0=
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+export class BantaTrustResourceUrlPipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(value) {
+        if (!value)
+            return undefined;
+        return this.sanitizer.bypassSecurityTrustResourceUrl(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: BantaTrustResourceUrlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.9", ngImport: i0, type: BantaTrustResourceUrlPipe, name: "trustResourceUrl" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: BantaTrustResourceUrlPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'trustResourceUrl'
+                }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJ1c3QtcmVzb3VyY2UtdXJsLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zZGsvc3JjL2xpYi9jb21tb24vdHJ1c3QtcmVzb3VyY2UtdXJsLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7OztBQU1wRCxNQUFNLE9BQU8seUJBQXlCO0lBQ2xDLFlBQ1ksU0FBdUI7UUFBdkIsY0FBUyxHQUFULFNBQVMsQ0FBYztJQUVuQyxDQUFDO0lBRUQsU0FBUyxDQUFDLEtBQWE7UUFDbkIsSUFBSSxDQUFDLEtBQUs7WUFDTixPQUFPLFNBQVMsQ0FBQztRQUVyQixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsOEJBQThCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDaEUsQ0FBQzs4R0FYUSx5QkFBeUI7NEdBQXpCLHlCQUF5Qjs7MkZBQXpCLHlCQUF5QjtrQkFIckMsSUFBSTttQkFBQztvQkFDRixJQUFJLEVBQUUsa0JBQWtCO2lCQUMzQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgRG9tU2FuaXRpemVyIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XHJcblxyXG5AUGlwZSh7XHJcbiAgICBuYW1lOiAndHJ1c3RSZXNvdXJjZVVybCdcclxufSlcclxuZXhwb3J0IGNsYXNzIEJhbnRhVHJ1c3RSZXNvdXJjZVVybFBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcclxuICAgIGNvbnN0cnVjdG9yKFxyXG4gICAgICAgIHByaXZhdGUgc2FuaXRpemVyOiBEb21TYW5pdGl6ZXJcclxuICAgICkge1xyXG4gICAgfVxyXG5cclxuICAgIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nKSB7XHJcbiAgICAgICAgaWYgKCF2YWx1ZSlcclxuICAgICAgICAgICAgcmV0dXJuIHVuZGVmaW5lZDtcclxuXHJcbiAgICAgICAgcmV0dXJuIHRoaXMuc2FuaXRpemVyLmJ5cGFzc1NlY3VyaXR5VHJ1c3RSZXNvdXJjZVVybCh2YWx1ZSk7XHJcbiAgICB9XHJcbn0iXX0=

package/esm2022/lib/emoji/emoji-selector-button.component.mjs

@@ -0,0 +1,115 @@
+import { Component, Output, ViewChild, Input } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/material/icon";
+import * as i3 from "@angular/material/button";
+import * as i4 from "@angular/cdk/portal";
+import * as i5 from "./emoji-selector-panel/emoji-selector-panel.component";
+export class EmojiSelectorButtonComponent {
+    constructor(elementRef, overlay) {
+        this.elementRef = elementRef;
+        this.overlay = overlay;
+        this._selected = new Subject();
+        this.showEmojiPanel = false;
+        this.disabled = false;
+        this.overlayX = 'end';
+        this.overlayY = 'top';
+        this.originX = 'end';
+        this.originY = 'bottom';
+    }
+    get selected() {
+        return this._selected;
+    }
+    get isOpen() {
+        return this.overlayRef;
+    }
+    /**
+     * Insert the given emoji.
+     * @param str
+     */
+    insert(str) {
+        this._selected.next(str);
+        this.close();
+    }
+    close() {
+        if (this.overlayRef) {
+            this.overlayRef.dispose();
+            this.overlayRef = null;
+        }
+    }
+    show() {
+        if (this.isOpen) {
+            this.close();
+        }
+        this.overlayRef = this.overlay.create({
+            positionStrategy: this.overlay.position()
+                .flexibleConnectedTo(this.elementRef)
+                .withPositions([
+                {
+                    originX: this.originX,
+                    originY: this.originY,
+                    overlayX: this.overlayX,
+                    overlayY: this.overlayY
+                }
+            ])
+                .withFlexibleDimensions(true),
+            hasBackdrop: true,
+            disposeOnNavigation: true,
+            scrollStrategy: this.overlay.scrollStrategies.reposition({
+                autoClose: true
+            })
+        });
+        this.overlayRef.backdropClick().subscribe(() => {
+            this.close();
+        });
+        this.overlayRef.keydownEvents().subscribe(event => {
+            if (event.key === 'Escape') {
+                this.close();
+            }
+        });
+        this.overlayRef.attach(this.selectorPanelTemplate);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: EmojiSelectorButtonComponent, deps: [{ token: i0.ElementRef }, { token: i1.Overlay }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: EmojiSelectorButtonComponent, selector: "emoji-selector-button", inputs: { disabled: "disabled", overlayX: "overlayX", overlayY: "overlayY", originX: "originX", originY: "originY" }, outputs: { selected: "selected" }, viewQueries: [{ propertyName: "selectorPanelTemplate", first: true, predicate: ["selectorPanelTemplate"], descendants: true }], ngImport: i0, template: `
+        <button #button type="button" mat-icon-button (click)="show()" [disabled]="disabled">
+            <mat-icon>emoji_emotions</mat-icon>
+        </button>
+        <ng-template cdkPortal #selectorPanelTemplate="cdkPortal">
+            <emoji-selector-panel 
+                #panel
+                (selected)="insert($event)"
+                ></emoji-selector-panel>
+        </ng-template>
+    `, isInline: true, styles: [":host{display:block;position:relative}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.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "directive", type: i4.CdkPortal, selector: "[cdkPortal]", exportAs: ["cdkPortal"] }, { kind: "component", type: i5.EmojiSelectorPanelComponent, selector: "emoji-selector-panel", outputs: ["selected"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: EmojiSelectorButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'emoji-selector-button', template: `
+        <button #button type="button" mat-icon-button (click)="show()" [disabled]="disabled">
+            <mat-icon>emoji_emotions</mat-icon>
+        </button>
+        <ng-template cdkPortal #selectorPanelTemplate="cdkPortal">
+            <emoji-selector-panel 
+                #panel
+                (selected)="insert($event)"
+                ></emoji-selector-panel>
+        </ng-template>
+    `, styles: [":host{display:block;position:relative}button{color:#666}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.Overlay }], propDecorators: { selectorPanelTemplate: [{
+                type: ViewChild,
+                args: ['selectorPanelTemplate']
+            }], selected: [{
+                type: Output
+            }], disabled: [{
+                type: Input
+            }], overlayX: [{
+                type: Input
+            }], overlayY: [{
+                type: Input
+            }], originX: [{
+                type: Input
+            }], originY: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/emoji/emoji-selector-panel/emoji-selector-panel.component.mjs

@@ -0,0 +1,98 @@
+import { Component, Inject, Optional, Output } from '@angular/core';
+import { BANTA_SDK_OPTIONS } from '../../sdk-options';
+import { Subject } from 'rxjs';
+import { EMOJIS } from '../emojis';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/button";
+import * as i6 from "@angular/material/form-field";
+import * as i7 from "@angular/material/input";
+export class EmojiSelectorPanelComponent {
+    constructor(sanitizer, sdkOptions) {
+        this.sanitizer = sanitizer;
+        this.sdkOptions = sdkOptions;
+        this.activeCategory = 'people';
+        this.searchResults = [];
+        this.searchVisible = false;
+        this.selected = new Subject();
+    }
+    get searchQuery() {
+        return this._searchQuery;
+    }
+    set searchQuery(value) {
+        this._searchQuery = value;
+        setTimeout(() => {
+            this.searchResults = Object.keys(EMOJIS).filter(k => k.includes(value)).map(k => EMOJIS[k]);
+            this.searchResults.splice(50, this.searchResults.length);
+            console.log(`looking for '${value}' => ${this.searchResults.length} results`);
+        });
+    }
+    humanize(str) {
+        return str.replace(/(^| )[a-z]/g, k => k.toUpperCase()).replace(/_/g, ' ');
+    }
+    select(char) {
+        this.selected.next(char);
+    }
+    pairs(object) {
+        return Object.keys(object).map(key => [key, object[key]]);
+    }
+    hideSearch() {
+        // because of the "outside click detection"
+        setTimeout(() => {
+            this.searchVisible = false;
+        });
+    }
+    showSearch() {
+        // because of the "outside click detection"
+        setTimeout(() => {
+            this.searchVisible = true;
+        });
+    }
+    get emojiUrl() {
+        return this.sdkOptions?.emojiUrl ?? 'https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/';
+    }
+    ngOnInit() {
+        let cats = {};
+        let categoryIcons = {
+            symbols: 'warning',
+            people: 'people',
+            animals_and_nature: 'nature',
+            travel_and_places: 'location_on',
+            activity: 'local_activity',
+            food_and_drink: 'restaurant',
+            objects: 'computer',
+            flags: 'flag'
+        };
+        for (let pair of this.pairs(EMOJIS)) {
+            let name = pair[0];
+            let emoji = pair[1];
+            if (!cats[emoji.category]) {
+                cats[emoji.category] = {
+                    name: emoji.category,
+                    icon: categoryIcons[emoji.category] || 'code',
+                    emojis: []
+                };
+            }
+            emoji.html = this.sanitizer.bypassSecurityTrustHtml(twemoji.parse(emoji.char || '', { base: this.emojiUrl }));
+            cats[emoji.category].emojis.push(emoji);
+        }
+        this.categories = this.pairs(cats).map(pair => pair[1]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: EmojiSelectorPanelComponent, deps: [{ token: i1.DomSanitizer }, { token: BANTA_SDK_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.9", type: EmojiSelectorPanelComponent, selector: "emoji-selector-panel", outputs: { selected: "selected" }, ngImport: i0, template: "<div class=\"search-box\" *ngIf=\"searchVisible\">\r\n\t<a mat-icon-button href=\"javascript:;\" (click)=\"hideSearch()\">\r\n\t\t<mat-icon>arrow_back</mat-icon>\r\n\t</a>\r\n\t<mat-form-field appearance=\"outline\" floatLabel=\"always\">\r\n\t\t<mat-label>Search for emoji</mat-label>\r\n\t\t<input name=\"search\" type=\"text\" matInput placeholder=\"Start typing\" [(ngModel)]=\"searchQuery\" />\r\n\t</mat-form-field>\r\n</div>\r\n\r\n<div class=\"selector\">\r\n\t<ng-container *ngIf=\"searchVisible\">\r\n\t\t<div class=\"emoji-list\">\r\n\t\t\t<a href=\"javascript:;\" (click)=\"select(emoji.char)\" \r\n\t\t\t\t*ngFor=\"let emoji of searchResults\" [innerHtml]=\"emoji.html || ''\">\r\n\t\t\t</a>\r\n\t\t</div>\r\n\t</ng-container>\r\n\t<ng-container *ngIf=\"!searchVisible\">\r\n\t\t<div class=\"categories\">\r\n\t\t\t<ng-container *ngIf=\"!searchVisible\">\r\n\t\t\t\t<a [title]=\"humanize(category.name)\" [class.active]=\"activeCategory === category.name\" mat-icon-button *ngFor=\"let category of categories\" (click)=\"activeCategory = category.name\">\r\n\t\t\t\t\t<mat-icon>{{category.icon}}</mat-icon>\r\n\t\t\t\t</a>\r\n\r\n\t\t\t\t<a title=\"Search\" [class.active] mat-icon-button (click)=\"showSearch()\">\r\n\t\t\t\t\t<mat-icon>search</mat-icon>\r\n\t\t\t\t</a>\r\n\t\t\t</ng-container>\r\n\t\t</div>\r\n\t\t<ng-container *ngFor=\"let category of categories\">\r\n\t\t\t<div class=\"emoji-list\" *ngIf=\"activeCategory && activeCategory == category.name\">\r\n\t\t\t\t<a href=\"javascript:;\" (click)=\"select(emoji.char)\" \r\n\t\t\t\t\t*ngFor=\"let emoji of category.emojis\" [innerHtml]=\"emoji.html || ''\">\r\n\t\t\t\t</a>\r\n\t\t\t</div>\r\n\t\t</ng-container>\r\n\t</ng-container>\r\n</div>", styles: [":host{background:#111;color:#fff;border:1px solid #333;border-radius:5px;padding:.5em;width:calc(9*(32px + 1em));max-width:calc(100vw - 1.5em - 5px)}.selector{display:flex;flex-direction:column}.categories a{opacity:.25;transition:.4s opacity ease-in-out}.categories a:hover{opacity:.5}.categories a.active{opacity:1}.emoji-list{flex-grow:1;overflow-y:auto;height:20em}.emoji-list a{display:inline-block;padding:2px;margin:4px;background-color:#111}.emoji-list a ::ng-deep .emoji{width:32px;height:32px}.emoji-list a:hover{background-color:#333}.search-box{display:flex;align-items:baseline}.search-box mat-form-field{flex-grow:1}@media (max-width: 500px){.selector{flex-direction:row;height:27em}.emoji-list{height:auto}}:host-context(.banta-mobile) .selector{flex-direction:row;height:27em}:host-context(.banta-mobile) .emoji-list{height:auto}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "component", type: i5.MatIconAnchor, selector: "a[mat-icon-button]", exportAs: ["matButton", "matAnchor"] }, { kind: "component", type: i6.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i6.MatLabel, selector: "mat-label" }, { kind: "directive", type: i7.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: EmojiSelectorPanelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'emoji-selector-panel', template: "<div class=\"search-box\" *ngIf=\"searchVisible\">\r\n\t<a mat-icon-button href=\"javascript:;\" (click)=\"hideSearch()\">\r\n\t\t<mat-icon>arrow_back</mat-icon>\r\n\t</a>\r\n\t<mat-form-field appearance=\"outline\" floatLabel=\"always\">\r\n\t\t<mat-label>Search for emoji</mat-label>\r\n\t\t<input name=\"search\" type=\"text\" matInput placeholder=\"Start typing\" [(ngModel)]=\"searchQuery\" />\r\n\t</mat-form-field>\r\n</div>\r\n\r\n<div class=\"selector\">\r\n\t<ng-container *ngIf=\"searchVisible\">\r\n\t\t<div class=\"emoji-list\">\r\n\t\t\t<a href=\"javascript:;\" (click)=\"select(emoji.char)\" \r\n\t\t\t\t*ngFor=\"let emoji of searchResults\" [innerHtml]=\"emoji.html || ''\">\r\n\t\t\t</a>\r\n\t\t</div>\r\n\t</ng-container>\r\n\t<ng-container *ngIf=\"!searchVisible\">\r\n\t\t<div class=\"categories\">\r\n\t\t\t<ng-container *ngIf=\"!searchVisible\">\r\n\t\t\t\t<a [title]=\"humanize(category.name)\" [class.active]=\"activeCategory === category.name\" mat-icon-button *ngFor=\"let category of categories\" (click)=\"activeCategory = category.name\">\r\n\t\t\t\t\t<mat-icon>{{category.icon}}</mat-icon>\r\n\t\t\t\t</a>\r\n\r\n\t\t\t\t<a title=\"Search\" [class.active] mat-icon-button (click)=\"showSearch()\">\r\n\t\t\t\t\t<mat-icon>search</mat-icon>\r\n\t\t\t\t</a>\r\n\t\t\t</ng-container>\r\n\t\t</div>\r\n\t\t<ng-container *ngFor=\"let category of categories\">\r\n\t\t\t<div class=\"emoji-list\" *ngIf=\"activeCategory && activeCategory == category.name\">\r\n\t\t\t\t<a href=\"javascript:;\" (click)=\"select(emoji.char)\" \r\n\t\t\t\t\t*ngFor=\"let emoji of category.emojis\" [innerHtml]=\"emoji.html || ''\">\r\n\t\t\t\t</a>\r\n\t\t\t</div>\r\n\t\t</ng-container>\r\n\t</ng-container>\r\n</div>", styles: [":host{background:#111;color:#fff;border:1px solid #333;border-radius:5px;padding:.5em;width:calc(9*(32px + 1em));max-width:calc(100vw - 1.5em - 5px)}.selector{display:flex;flex-direction:column}.categories a{opacity:.25;transition:.4s opacity ease-in-out}.categories a:hover{opacity:.5}.categories a.active{opacity:1}.emoji-list{flex-grow:1;overflow-y:auto;height:20em}.emoji-list a{display:inline-block;padding:2px;margin:4px;background-color:#111}.emoji-list a ::ng-deep .emoji{width:32px;height:32px}.emoji-list a:hover{background-color:#333}.search-box{display:flex;align-items:baseline}.search-box mat-form-field{flex-grow:1}@media (max-width: 500px){.selector{flex-direction:row;height:27em}.emoji-list{height:auto}}:host-context(.banta-mobile) .selector{flex-direction:row;height:27em}:host-context(.banta-mobile) .emoji-list{height:auto}\n"] }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BANTA_SDK_OPTIONS]
+                }, {
+                    type: Optional
+                }] }], propDecorators: { selected: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emoji-selector-panel.component.js","sourceRoot":"","sources":["../../../../../../projects/sdk/src/lib/emoji/emoji-selector-panel/emoji-selector-panel.component.ts","../../../../../../projects/sdk/src/lib/emoji/emoji-selector-panel/emoji-selector-panel.component.html"],"names":[],"mappings":"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","sourcesContent":["declare var twemoji: {\r\n    parse(str: string, options?: { folder?: string, ext?: string, base?: string }): string;\r\n}\r\n\r\nimport { Component, Inject, Input, OnInit, Optional, Output } from '@angular/core';\r\nimport { DomSanitizer, SafeHtml } from '@angular/platform-browser';\r\nimport { BANTA_SDK_OPTIONS, SdkOptions } from '../../sdk-options';\r\nimport { Subject } from 'rxjs';\r\n\r\ninterface Emoji {\r\n\tkeywords : string[];\r\n\tchar : string;\r\n\thtml? : SafeHtml;\r\n\tcategory : string;\r\n}\r\n\r\nimport { EMOJIS } from '../emojis';\r\n\r\n@Component({\r\n\tselector: 'emoji-selector-panel',\r\n\ttemplateUrl: './emoji-selector-panel.component.html',\r\n\tstyleUrls: ['./emoji-selector-panel.component.scss']\r\n})\r\nexport class EmojiSelectorPanelComponent implements OnInit {\r\n\r\n\tconstructor(\r\n\t\tprivate sanitizer : DomSanitizer,\r\n\t\t@Inject(BANTA_SDK_OPTIONS) @Optional()\r\n\t\tprivate sdkOptions: SdkOptions\r\n\t) { }\r\n\r\n\tcategories : any[];\r\n\tactiveCategory : string = 'people';\r\n\tsearchResults : any[] = [];\r\n    searchVisible = false;\r\n\t\r\n\t@Output()\r\n\tprivate selected : Subject<string> = new Subject();\r\n\r\n\tprivate _searchQuery : string;\r\n\r\n\tget searchQuery() {\r\n\t\treturn this._searchQuery;\r\n\t}\r\n\r\n\tset searchQuery(value) {\r\n\t\tthis._searchQuery = value;\r\n\t\tsetTimeout(() => {\r\n\t\t\tthis.searchResults = Object.keys(EMOJIS).filter(k => k.includes(value)).map(k => EMOJIS[k]);\r\n\t\t\tthis.searchResults.splice(50, this.searchResults.length);\r\n\t\t\tconsole.log(`looking for '${value}' => ${this.searchResults.length} results`);\r\n\t\t});\r\n\t}\r\n\r\n\thumanize(str : string) {\r\n\t\treturn str.replace(/(^| )[a-z]/g, k => k.toUpperCase()).replace(/_/g, ' ');\r\n\t}\r\n\r\n\tselect(char : string) {\r\n\t\tthis.selected.next(char);\r\n\t}\r\n\r\n\tpairs(object) {\r\n\t\treturn Object.keys(object).map(key => [key, object[key]]);\r\n\t}\r\n\r\n\thideSearch() {\r\n\t\t// because of the \"outside click detection\"\r\n        setTimeout(() => {\r\n            this.searchVisible = false;\r\n        });\r\n\t}\r\n\t\r\n    showSearch() {\r\n\t\t// because of the \"outside click detection\"\r\n        setTimeout(() => {\r\n            this.searchVisible = true;\r\n        });\r\n    }\r\n\r\n\tprivate get emojiUrl() {\r\n\t\treturn this.sdkOptions?.emojiUrl ?? 'https://cdn.jsdelivr.net/gh/twitter/twemoji@14.0.2/assets/';\r\n\t}\r\n\r\n\tngOnInit() {\r\n\r\n\t\tlet cats = {};\r\n\t\tlet categoryIcons = {\r\n\t\t\tsymbols: 'warning',\r\n\t\t\tpeople: 'people',\r\n\t\t\tanimals_and_nature: 'nature',\r\n\t\t\ttravel_and_places: 'location_on',\r\n\t\t\tactivity: 'local_activity',\r\n\t\t\tfood_and_drink: 'restaurant',\r\n\t\t\tobjects: 'computer',\r\n\t\t\tflags: 'flag'\r\n\t\t};\r\n\t\tfor (let pair of this.pairs(EMOJIS)) {\r\n\t\t\tlet name = pair[0];\r\n\t\t\tlet emoji : Emoji = pair[1];\r\n\r\n\t\t\tif (!cats[emoji.category]) {\r\n\t\t\t\tcats[emoji.category] = {\r\n\t\t\t\t\tname: emoji.category,\r\n\t\t\t\t\ticon: categoryIcons[emoji.category] || 'code',\r\n\t\t\t\t\temojis: []\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\temoji.html = this.sanitizer.bypassSecurityTrustHtml(\r\n\t\t\t\ttwemoji.parse(emoji.char || '', { base: this.emojiUrl })\r\n\t\t\t);\r\n\r\n\t\t\tcats[emoji.category].emojis.push(emoji);\r\n\t\t}\r\n\r\n\t\tthis.categories = this.pairs(cats).map(pair => pair[1]);\r\n\t}\r\n\r\n}\r\n","<div class=\"search-box\" *ngIf=\"searchVisible\">\r\n\t<a mat-icon-button href=\"javascript:;\" (click)=\"hideSearch()\">\r\n\t\t<mat-icon>arrow_back</mat-icon>\r\n\t</a>\r\n\t<mat-form-field appearance=\"outline\" floatLabel=\"always\">\r\n\t\t<mat-label>Search for emoji</mat-label>\r\n\t\t<input name=\"search\" type=\"text\" matInput placeholder=\"Start typing\" [(ngModel)]=\"searchQuery\" />\r\n\t</mat-form-field>\r\n</div>\r\n\r\n<div class=\"selector\">\r\n\t<ng-container *ngIf=\"searchVisible\">\r\n\t\t<div class=\"emoji-list\">\r\n\t\t\t<a href=\"javascript:;\" (click)=\"select(emoji.char)\" \r\n\t\t\t\t*ngFor=\"let emoji of searchResults\" [innerHtml]=\"emoji.html || ''\">\r\n\t\t\t</a>\r\n\t\t</div>\r\n\t</ng-container>\r\n\t<ng-container *ngIf=\"!searchVisible\">\r\n\t\t<div class=\"categories\">\r\n\t\t\t<ng-container *ngIf=\"!searchVisible\">\r\n\t\t\t\t<a [title]=\"humanize(category.name)\" [class.active]=\"activeCategory === category.name\" mat-icon-button *ngFor=\"let category of categories\" (click)=\"activeCategory = category.name\">\r\n\t\t\t\t\t<mat-icon>{{category.icon}}</mat-icon>\r\n\t\t\t\t</a>\r\n\r\n\t\t\t\t<a title=\"Search\" [class.active] mat-icon-button (click)=\"showSearch()\">\r\n\t\t\t\t\t<mat-icon>search</mat-icon>\r\n\t\t\t\t</a>\r\n\t\t\t</ng-container>\r\n\t\t</div>\r\n\t\t<ng-container *ngFor=\"let category of categories\">\r\n\t\t\t<div class=\"emoji-list\" *ngIf=\"activeCategory && activeCategory == category.name\">\r\n\t\t\t\t<a href=\"javascript:;\" (click)=\"select(emoji.char)\" \r\n\t\t\t\t\t*ngFor=\"let emoji of category.emojis\" [innerHtml]=\"emoji.html || ''\">\r\n\t\t\t\t</a>\r\n\t\t\t</div>\r\n\t\t</ng-container>\r\n\t</ng-container>\r\n</div>"]}