@ctrl/ngx-emoji-mart 8.2.0 → 9.1.0

package/esm2022/emoji-search.service.mjs

@@ -0,0 +1,178 @@
+import { Injectable } from '@angular/core';
+import { categories } from '@ctrl/ngx-emoji-mart/ngx-emoji';
+import { intersect } from './utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@ctrl/ngx-emoji-mart/ngx-emoji";
+class EmojiSearch {
+    emojiService;
+    originalPool = {};
+    index = {};
+    emojisList = {};
+    emoticonsList = {};
+    emojiSearch = {};
+    constructor(emojiService) {
+        this.emojiService = emojiService;
+        for (const emojiData of this.emojiService.emojis) {
+            const { shortNames, emoticons } = emojiData;
+            const id = shortNames[0];
+            for (const emoticon of emoticons) {
+                if (this.emoticonsList[emoticon]) {
+                    continue;
+                }
+                this.emoticonsList[emoticon] = id;
+            }
+            this.emojisList[id] = this.emojiService.getSanitizedData(id);
+            this.originalPool[id] = emojiData;
+        }
+    }
+    addCustomToPool(custom, pool) {
+        for (const emoji of custom) {
+            const emojiId = emoji.id || emoji.shortNames[0];
+            if (emojiId && !pool[emojiId]) {
+                pool[emojiId] = this.emojiService.getData(emoji);
+                this.emojisList[emojiId] = this.emojiService.getSanitizedData(emoji);
+            }
+        }
+    }
+    search(value, emojisToShowFilter, maxResults = 75, include = [], exclude = [], custom = []) {
+        this.addCustomToPool(custom, this.originalPool);
+        let results;
+        let pool = this.originalPool;
+        if (value.length) {
+            if (value === '-' || value === '-1') {
+                return [this.emojisList['-1']];
+            }
+            if (value === '+' || value === '+1') {
+                return [this.emojisList['+1']];
+            }
+            let values = value.toLowerCase().split(/[\s|,|\-|_]+/);
+            let allResults = [];
+            if (values.length > 2) {
+                values = [values[0], values[1]];
+            }
+            if (include.length || exclude.length) {
+                pool = {};
+                for (const category of categories || []) {
+                    const isIncluded = include && include.length ? include.indexOf(category.id) > -1 : true;
+                    const isExcluded = exclude && exclude.length ? exclude.indexOf(category.id) > -1 : false;
+                    if (!isIncluded || isExcluded) {
+                        continue;
+                    }
+                    for (const emojiId of category.emojis || []) {
+                        // Need to make sure that pool gets keyed
+                        // with the correct id, which is why we call emojiService.getData below
+                        const emoji = this.emojiService.getData(emojiId);
+                        pool[emoji?.id ?? ''] = emoji;
+                    }
+                }
+                if (custom.length) {
+                    const customIsIncluded = include && include.length ? include.indexOf('custom') > -1 : true;
+                    const customIsExcluded = exclude && exclude.length ? exclude.indexOf('custom') > -1 : false;
+                    if (customIsIncluded && !customIsExcluded) {
+                        this.addCustomToPool(custom, pool);
+                    }
+                }
+            }
+            allResults = values
+                .map(v => {
+                let aPool = pool;
+                let aIndex = this.index;
+                let length = 0;
+                for (let charIndex = 0; charIndex < v.length; charIndex++) {
+                    const char = v[charIndex];
+                    length++;
+                    if (!aIndex[char]) {
+                        aIndex[char] = {};
+                    }
+                    aIndex = aIndex[char];
+                    if (!aIndex.results) {
+                        const scores = {};
+                        aIndex.results = [];
+                        aIndex.pool = {};
+                        for (const id of Object.keys(aPool)) {
+                            const emoji = aPool[id];
+                            if (!this.emojiSearch[id]) {
+                                this.emojiSearch[id] = this.buildSearch(emoji.short_names, emoji.name, emoji.id, emoji.keywords, emoji.emoticons);
+                            }
+                            const query = this.emojiSearch[id];
+                            const sub = v.substr(0, length);
+                            const subIndex = query.indexOf(sub);
+                            if (subIndex !== -1) {
+                                let score = subIndex + 1;
+                                if (sub === id) {
+                                    score = 0;
+                                }
+                                aIndex.results.push(this.emojisList[id]);
+                                aIndex.pool[id] = emoji;
+                                scores[id] = score;
+                            }
+                        }
+                        aIndex.results.sort((a, b) => {
+                            const aScore = scores[a.id];
+                            const bScore = scores[b.id];
+                            return aScore - bScore;
+                        });
+                    }
+                    aPool = aIndex.pool;
+                }
+                return aIndex.results;
+            })
+                .filter(a => a);
+            if (allResults.length > 1) {
+                results = intersect.apply(null, allResults);
+            }
+            else if (allResults.length) {
+                results = allResults[0];
+            }
+            else {
+                results = [];
+            }
+        }
+        if (results) {
+            if (emojisToShowFilter) {
+                results = results.filter((result) => {
+                    if (result && result.id) {
+                        return emojisToShowFilter(this.emojiService.names[result.id]);
+                    }
+                    return false;
+                });
+            }
+            if (results && results.length > maxResults) {
+                results = results.slice(0, maxResults);
+            }
+        }
+        return results || null;
+    }
+    buildSearch(shortNames, name, id, keywords, emoticons) {
+        const search = [];
+        const addToSearch = (strings, split) => {
+            if (!strings) {
+                return;
+            }
+            const arr = Array.isArray(strings) ? strings : [strings];
+            for (const str of arr) {
+                const substrings = split ? str.split(/[-|_|\s]+/) : [str];
+                for (let s of substrings) {
+                    s = s.toLowerCase();
+                    if (!search.includes(s)) {
+                        search.push(s);
+                    }
+                }
+            }
+        };
+        addToSearch(shortNames, true);
+        addToSearch(name, true);
+        addToSearch(id, true);
+        addToSearch(keywords, true);
+        addToSearch(emoticons, false);
+        return search.join(',');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EmojiSearch, deps: [{ token: i1.EmojiService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EmojiSearch, providedIn: 'root' });
+}
+export { EmojiSearch };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EmojiSearch, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.EmojiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emoji-search.service.js","sourceRoot":"","sources":["../../src/lib/picker/emoji-search.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,UAAU,EAA2B,MAAM,gCAAgC,CAAC;AACrF,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;;;AAEpC,MACa,WAAW;IAWF;IAVpB,YAAY,GAAQ,EAAE,CAAC;IACvB,KAAK,GAID,EAAE,CAAC;IACP,UAAU,GAAQ,EAAE,CAAC;IACrB,aAAa,GAA8B,EAAE,CAAC;IAC9C,WAAW,GAA8B,EAAE,CAAC;IAE5C,YAAoB,YAA0B;QAA1B,iBAAY,GAAZ,YAAY,CAAc;QAC5C,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE;YAChD,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,SAAS,CAAC;YAC5C,MAAM,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;YAEzB,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE;gBAChC,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE;oBAChC,SAAS;iBACV;gBAED,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC;aACnC;YAED,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAC;YAC7D,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;SACnC;IACH,CAAC;IAED,eAAe,CAAC,MAAW,EAAE,IAAS;QACpC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;YAC1B,MAAM,OAAO,GAAG,KAAK,CAAC,EAAE,IAAI,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAEhD,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;gBAC7B,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;gBACjD,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;aACtE;SACF;IACH,CAAC;IAED,MAAM,CACJ,KAAa,EACb,kBAAwC,EACxC,UAAU,GAAG,EAAE,EACf,UAAiB,EAAE,EACnB,UAAiB,EAAE,EACnB,SAAgB,EAAE;QAElB,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAEhD,IAAI,OAAgC,CAAC;QACrC,IAAI,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC;QAE7B,IAAI,KAAK,CAAC,MAAM,EAAE;YAChB,IAAI,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,IAAI,EAAE;gBACnC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;aAChC;YACD,IAAI,KAAK,KAAK,GAAG,IAAI,KAAK,KAAK,IAAI,EAAE;gBACnC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;aAChC;YAED,IAAI,MAAM,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC;YACvD,IAAI,UAAU,GAAG,EAAE,CAAC;YAEpB,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;gBACrB,MAAM,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;aACjC;YAED,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,EAAE;gBACpC,IAAI,GAAG,EAAE,CAAC;gBAEV,KAAK,MAAM,QAAQ,IAAI,UAAU,IAAI,EAAE,EAAE;oBACvC,MAAM,UAAU,GAAG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;oBACxF,MAAM,UAAU,GAAG,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;oBAEzF,IAAI,CAAC,UAAU,IAAI,UAAU,EAAE;wBAC7B,SAAS;qBACV;oBAED,KAAK,MAAM,OAAO,IAAI,QAAQ,CAAC,MAAM,IAAI,EAAE,EAAE;wBAC3C,yCAAyC;wBACzC,uEAAuE;wBACvE,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;wBACjD,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC;qBAC/B;iBACF;gBAED,IAAI,MAAM,CAAC,MAAM,EAAE;oBACjB,MAAM,gBAAgB,GACpB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;oBACpE,MAAM,gBAAgB,GACpB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;oBACrE,IAAI,gBAAgB,IAAI,CAAC,gBAAgB,EAAE;wBACzC,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;qBACpC;iBACF;aACF;YAED,UAAU,GAAG,MAAM;iBAChB,GAAG,CAAC,CAAC,CAAC,EAAE;gBACP,IAAI,KAAK,GAAG,IAAI,CAAC;gBACjB,IAAI,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC;gBACxB,IAAI,MAAM,GAAG,CAAC,CAAC;gBAEf,KAAK,IAAI,SAAS,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE;oBACzD,MAAM,IAAI,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC;oBAC1B,MAAM,EAAE,CAAC;oBACT,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;wBACjB,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;qBACnB;oBACD,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;oBAEtB,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE;wBACnB,MAAM,MAAM,GAA8B,EAAE,CAAC;wBAE7C,MAAM,CAAC,OAAO,GAAG,EAAE,CAAC;wBACpB,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC;wBAEjB,KAAK,MAAM,EAAE,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;4BACnC,MAAM,KAAK,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;4BACxB,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,EAAE;gCACzB,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,CACrC,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,IAAI,EACV,KAAK,CAAC,EAAE,EACR,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,SAAS,CAChB,CAAC;6BACH;4BACD,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;4BACnC,MAAM,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;4BAChC,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;4BAEpC,IAAI,QAAQ,KAAK,CAAC,CAAC,EAAE;gCACnB,IAAI,KAAK,GAAG,QAAQ,GAAG,CAAC,CAAC;gCACzB,IAAI,GAAG,KAAK,EAAE,EAAE;oCACd,KAAK,GAAG,CAAC,CAAC;iCACX;gCAED,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;gCACzC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;gCAExB,MAAM,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC;6BACpB;yBACF;wBAED,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;4BAC3B,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;4BAC5B,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;4BAE5B,OAAO,MAAM,GAAG,MAAM,CAAC;wBACzB,CAAC,CAAC,CAAC;qBACJ;oBAED,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC;iBACrB;gBAED,OAAO,MAAM,CAAC,OAAO,CAAC;YACxB,CAAC,CAAC;iBACD,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAElB,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE;gBACzB,OAAO,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,UAAiB,CAAC,CAAC;aACpD;iBAAM,IAAI,UAAU,CAAC,MAAM,EAAE;gBAC5B,OAAO,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;aACzB;iBAAM;gBACL,OAAO,GAAG,EAAE,CAAC;aACd;SACF;QAED,IAAI,OAAO,EAAE;YACX,IAAI,kBAAkB,EAAE;gBACtB,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,MAAiB,EAAE,EAAE;oBAC7C,IAAI,MAAM,IAAI,MAAM,CAAC,EAAE,EAAE;wBACvB,OAAO,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;qBAC/D;oBACD,OAAO,KAAK,CAAC;gBACf,CAAC,CAAC,CAAC;aACJ;YAED,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,GAAG,UAAU,EAAE;gBAC1C,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;aACxC;SACF;QACD,OAAO,OAAO,IAAI,IAAI,CAAC;IACzB,CAAC;IAED,WAAW,CACT,UAAoB,EACpB,IAAY,EACZ,EAAU,EACV,QAAkB,EAClB,SAAmB;QAEnB,MAAM,MAAM,GAAa,EAAE,CAAC;QAE5B,MAAM,WAAW,GAAG,CAAC,OAA0B,EAAE,KAAc,EAAE,EAAE;YACjE,IAAI,CAAC,OAAO,EAAE;gBACZ,OAAO;aACR;YAED,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;YAEzD,KAAK,MAAM,GAAG,IAAI,GAAG,EAAE;gBACrB,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;gBAE1D,KAAK,IAAI,CAAC,IAAI,UAAU,EAAE;oBACxB,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,CAAC;oBAEpB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE;wBACvB,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;qBAChB;iBACF;aACF;QACH,CAAC,CAAC;QAEF,WAAW,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QAC9B,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACxB,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;QACtB,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAC5B,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;QAE9B,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;uGA/NU,WAAW;2GAAX,WAAW,cADE,MAAM;;SACnB,WAAW;2FAAX,WAAW;kBADvB,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { categories, EmojiData, EmojiService } from '@ctrl/ngx-emoji-mart/ngx-emoji';\nimport { intersect } from './utils';\n\n@Injectable({ providedIn: 'root' })\nexport class EmojiSearch {\n  originalPool: any = {};\n  index: {\n    results?: EmojiData[];\n    pool?: { [key: string]: EmojiData };\n    [key: string]: any;\n  } = {};\n  emojisList: any = {};\n  emoticonsList: { [key: string]: string } = {};\n  emojiSearch: { [key: string]: string } = {};\n\n  constructor(private emojiService: EmojiService) {\n    for (const emojiData of this.emojiService.emojis) {\n      const { shortNames, emoticons } = emojiData;\n      const id = shortNames[0];\n\n      for (const emoticon of emoticons) {\n        if (this.emoticonsList[emoticon]) {\n          continue;\n        }\n\n        this.emoticonsList[emoticon] = id;\n      }\n\n      this.emojisList[id] = this.emojiService.getSanitizedData(id);\n      this.originalPool[id] = emojiData;\n    }\n  }\n\n  addCustomToPool(custom: any, pool: any) {\n    for (const emoji of custom) {\n      const emojiId = emoji.id || emoji.shortNames[0];\n\n      if (emojiId && !pool[emojiId]) {\n        pool[emojiId] = this.emojiService.getData(emoji);\n        this.emojisList[emojiId] = this.emojiService.getSanitizedData(emoji);\n      }\n    }\n  }\n\n  search(\n    value: string,\n    emojisToShowFilter?: (x: any) => boolean,\n    maxResults = 75,\n    include: any[] = [],\n    exclude: any[] = [],\n    custom: any[] = [],\n  ): EmojiData[] | null {\n    this.addCustomToPool(custom, this.originalPool);\n\n    let results: EmojiData[] | undefined;\n    let pool = this.originalPool;\n\n    if (value.length) {\n      if (value === '-' || value === '-1') {\n        return [this.emojisList['-1']];\n      }\n      if (value === '+' || value === '+1') {\n        return [this.emojisList['+1']];\n      }\n\n      let values = value.toLowerCase().split(/[\\s|,|\\-|_]+/);\n      let allResults = [];\n\n      if (values.length > 2) {\n        values = [values[0], values[1]];\n      }\n\n      if (include.length || exclude.length) {\n        pool = {};\n\n        for (const category of categories || []) {\n          const isIncluded = include && include.length ? include.indexOf(category.id) > -1 : true;\n          const isExcluded = exclude && exclude.length ? exclude.indexOf(category.id) > -1 : false;\n\n          if (!isIncluded || isExcluded) {\n            continue;\n          }\n\n          for (const emojiId of category.emojis || []) {\n            // Need to make sure that pool gets keyed\n            // with the correct id, which is why we call emojiService.getData below\n            const emoji = this.emojiService.getData(emojiId);\n            pool[emoji?.id ?? ''] = emoji;\n          }\n        }\n\n        if (custom.length) {\n          const customIsIncluded =\n            include && include.length ? include.indexOf('custom') > -1 : true;\n          const customIsExcluded =\n            exclude && exclude.length ? exclude.indexOf('custom') > -1 : false;\n          if (customIsIncluded && !customIsExcluded) {\n            this.addCustomToPool(custom, pool);\n          }\n        }\n      }\n\n      allResults = values\n        .map(v => {\n          let aPool = pool;\n          let aIndex = this.index;\n          let length = 0;\n\n          for (let charIndex = 0; charIndex < v.length; charIndex++) {\n            const char = v[charIndex];\n            length++;\n            if (!aIndex[char]) {\n              aIndex[char] = {};\n            }\n            aIndex = aIndex[char];\n\n            if (!aIndex.results) {\n              const scores: { [key: string]: number } = {};\n\n              aIndex.results = [];\n              aIndex.pool = {};\n\n              for (const id of Object.keys(aPool)) {\n                const emoji = aPool[id];\n                if (!this.emojiSearch[id]) {\n                  this.emojiSearch[id] = this.buildSearch(\n                    emoji.short_names,\n                    emoji.name,\n                    emoji.id,\n                    emoji.keywords,\n                    emoji.emoticons,\n                  );\n                }\n                const query = this.emojiSearch[id];\n                const sub = v.substr(0, length);\n                const subIndex = query.indexOf(sub);\n\n                if (subIndex !== -1) {\n                  let score = subIndex + 1;\n                  if (sub === id) {\n                    score = 0;\n                  }\n\n                  aIndex.results.push(this.emojisList[id]);\n                  aIndex.pool[id] = emoji;\n\n                  scores[id] = score;\n                }\n              }\n\n              aIndex.results.sort((a, b) => {\n                const aScore = scores[a.id];\n                const bScore = scores[b.id];\n\n                return aScore - bScore;\n              });\n            }\n\n            aPool = aIndex.pool;\n          }\n\n          return aIndex.results;\n        })\n        .filter(a => a);\n\n      if (allResults.length > 1) {\n        results = intersect.apply(null, allResults as any);\n      } else if (allResults.length) {\n        results = allResults[0];\n      } else {\n        results = [];\n      }\n    }\n\n    if (results) {\n      if (emojisToShowFilter) {\n        results = results.filter((result: EmojiData) => {\n          if (result && result.id) {\n            return emojisToShowFilter(this.emojiService.names[result.id]);\n          }\n          return false;\n        });\n      }\n\n      if (results && results.length > maxResults) {\n        results = results.slice(0, maxResults);\n      }\n    }\n    return results || null;\n  }\n\n  buildSearch(\n    shortNames: string[],\n    name: string,\n    id: string,\n    keywords: string[],\n    emoticons: string[],\n  ) {\n    const search: string[] = [];\n\n    const addToSearch = (strings: string | string[], split: boolean) => {\n      if (!strings) {\n        return;\n      }\n\n      const arr = Array.isArray(strings) ? strings : [strings];\n\n      for (const str of arr) {\n        const substrings = split ? str.split(/[-|_|\\s]+/) : [str];\n\n        for (let s of substrings) {\n          s = s.toLowerCase();\n\n          if (!search.includes(s)) {\n            search.push(s);\n          }\n        }\n      }\n    };\n\n    addToSearch(shortNames, true);\n    addToSearch(name, true);\n    addToSearch(id, true);\n    addToSearch(keywords, true);\n    addToSearch(emoticons, false);\n\n    return search.join(',');\n  }\n}\n"]}

package/esm2022/ngx-emoji/emoji.component.mjs

@@ -0,0 +1,299 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, NgZone, Output, ViewChild, inject, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { EMPTY, Subject, fromEvent, switchMap, takeUntil } from 'rxjs';
+import { DEFAULT_BACKGROUNDFN, EmojiService } from './emoji.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+class EmojiComponent {
+    skin = 1;
+    set = 'apple';
+    sheetSize = 64;
+    /** Renders the native unicode emoji */
+    isNative = false;
+    forceSize = false;
+    tooltip = false;
+    size = 24;
+    emoji = '';
+    fallback;
+    hideObsolete = false;
+    sheetRows;
+    sheetColumns;
+    useButton;
+    emojiClick = new EventEmitter();
+    /**
+     * Note: `emojiOver` and `emojiOverOutsideAngular` are dispatched on the same event (`mouseenter`), but
+     *       for different purposes. The `emojiOverOutsideAngular` event is listened only in `emoji-category`
+     *       component and the category component doesn't care about zone context the callback is being called in.
+     *       The `emojiOver` is for backwards compatibility if anyone is listening to this event explicitly in their code.
+     */
+    emojiOver = new EventEmitter();
+    emojiOverOutsideAngular = new EventEmitter();
+    /** See comments above, this serves the same purpose. */
+    emojiLeave = new EventEmitter();
+    emojiLeaveOutsideAngular = new EventEmitter();
+    style;
+    title = undefined;
+    label = '';
+    unified;
+    custom = false;
+    isVisible = true;
+    // TODO: replace 4.0.3 w/ dynamic get verison from emoji-datasource in package.json
+    backgroundImageFn = DEFAULT_BACKGROUNDFN;
+    imageUrlFn;
+    set button(button) {
+        // Note: `runOutsideAngular` is used to trigger `addEventListener` outside of the Angular zone
+        //       too. See `setupMouseEnterListener`. The `switchMap` will subscribe to `fromEvent` considering
+        //       the context where the factory is called in.
+        this.ngZone.runOutsideAngular(() => this.button$.next(button?.nativeElement));
+    }
+    /**
+     * The subject used to emit whenever view queries are run and `button` or `span` is set/removed.
+     * We use subject to keep the reactive behavior so we don't have to add and remove event listeners manually.
+     */
+    button$ = new Subject();
+    destroy$ = new Subject();
+    ngZone = inject(NgZone);
+    emojiService = inject(EmojiService);
+    constructor() {
+        this.setupMouseListeners();
+    }
+    ngOnChanges() {
+        if (!this.emoji) {
+            return (this.isVisible = false);
+        }
+        const data = this.getData();
+        if (!data) {
+            return (this.isVisible = false);
+        }
+        // const children = this.children;
+        this.unified = data.native || null;
+        if (data.custom) {
+            this.custom = data.custom;
+        }
+        if (!data.unified && !data.custom) {
+            return (this.isVisible = false);
+        }
+        if (this.tooltip) {
+            this.title = data.shortNames[0];
+        }
+        if (data.obsoletedBy && this.hideObsolete) {
+            return (this.isVisible = false);
+        }
+        this.label = [data.native].concat(data.shortNames).filter(Boolean).join(', ');
+        if (this.isNative && data.unified && data.native) {
+            // hide older emoji before the split into gendered emoji
+            this.style = { fontSize: `${this.size}px` };
+            if (this.forceSize) {
+                this.style.display = 'inline-block';
+                this.style.width = `${this.size}px`;
+                this.style.height = `${this.size}px`;
+                this.style['word-break'] = 'keep-all';
+            }
+        }
+        else if (data.custom) {
+            this.style = {
+                width: `${this.size}px`,
+                height: `${this.size}px`,
+                display: 'inline-block',
+            };
+            if (data.spriteUrl && this.sheetRows && this.sheetColumns) {
+                this.style = {
+                    ...this.style,
+                    backgroundImage: `url(${data.spriteUrl})`,
+                    backgroundSize: `${100 * this.sheetColumns}% ${100 * this.sheetRows}%`,
+                    backgroundPosition: this.emojiService.getSpritePosition(data.sheet, this.sheetColumns),
+                };
+            }
+            else {
+                this.style = {
+                    ...this.style,
+                    backgroundImage: `url(${data.imageUrl})`,
+                    backgroundSize: 'contain',
+                };
+            }
+        }
+        else {
+            if (data.hidden.length && data.hidden.includes(this.set)) {
+                if (this.fallback) {
+                    this.style = { fontSize: `${this.size}px` };
+                    this.unified = this.fallback(data, this);
+                }
+                else {
+                    return (this.isVisible = false);
+                }
+            }
+            else {
+                this.style = this.emojiService.emojiSpriteStyles(data.sheet, this.set, this.size, this.sheetSize, this.sheetRows, this.backgroundImageFn, this.sheetColumns, this.imageUrlFn?.(this.getData()));
+            }
+        }
+        return (this.isVisible = true);
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+    }
+    getData() {
+        return this.emojiService.getData(this.emoji, this.skin, this.set);
+    }
+    getSanitizedData() {
+        return this.emojiService.getSanitizedData(this.emoji, this.skin, this.set);
+    }
+    handleClick($event) {
+        const emoji = this.getSanitizedData();
+        this.emojiClick.emit({ emoji, $event });
+    }
+    setupMouseListeners() {
+        const eventListener$ = (eventName) => this.button$.pipe(
+        // Note: `EMPTY` is used to remove event listener once the DOM node is removed.
+        switchMap(button => (button ? fromEvent(button, eventName) : EMPTY)), takeUntil(this.destroy$));
+        eventListener$('mouseenter').subscribe($event => {
+            const emoji = this.getSanitizedData();
+            this.emojiOverOutsideAngular.emit({ emoji, $event });
+            // Note: this is done for backwards compatibility. We run change detection if developers
+            //       are listening to `emojiOver` in their code. For instance:
+            //       `<ngx-emoji (emojiOver)="..."></ngx-emoji>`.
+            if (this.emojiOver.observed) {
+                this.ngZone.run(() => this.emojiOver.emit({ emoji, $event }));
+            }
+        });
+        eventListener$('mouseleave').subscribe($event => {
+            const emoji = this.getSanitizedData();
+            this.emojiLeaveOutsideAngular.emit({ emoji, $event });
+            // Note: this is done for backwards compatibility. We run change detection if developers
+            //       are listening to `emojiLeave` in their code. For instance:
+            //       `<ngx-emoji (emojiLeave)="..."></ngx-emoji>`.
+            if (this.emojiLeave.observed) {
+                this.ngZone.run(() => this.emojiLeave.emit({ emoji, $event }));
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EmojiComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: EmojiComponent, isStandalone: true, selector: "ngx-emoji", inputs: { skin: "skin", set: "set", sheetSize: "sheetSize", isNative: "isNative", forceSize: "forceSize", tooltip: "tooltip", size: "size", emoji: "emoji", fallback: "fallback", hideObsolete: "hideObsolete", sheetRows: "sheetRows", sheetColumns: "sheetColumns", useButton: "useButton", backgroundImageFn: "backgroundImageFn", imageUrlFn: "imageUrlFn" }, outputs: { emojiClick: "emojiClick", emojiOver: "emojiOver", emojiOverOutsideAngular: "emojiOverOutsideAngular", emojiLeave: "emojiLeave", emojiLeaveOutsideAngular: "emojiLeaveOutsideAngular" }, viewQueries: [{ propertyName: "button", first: true, predicate: ["button"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
+    <ng-template [ngIf]="isVisible">
+      <button
+        *ngIf="useButton; else spanTpl"
+        #button
+        type="button"
+        (click)="handleClick($event)"
+        [attr.title]="title"
+        [attr.aria-label]="label"
+        class="emoji-mart-emoji"
+        [class.emoji-mart-emoji-native]="isNative"
+        [class.emoji-mart-emoji-custom]="custom"
+      >
+        <span [ngStyle]="style">
+          <ng-template [ngIf]="isNative">{{ unified }}</ng-template>
+          <ng-content></ng-content>
+        </span>
+      </button>
+    </ng-template>
+
+    <ng-template #spanTpl>
+      <span
+        #button
+        (click)="handleClick($event)"
+        [attr.title]="title"
+        [attr.aria-label]="label"
+        class="emoji-mart-emoji"
+        [class.emoji-mart-emoji-native]="isNative"
+        [class.emoji-mart-emoji-custom]="custom"
+      >
+        <span [ngStyle]="style">
+          <ng-template [ngIf]="isNative">{{ unified }}</ng-template>
+          <ng-content></ng-content>
+        </span>
+      </span>
+    </ng-template>
+  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+export { EmojiComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EmojiComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngx-emoji',
+                    template: `
+    <ng-template [ngIf]="isVisible">
+      <button
+        *ngIf="useButton; else spanTpl"
+        #button
+        type="button"
+        (click)="handleClick($event)"
+        [attr.title]="title"
+        [attr.aria-label]="label"
+        class="emoji-mart-emoji"
+        [class.emoji-mart-emoji-native]="isNative"
+        [class.emoji-mart-emoji-custom]="custom"
+      >
+        <span [ngStyle]="style">
+          <ng-template [ngIf]="isNative">{{ unified }}</ng-template>
+          <ng-content></ng-content>
+        </span>
+      </button>
+    </ng-template>
+
+    <ng-template #spanTpl>
+      <span
+        #button
+        (click)="handleClick($event)"
+        [attr.title]="title"
+        [attr.aria-label]="label"
+        class="emoji-mart-emoji"
+        [class.emoji-mart-emoji-native]="isNative"
+        [class.emoji-mart-emoji-custom]="custom"
+      >
+        <span [ngStyle]="style">
+          <ng-template [ngIf]="isNative">{{ unified }}</ng-template>
+          <ng-content></ng-content>
+        </span>
+      </span>
+    </ng-template>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    preserveWhitespaces: false,
+                    standalone: true,
+                    imports: [CommonModule],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { skin: [{
+                type: Input
+            }], set: [{
+                type: Input
+            }], sheetSize: [{
+                type: Input
+            }], isNative: [{
+                type: Input
+            }], forceSize: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], emoji: [{
+                type: Input
+            }], fallback: [{
+                type: Input
+            }], hideObsolete: [{
+                type: Input
+            }], sheetRows: [{
+                type: Input
+            }], sheetColumns: [{
+                type: Input
+            }], useButton: [{
+                type: Input
+            }], emojiClick: [{
+                type: Output
+            }], emojiOver: [{
+                type: Output
+            }], emojiOverOutsideAngular: [{
+                type: Output
+            }], emojiLeave: [{
+                type: Output
+            }], emojiLeaveOutsideAngular: [{
+                type: Output
+            }], backgroundImageFn: [{
+                type: Input
+            }], imageUrlFn: [{
+                type: Input
+            }], button: [{
+                type: ViewChild,
+                args: ['button', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emoji.component.js","sourceRoot":"","sources":["../../../src/lib/picker/ngx-emoji/emoji.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,SAAS,EAET,YAAY,EACZ,KAAK,EACL,MAAM,EAGN,MAAM,EACN,SAAS,EACT,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAGvE,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;;;AA0BrE,MA4Ca,cAAc;IAChB,IAAI,GAAkB,CAAC,CAAC;IACxB,GAAG,GAAiB,OAAO,CAAC;IAC5B,SAAS,GAAuB,EAAE,CAAC;IAC5C,uCAAuC;IAC9B,QAAQ,GAAsB,KAAK,CAAC;IACpC,SAAS,GAAuB,KAAK,CAAC;IACtC,OAAO,GAAqB,KAAK,CAAC;IAClC,IAAI,GAAkB,EAAE,CAAC;IACzB,KAAK,GAAmB,EAAE,CAAC;IAC3B,QAAQ,CAAqB;IAC7B,YAAY,GAAG,KAAK,CAAC;IACrB,SAAS,CAAU;IACnB,YAAY,CAAU;IACtB,SAAS,CAAW;IACnB,UAAU,GAAwB,IAAI,YAAY,EAAE,CAAC;IAC/D;;;;;OAKG;IACO,SAAS,GAAuB,IAAI,YAAY,EAAE,CAAC;IACnD,uBAAuB,GAAuB,IAAI,YAAY,EAAE,CAAC;IAC3E,wDAAwD;IAC9C,UAAU,GAAwB,IAAI,YAAY,EAAE,CAAC;IACrD,wBAAwB,GAAwB,IAAI,YAAY,EAAE,CAAC;IAE7E,KAAK,CAAM;IACX,KAAK,GAAY,SAAS,CAAC;IAC3B,KAAK,GAAG,EAAE,CAAC;IACX,OAAO,CAAiB;IACxB,MAAM,GAAG,KAAK,CAAC;IACf,SAAS,GAAG,IAAI,CAAC;IACjB,mFAAmF;IAC1E,iBAAiB,GAA+B,oBAAoB,CAAC;IACrE,UAAU,CAAuB;IAE1C,IACI,MAAM,CAAC,MAA2C;QACpD,8FAA8F;QAC9F,sGAAsG;QACtG,oDAAoD;QACpD,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IAChF,CAAC;IAED;;;OAGG;IACc,OAAO,GAAG,IAAI,OAAO,EAA2B,CAAC;IAEjD,QAAQ,GAAG,IAAI,OAAO,EAAQ,CAAC;IAE/B,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IACxB,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;IAErD;QACE,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;YACf,OAAO,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;SACjC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC,IAAI,EAAE;YACT,OAAO,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;SACjC;QACD,kCAAkC;QAClC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC;QACnC,IAAI,IAAI,CAAC,MAAM,EAAE;YACf,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;SAC3B;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YACjC,OAAO,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;SACjC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;SACjC;QACD,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,YAAY,EAAE;YACzC,OAAO,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;SACjC;QAED,IAAI,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE9E,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM,EAAE;YAChD,wDAAwD;YACxD,IAAI,CAAC,KAAK,GAAG,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;YAE5C,IAAI,IAAI,CAAC,SAAS,EAAE;gBAClB,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,cAAc,CAAC;gBACpC,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC;gBACpC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC;gBACrC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,UAAU,CAAC;aACvC;SACF;aAAM,IAAI,IAAI,CAAC,MAAM,EAAE;YACtB,IAAI,CAAC,KAAK,GAAG;gBACX,KAAK,EAAE,GAAG,IAAI,CAAC,IAAI,IAAI;gBACvB,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,IAAI;gBACxB,OAAO,EAAE,cAAc;aACxB,CAAC;YACF,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,YAAY,EAAE;gBACzD,IAAI,CAAC,KAAK,GAAG;oBACX,GAAG,IAAI,CAAC,KAAK;oBACb,eAAe,EAAE,OAAO,IAAI,CAAC,SAAS,GAAG;oBACzC,cAAc,EAAE,GAAG,GAAG,GAAG,IAAI,CAAC,YAAY,KAAK,GAAG,GAAG,IAAI,CAAC,SAAS,GAAG;oBACtE,kBAAkB,EAAE,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC;iBACvF,CAAC;aACH;iBAAM;gBACL,IAAI,CAAC,KAAK,GAAG;oBACX,GAAG,IAAI,CAAC,KAAK;oBACb,eAAe,EAAE,OAAO,IAAI,CAAC,QAAQ,GAAG;oBACxC,cAAc,EAAE,SAAS;iBAC1B,CAAC;aACH;SACF;aAAM;YACL,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;gBACxD,IAAI,IAAI,CAAC,QAAQ,EAAE;oBACjB,IAAI,CAAC,KAAK,GAAG,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;oBAC5C,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;iBAC1C;qBAAM;oBACL,OAAO,CAAC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,CAAC;iBACjC;aACF;iBAAM;gBACL,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAC9C,IAAI,CAAC,KAAK,EACV,IAAI,CAAC,GAAG,EACR,IAAI,CAAC,IAAI,EACT,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,iBAAiB,EACtB,IAAI,CAAC,YAAY,EACjB,IAAI,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAClC,CAAC;aACH;SACF;QACD,OAAO,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,WAAW;QACT,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IACvB,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;IACpE,CAAC;IAED,gBAAgB;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAc,CAAC;IAC1F,CAAC;IAED,WAAW,CAAC,MAAa;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;IAC1C,CAAC;IAEO,mBAAmB;QACzB,MAAM,cAAc,GAAG,CAAC,SAAiB,EAAE,EAAE,CAC3C,IAAI,CAAC,OAAO,CAAC,IAAI;QACf,+EAA+E;QAC/E,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EACpE,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CACzB,CAAC;QAEJ,cAAc,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;YACrD,wFAAwF;YACxF,kEAAkE;YAClE,qDAAqD;YACrD,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE;gBAC3B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;aAC/D;QACH,CAAC,CAAC,CAAC;QAEH,cAAc,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtC,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;YACtD,wFAAwF;YACxF,mEAAmE;YACnE,sDAAsD;YACtD,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE;gBAC5B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;aAChE;QACH,CAAC,CAAC,CAAC;IACL,CAAC;uGA1LU,cAAc;2FAAd,cAAc,iuBA1Cf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCT,2DAIS,YAAY;;SAEX,cAAc;2FAAd,cAAc;kBA5C1B,SAAS;mBAAC;oBACT,QAAQ,EAAE,WAAW;oBACrB,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCT;oBACD,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,mBAAmB,EAAE,KAAK;oBAC1B,UAAU,EAAE,IAAI;oBAChB,OAAO,EAAE,CAAC,YAAY,CAAC;iBACxB;0EAEU,IAAI;sBAAZ,KAAK;gBACG,GAAG;sBAAX,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBAEG,QAAQ;sBAAhB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,YAAY;sBAApB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACI,UAAU;sBAAnB,MAAM;gBAOG,SAAS;sBAAlB,MAAM;gBACG,uBAAuB;sBAAhC,MAAM;gBAEG,UAAU;sBAAnB,MAAM;gBACG,wBAAwB;sBAAjC,MAAM;gBASE,iBAAiB;sBAAzB,KAAK;gBACG,UAAU;sBAAlB,KAAK;gBAGF,MAAM;sBADT,SAAS;uBAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  Output,\n  ViewChild,\n  inject,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { EMPTY, Subject, fromEvent, switchMap, takeUntil } from 'rxjs';\n\nimport { EmojiData } from './data/data.interfaces';\nimport { DEFAULT_BACKGROUNDFN, EmojiService } from './emoji.service';\n\nexport interface Emoji {\n  /** Renders the native unicode emoji */\n  isNative: boolean;\n  forceSize: boolean;\n  tooltip: boolean;\n  skin: 1 | 2 | 3 | 4 | 5 | 6;\n  sheetSize: 16 | 20 | 32 | 64 | 72;\n  sheetRows?: number;\n  set: 'apple' | 'google' | 'twitter' | 'facebook' | '';\n  size: number;\n  emoji: string | EmojiData;\n  backgroundImageFn: (set: string, sheetSize: number) => string;\n  fallback?: (data: any, props: any) => string;\n  emojiOver: EventEmitter<EmojiEvent>;\n  emojiLeave: EventEmitter<EmojiEvent>;\n  emojiClick: EventEmitter<EmojiEvent>;\n  imageUrlFn?: (emoji: EmojiData | null) => string;\n}\n\nexport interface EmojiEvent {\n  emoji: EmojiData;\n  $event: Event;\n}\n\n@Component({\n  selector: 'ngx-emoji',\n  template: `\n    <ng-template [ngIf]=\"isVisible\">\n      <button\n        *ngIf=\"useButton; else spanTpl\"\n        #button\n        type=\"button\"\n        (click)=\"handleClick($event)\"\n        [attr.title]=\"title\"\n        [attr.aria-label]=\"label\"\n        class=\"emoji-mart-emoji\"\n        [class.emoji-mart-emoji-native]=\"isNative\"\n        [class.emoji-mart-emoji-custom]=\"custom\"\n      >\n        <span [ngStyle]=\"style\">\n          <ng-template [ngIf]=\"isNative\">{{ unified }}</ng-template>\n          <ng-content></ng-content>\n        </span>\n      </button>\n    </ng-template>\n\n    <ng-template #spanTpl>\n      <span\n        #button\n        (click)=\"handleClick($event)\"\n        [attr.title]=\"title\"\n        [attr.aria-label]=\"label\"\n        class=\"emoji-mart-emoji\"\n        [class.emoji-mart-emoji-native]=\"isNative\"\n        [class.emoji-mart-emoji-custom]=\"custom\"\n      >\n        <span [ngStyle]=\"style\">\n          <ng-template [ngIf]=\"isNative\">{{ unified }}</ng-template>\n          <ng-content></ng-content>\n        </span>\n      </span>\n    </ng-template>\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  preserveWhitespaces: false,\n  standalone: true,\n  imports: [CommonModule],\n})\nexport class EmojiComponent implements OnChanges, Emoji, OnDestroy {\n  @Input() skin: Emoji['skin'] = 1;\n  @Input() set: Emoji['set'] = 'apple';\n  @Input() sheetSize: Emoji['sheetSize'] = 64;\n  /** Renders the native unicode emoji */\n  @Input() isNative: Emoji['isNative'] = false;\n  @Input() forceSize: Emoji['forceSize'] = false;\n  @Input() tooltip: Emoji['tooltip'] = false;\n  @Input() size: Emoji['size'] = 24;\n  @Input() emoji: Emoji['emoji'] = '';\n  @Input() fallback?: Emoji['fallback'];\n  @Input() hideObsolete = false;\n  @Input() sheetRows?: number;\n  @Input() sheetColumns?: number;\n  @Input() useButton?: boolean;\n  @Output() emojiClick: Emoji['emojiClick'] = new EventEmitter();\n  /**\n   * Note: `emojiOver` and `emojiOverOutsideAngular` are dispatched on the same event (`mouseenter`), but\n   *       for different purposes. The `emojiOverOutsideAngular` event is listened only in `emoji-category`\n   *       component and the category component doesn't care about zone context the callback is being called in.\n   *       The `emojiOver` is for backwards compatibility if anyone is listening to this event explicitly in their code.\n   */\n  @Output() emojiOver: Emoji['emojiOver'] = new EventEmitter();\n  @Output() emojiOverOutsideAngular: Emoji['emojiOver'] = new EventEmitter();\n  /** See comments above, this serves the same purpose. */\n  @Output() emojiLeave: Emoji['emojiLeave'] = new EventEmitter();\n  @Output() emojiLeaveOutsideAngular: Emoji['emojiLeave'] = new EventEmitter();\n\n  style: any;\n  title?: string = undefined;\n  label = '';\n  unified?: string | null;\n  custom = false;\n  isVisible = true;\n  // TODO: replace 4.0.3 w/ dynamic get verison from emoji-datasource in package.json\n  @Input() backgroundImageFn: Emoji['backgroundImageFn'] = DEFAULT_BACKGROUNDFN;\n  @Input() imageUrlFn?: Emoji['imageUrlFn'];\n\n  @ViewChild('button', { static: false })\n  set button(button: ElementRef<HTMLElement> | undefined) {\n    // Note: `runOutsideAngular` is used to trigger `addEventListener` outside of the Angular zone\n    //       too. See `setupMouseEnterListener`. The `switchMap` will subscribe to `fromEvent` considering\n    //       the context where the factory is called in.\n    this.ngZone.runOutsideAngular(() => this.button$.next(button?.nativeElement));\n  }\n\n  /**\n   * The subject used to emit whenever view queries are run and `button` or `span` is set/removed.\n   * We use subject to keep the reactive behavior so we don't have to add and remove event listeners manually.\n   */\n  private readonly button$ = new Subject<HTMLElement | undefined>();\n\n  private readonly destroy$ = new Subject<void>();\n\n  private readonly ngZone = inject(NgZone);\n  private readonly emojiService = inject(EmojiService);\n\n  constructor() {\n    this.setupMouseListeners();\n  }\n\n  ngOnChanges() {\n    if (!this.emoji) {\n      return (this.isVisible = false);\n    }\n    const data = this.getData();\n    if (!data) {\n      return (this.isVisible = false);\n    }\n    // const children = this.children;\n    this.unified = data.native || null;\n    if (data.custom) {\n      this.custom = data.custom;\n    }\n    if (!data.unified && !data.custom) {\n      return (this.isVisible = false);\n    }\n    if (this.tooltip) {\n      this.title = data.shortNames[0];\n    }\n    if (data.obsoletedBy && this.hideObsolete) {\n      return (this.isVisible = false);\n    }\n\n    this.label = [data.native].concat(data.shortNames).filter(Boolean).join(', ');\n\n    if (this.isNative && data.unified && data.native) {\n      // hide older emoji before the split into gendered emoji\n      this.style = { fontSize: `${this.size}px` };\n\n      if (this.forceSize) {\n        this.style.display = 'inline-block';\n        this.style.width = `${this.size}px`;\n        this.style.height = `${this.size}px`;\n        this.style['word-break'] = 'keep-all';\n      }\n    } else if (data.custom) {\n      this.style = {\n        width: `${this.size}px`,\n        height: `${this.size}px`,\n        display: 'inline-block',\n      };\n      if (data.spriteUrl && this.sheetRows && this.sheetColumns) {\n        this.style = {\n          ...this.style,\n          backgroundImage: `url(${data.spriteUrl})`,\n          backgroundSize: `${100 * this.sheetColumns}% ${100 * this.sheetRows}%`,\n          backgroundPosition: this.emojiService.getSpritePosition(data.sheet, this.sheetColumns),\n        };\n      } else {\n        this.style = {\n          ...this.style,\n          backgroundImage: `url(${data.imageUrl})`,\n          backgroundSize: 'contain',\n        };\n      }\n    } else {\n      if (data.hidden.length && data.hidden.includes(this.set)) {\n        if (this.fallback) {\n          this.style = { fontSize: `${this.size}px` };\n          this.unified = this.fallback(data, this);\n        } else {\n          return (this.isVisible = false);\n        }\n      } else {\n        this.style = this.emojiService.emojiSpriteStyles(\n          data.sheet,\n          this.set,\n          this.size,\n          this.sheetSize,\n          this.sheetRows,\n          this.backgroundImageFn,\n          this.sheetColumns,\n          this.imageUrlFn?.(this.getData()),\n        );\n      }\n    }\n    return (this.isVisible = true);\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n  }\n\n  getData() {\n    return this.emojiService.getData(this.emoji, this.skin, this.set);\n  }\n\n  getSanitizedData(): EmojiData {\n    return this.emojiService.getSanitizedData(this.emoji, this.skin, this.set) as EmojiData;\n  }\n\n  handleClick($event: Event) {\n    const emoji = this.getSanitizedData();\n    this.emojiClick.emit({ emoji, $event });\n  }\n\n  private setupMouseListeners(): void {\n    const eventListener$ = (eventName: string) =>\n      this.button$.pipe(\n        // Note: `EMPTY` is used to remove event listener once the DOM node is removed.\n        switchMap(button => (button ? fromEvent(button, eventName) : EMPTY)),\n        takeUntil(this.destroy$),\n      );\n\n    eventListener$('mouseenter').subscribe($event => {\n      const emoji = this.getSanitizedData();\n      this.emojiOverOutsideAngular.emit({ emoji, $event });\n      // Note: this is done for backwards compatibility. We run change detection if developers\n      //       are listening to `emojiOver` in their code. For instance:\n      //       `<ngx-emoji (emojiOver)=\"...\"></ngx-emoji>`.\n      if (this.emojiOver.observed) {\n        this.ngZone.run(() => this.emojiOver.emit({ emoji, $event }));\n      }\n    });\n\n    eventListener$('mouseleave').subscribe($event => {\n      const emoji = this.getSanitizedData();\n      this.emojiLeaveOutsideAngular.emit({ emoji, $event });\n      // Note: this is done for backwards compatibility. We run change detection if developers\n      //       are listening to `emojiLeave` in their code. For instance:\n      //       `<ngx-emoji (emojiLeave)=\"...\"></ngx-emoji>`.\n      if (this.emojiLeave.observed) {\n        this.ngZone.run(() => this.emojiLeave.emit({ emoji, $event }));\n      }\n    });\n  }\n}\n"]}

package/esm2022/ngx-emoji/emoji.module.mjs

@@ -0,0 +1,17 @@
+import { NgModule } from '@angular/core';
+import { EmojiComponent } from './emoji.component';
+import * as i0 from "@angular/core";
+class EmojiModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EmojiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: EmojiModule, imports: [EmojiComponent], exports: [EmojiComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EmojiModule, imports: [EmojiComponent] });
+}
+export { EmojiModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: EmojiModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [EmojiComponent],
+                    exports: [EmojiComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1vamkubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9waWNrZXIvbmd4LWVtb2ppL2Vtb2ppLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7QUFFbkQsTUFJYSxXQUFXO3VHQUFYLFdBQVc7d0dBQVgsV0FBVyxZQUhaLGNBQWMsYUFDZCxjQUFjO3dHQUViLFdBQVcsWUFIWixjQUFjOztTQUdiLFdBQVc7MkZBQVgsV0FBVztrQkFKdkIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxjQUFjLENBQUM7b0JBQ3pCLE9BQU8sRUFBRSxDQUFDLGNBQWMsQ0FBQztpQkFDMUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBFbW9qaUNvbXBvbmVudCB9IGZyb20gJy4vZW1vamkuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0Vtb2ppQ29tcG9uZW50XSxcbiAgZXhwb3J0czogW0Vtb2ppQ29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgRW1vamlNb2R1bGUge31cbiJdfQ==