@ctrl/ngx-emoji-mart 5.1.1 → 6.1.0

package/esm2020/category.component.mjs

@@ -0,0 +1,386 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@ctrl/ngx-emoji-mart/ngx-emoji";
+import * as i2 from "./emoji-frequently.service";
+import * as i3 from "@angular/common";
+export class CategoryComponent {
+    constructor(ref, emojiService, frequently) {
+        this.ref = ref;
+        this.emojiService = emojiService;
+        this.frequently = frequently;
+        this.emojis = null;
+        this.hasStickyPosition = true;
+        this.name = '';
+        this.perLine = 9;
+        this.totalFrequentLines = 4;
+        this.recent = [];
+        this.custom = [];
+        this.hideObsolete = true;
+        this.virtualize = false;
+        this.virtualizeOffset = 0;
+        this.emojiOver = new EventEmitter();
+        this.emojiLeave = new EventEmitter();
+        this.emojiClick = new EventEmitter();
+        this.containerStyles = {};
+        this.emojisToDisplay = [];
+        this.filteredEmojisSubject = new Subject();
+        this.filteredEmojis$ = this.filteredEmojisSubject.asObservable();
+        this.labelStyles = {};
+        this.labelSpanStyles = {};
+        this.margin = 0;
+        this.minMargin = 0;
+        this.maxMargin = 0;
+        this.top = 0;
+        this.rows = 0;
+    }
+    ngOnInit() {
+        this.updateRecentEmojis();
+        this.emojisToDisplay = this.filterEmojis();
+        if (this.noEmojiToDisplay) {
+            this.containerStyles = { display: 'none' };
+        }
+        if (!this.hasStickyPosition) {
+            this.labelStyles = { height: 28 };
+            // this.labelSpanStyles = { position: 'absolute' };
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes.emojis?.currentValue?.length !== changes.emojis?.previousValue?.length) {
+            this.emojisToDisplay = this.filterEmojis();
+            this.ngAfterViewInit();
+        }
+    }
+    ngAfterViewInit() {
+        if (!this.virtualize) {
+            return;
+        }
+        const { width } = this.container.nativeElement.getBoundingClientRect();
+        const perRow = Math.floor(width / (this.emojiSize + 12));
+        this.rows = Math.ceil(this.emojisToDisplay.length / perRow);
+        this.containerStyles = {
+            ...this.containerStyles,
+            minHeight: `${this.rows * (this.emojiSize + 12) + 28}px`,
+        };
+        this.ref?.detectChanges();
+        this.handleScroll(this.container.nativeElement.parentNode.parentNode.scrollTop);
+    }
+    get noEmojiToDisplay() {
+        return this.emojisToDisplay.length === 0;
+    }
+    memoizeSize() {
+        const parent = this.container.nativeElement.parentNode.parentNode;
+        const { top, height } = this.container.nativeElement.getBoundingClientRect();
+        const parentTop = parent.getBoundingClientRect().top;
+        const labelHeight = this.label.nativeElement.getBoundingClientRect().height;
+        this.top = top - parentTop + parent.scrollTop;
+        if (height === 0) {
+            this.maxMargin = 0;
+        }
+        else {
+            this.maxMargin = height - labelHeight;
+        }
+    }
+    handleScroll(scrollTop) {
+        let margin = scrollTop - this.top;
+        margin = margin < this.minMargin ? this.minMargin : margin;
+        margin = margin > this.maxMargin ? this.maxMargin : margin;
+        if (this.virtualize) {
+            const { top, height } = this.container.nativeElement.getBoundingClientRect();
+            const parentHeight = this.container.nativeElement.parentNode.parentNode.clientHeight;
+            if (parentHeight + (parentHeight + this.virtualizeOffset) >= top && -height - (parentHeight + this.virtualizeOffset) <= top) {
+                this.filteredEmojisSubject.next(this.emojisToDisplay);
+            }
+            else {
+                this.filteredEmojisSubject.next([]);
+            }
+        }
+        if (margin === this.margin) {
+            this.ref.detectChanges();
+            return false;
+        }
+        if (!this.hasStickyPosition) {
+            this.label.nativeElement.style.top = `${margin}px`;
+        }
+        this.margin = margin;
+        this.ref.detectChanges();
+        return true;
+    }
+    updateRecentEmojis() {
+        if (this.name !== 'Recent') {
+            return;
+        }
+        let frequentlyUsed = this.recent || this.frequently.get(this.perLine, this.totalFrequentLines);
+        if (!frequentlyUsed || !frequentlyUsed.length) {
+            frequentlyUsed = this.frequently.get(this.perLine, this.totalFrequentLines);
+        }
+        if (!frequentlyUsed.length) {
+            return;
+        }
+        this.emojis = frequentlyUsed
+            .map(id => {
+            const emoji = this.custom.filter((e) => e.id === id)[0];
+            if (emoji) {
+                return emoji;
+            }
+            return id;
+        })
+            .filter(id => !!this.emojiService.getData(id));
+    }
+    updateDisplay(display) {
+        this.containerStyles.display = display;
+        this.updateRecentEmojis();
+        this.ref.detectChanges();
+    }
+    trackById(index, item) {
+        return item;
+    }
+    filterEmojis() {
+        const newEmojis = [];
+        for (const emoji of this.emojis || []) {
+            if (!emoji) {
+                continue;
+            }
+            const data = this.emojiService.getData(emoji);
+            if (!data || (data.obsoletedBy && this.hideObsolete) || (!data.unified && !data.custom)) {
+                continue;
+            }
+            newEmojis.push(emoji);
+        }
+        return newEmojis;
+    }
+}
+CategoryComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CategoryComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.EmojiService }, { token: i2.EmojiFrequentlyService }], target: i0.ɵɵFactoryTarget.Component });
+CategoryComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: CategoryComponent, selector: "emoji-category", inputs: { emojis: "emojis", hasStickyPosition: "hasStickyPosition", name: "name", perLine: "perLine", totalFrequentLines: "totalFrequentLines", recent: "recent", custom: "custom", i18n: "i18n", id: "id", hideObsolete: "hideObsolete", notFoundEmoji: "notFoundEmoji", virtualize: "virtualize", virtualizeOffset: "virtualizeOffset", emojiIsNative: "emojiIsNative", emojiSkin: "emojiSkin", emojiSize: "emojiSize", emojiSet: "emojiSet", emojiSheetSize: "emojiSheetSize", emojiForceSize: "emojiForceSize", emojiTooltip: "emojiTooltip", emojiBackgroundImageFn: "emojiBackgroundImageFn", emojiImageUrlFn: "emojiImageUrlFn", emojiUseButton: "emojiUseButton" }, outputs: { emojiOver: "emojiOver", emojiLeave: "emojiLeave", emojiClick: "emojiClick" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, static: true }, { propertyName: "label", first: true, predicate: ["label"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: `
+    <section
+      #container
+      class="emoji-mart-category"
+      [attr.aria-label]="i18n.categories[id]"
+      [class.emoji-mart-no-results]="noEmojiToDisplay"
+      [ngStyle]="containerStyles"
+    >
+      <div class="emoji-mart-category-label" [ngStyle]="labelStyles" [attr.data-name]="name">
+        <!-- already labeled by the section aria-label -->
+        <span #label [ngStyle]="labelSpanStyles" aria-hidden="true">
+          {{ i18n.categories[id] }}
+        </span>
+      </div>
+
+      <div
+        *ngIf="virtualize; else normalRenderTemplate"
+      >
+        <div *ngIf="filteredEmojis$ | async as filteredEmojis">
+          <ngx-emoji
+            *ngFor="let emoji of filteredEmojis; trackBy: trackById"
+            [emoji]="emoji"
+            [size]="emojiSize"
+            [skin]="emojiSkin"
+            [isNative]="emojiIsNative"
+            [set]="emojiSet"
+            [sheetSize]="emojiSheetSize"
+            [forceSize]="emojiForceSize"
+            [tooltip]="emojiTooltip"
+            [backgroundImageFn]="emojiBackgroundImageFn"
+            [imageUrlFn]="emojiImageUrlFn"
+            [hideObsolete]="hideObsolete"
+            [useButton]="emojiUseButton"
+            (emojiOver)="emojiOver.emit($event)"
+            (emojiLeave)="emojiLeave.emit($event)"
+            (emojiClick)="emojiClick.emit($event)"
+          ></ngx-emoji>
+        </div>
+      </div>
+
+      <div *ngIf="noEmojiToDisplay">
+        <div>
+          <ngx-emoji
+            [emoji]="notFoundEmoji"
+            [size]="38"
+            [skin]="emojiSkin"
+            [isNative]="emojiIsNative"
+            [set]="emojiSet"
+            [sheetSize]="emojiSheetSize"
+            [forceSize]="emojiForceSize"
+            [tooltip]="emojiTooltip"
+            [backgroundImageFn]="emojiBackgroundImageFn"
+            [useButton]="emojiUseButton"
+          ></ngx-emoji>
+        </div>
+
+        <div class="emoji-mart-no-results-label">
+          {{ i18n.notfound }}
+        </div>
+      </div>
+    </section>
+
+    <ng-template #normalRenderTemplate>
+        <ngx-emoji
+          *ngFor="let emoji of emojisToDisplay; trackBy: trackById"
+          [emoji]="emoji"
+          [size]="emojiSize"
+          [skin]="emojiSkin"
+          [isNative]="emojiIsNative"
+          [set]="emojiSet"
+          [sheetSize]="emojiSheetSize"
+          [forceSize]="emojiForceSize"
+          [tooltip]="emojiTooltip"
+          [backgroundImageFn]="emojiBackgroundImageFn"
+          [imageUrlFn]="emojiImageUrlFn"
+          [hideObsolete]="hideObsolete"
+          [useButton]="emojiUseButton"
+          (emojiOver)="emojiOver.emit($event)"
+          (emojiLeave)="emojiLeave.emit($event)"
+          (emojiClick)="emojiClick.emit($event)"
+        ></ngx-emoji>
+    </ng-template>
+  `, isInline: true, components: [{ type: i1.EmojiComponent, selector: "ngx-emoji", inputs: ["skin", "set", "sheetSize", "isNative", "forceSize", "tooltip", "size", "emoji", "fallback", "hideObsolete", "sheetRows", "sheetColumns", "useButton", "backgroundImageFn", "imageUrlFn"], outputs: ["emojiOver", "emojiLeave", "emojiClick"] }], directives: [{ type: i3.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "async": i3.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CategoryComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'emoji-category',
+                    template: `
+    <section
+      #container
+      class="emoji-mart-category"
+      [attr.aria-label]="i18n.categories[id]"
+      [class.emoji-mart-no-results]="noEmojiToDisplay"
+      [ngStyle]="containerStyles"
+    >
+      <div class="emoji-mart-category-label" [ngStyle]="labelStyles" [attr.data-name]="name">
+        <!-- already labeled by the section aria-label -->
+        <span #label [ngStyle]="labelSpanStyles" aria-hidden="true">
+          {{ i18n.categories[id] }}
+        </span>
+      </div>
+
+      <div
+        *ngIf="virtualize; else normalRenderTemplate"
+      >
+        <div *ngIf="filteredEmojis$ | async as filteredEmojis">
+          <ngx-emoji
+            *ngFor="let emoji of filteredEmojis; trackBy: trackById"
+            [emoji]="emoji"
+            [size]="emojiSize"
+            [skin]="emojiSkin"
+            [isNative]="emojiIsNative"
+            [set]="emojiSet"
+            [sheetSize]="emojiSheetSize"
+            [forceSize]="emojiForceSize"
+            [tooltip]="emojiTooltip"
+            [backgroundImageFn]="emojiBackgroundImageFn"
+            [imageUrlFn]="emojiImageUrlFn"
+            [hideObsolete]="hideObsolete"
+            [useButton]="emojiUseButton"
+            (emojiOver)="emojiOver.emit($event)"
+            (emojiLeave)="emojiLeave.emit($event)"
+            (emojiClick)="emojiClick.emit($event)"
+          ></ngx-emoji>
+        </div>
+      </div>
+
+      <div *ngIf="noEmojiToDisplay">
+        <div>
+          <ngx-emoji
+            [emoji]="notFoundEmoji"
+            [size]="38"
+            [skin]="emojiSkin"
+            [isNative]="emojiIsNative"
+            [set]="emojiSet"
+            [sheetSize]="emojiSheetSize"
+            [forceSize]="emojiForceSize"
+            [tooltip]="emojiTooltip"
+            [backgroundImageFn]="emojiBackgroundImageFn"
+            [useButton]="emojiUseButton"
+          ></ngx-emoji>
+        </div>
+
+        <div class="emoji-mart-no-results-label">
+          {{ i18n.notfound }}
+        </div>
+      </div>
+    </section>
+
+    <ng-template #normalRenderTemplate>
+        <ngx-emoji
+          *ngFor="let emoji of emojisToDisplay; trackBy: trackById"
+          [emoji]="emoji"
+          [size]="emojiSize"
+          [skin]="emojiSkin"
+          [isNative]="emojiIsNative"
+          [set]="emojiSet"
+          [sheetSize]="emojiSheetSize"
+          [forceSize]="emojiForceSize"
+          [tooltip]="emojiTooltip"
+          [backgroundImageFn]="emojiBackgroundImageFn"
+          [imageUrlFn]="emojiImageUrlFn"
+          [hideObsolete]="hideObsolete"
+          [useButton]="emojiUseButton"
+          (emojiOver)="emojiOver.emit($event)"
+          (emojiLeave)="emojiLeave.emit($event)"
+          (emojiClick)="emojiClick.emit($event)"
+        ></ngx-emoji>
+    </ng-template>
+  `,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    preserveWhitespaces: false,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.EmojiService }, { type: i2.EmojiFrequentlyService }]; }, propDecorators: { emojis: [{
+                type: Input
+            }], hasStickyPosition: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], perLine: [{
+                type: Input
+            }], totalFrequentLines: [{
+                type: Input
+            }], recent: [{
+                type: Input
+            }], custom: [{
+                type: Input
+            }], i18n: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], hideObsolete: [{
+                type: Input
+            }], notFoundEmoji: [{
+                type: Input
+            }], virtualize: [{
+                type: Input
+            }], virtualizeOffset: [{
+                type: Input
+            }], emojiIsNative: [{
+                type: Input
+            }], emojiSkin: [{
+                type: Input
+            }], emojiSize: [{
+                type: Input
+            }], emojiSet: [{
+                type: Input
+            }], emojiSheetSize: [{
+                type: Input
+            }], emojiForceSize: [{
+                type: Input
+            }], emojiTooltip: [{
+                type: Input
+            }], emojiBackgroundImageFn: [{
+                type: Input
+            }], emojiImageUrlFn: [{
+                type: Input
+            }], emojiUseButton: [{
+                type: Input
+            }], emojiOver: [{
+                type: Output
+            }], emojiLeave: [{
+                type: Output
+            }], emojiClick: [{
+                type: Output
+            }], container: [{
+                type: ViewChild,
+                args: ['container', { static: true }]
+            }], label: [{
+                type: ViewChild,
+                args: ['label', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"category.component.js","sourceRoot":"","sources":["../../src/lib/picker/category.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Emoji, EmojiService } from '@ctrl/ngx-emoji-mart/ngx-emoji';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\nimport { EmojiFrequentlyService } from './emoji-frequently.service';\n\n\n@Component({\n  selector: 'emoji-category',\n  template: `\n    <section\n      #container\n      class=\"emoji-mart-category\"\n      [attr.aria-label]=\"i18n.categories[id]\"\n      [class.emoji-mart-no-results]=\"noEmojiToDisplay\"\n      [ngStyle]=\"containerStyles\"\n    >\n      <div class=\"emoji-mart-category-label\" [ngStyle]=\"labelStyles\" [attr.data-name]=\"name\">\n        <!-- already labeled by the section aria-label -->\n        <span #label [ngStyle]=\"labelSpanStyles\" aria-hidden=\"true\">\n          {{ i18n.categories[id] }}\n        </span>\n      </div>\n\n      <div\n        *ngIf=\"virtualize; else normalRenderTemplate\"\n      >\n        <div *ngIf=\"filteredEmojis$ | async as filteredEmojis\">\n          <ngx-emoji\n            *ngFor=\"let emoji of filteredEmojis; trackBy: trackById\"\n            [emoji]=\"emoji\"\n            [size]=\"emojiSize\"\n            [skin]=\"emojiSkin\"\n            [isNative]=\"emojiIsNative\"\n            [set]=\"emojiSet\"\n            [sheetSize]=\"emojiSheetSize\"\n            [forceSize]=\"emojiForceSize\"\n            [tooltip]=\"emojiTooltip\"\n            [backgroundImageFn]=\"emojiBackgroundImageFn\"\n            [imageUrlFn]=\"emojiImageUrlFn\"\n            [hideObsolete]=\"hideObsolete\"\n            [useButton]=\"emojiUseButton\"\n            (emojiOver)=\"emojiOver.emit($event)\"\n            (emojiLeave)=\"emojiLeave.emit($event)\"\n            (emojiClick)=\"emojiClick.emit($event)\"\n          ></ngx-emoji>\n        </div>\n      </div>\n\n      <div *ngIf=\"noEmojiToDisplay\">\n        <div>\n          <ngx-emoji\n            [emoji]=\"notFoundEmoji\"\n            [size]=\"38\"\n            [skin]=\"emojiSkin\"\n            [isNative]=\"emojiIsNative\"\n            [set]=\"emojiSet\"\n            [sheetSize]=\"emojiSheetSize\"\n            [forceSize]=\"emojiForceSize\"\n            [tooltip]=\"emojiTooltip\"\n            [backgroundImageFn]=\"emojiBackgroundImageFn\"\n            [useButton]=\"emojiUseButton\"\n          ></ngx-emoji>\n        </div>\n\n        <div class=\"emoji-mart-no-results-label\">\n          {{ i18n.notfound }}\n        </div>\n      </div>\n    </section>\n\n    <ng-template #normalRenderTemplate>\n        <ngx-emoji\n          *ngFor=\"let emoji of emojisToDisplay; trackBy: trackById\"\n          [emoji]=\"emoji\"\n          [size]=\"emojiSize\"\n          [skin]=\"emojiSkin\"\n          [isNative]=\"emojiIsNative\"\n          [set]=\"emojiSet\"\n          [sheetSize]=\"emojiSheetSize\"\n          [forceSize]=\"emojiForceSize\"\n          [tooltip]=\"emojiTooltip\"\n          [backgroundImageFn]=\"emojiBackgroundImageFn\"\n          [imageUrlFn]=\"emojiImageUrlFn\"\n          [hideObsolete]=\"hideObsolete\"\n          [useButton]=\"emojiUseButton\"\n          (emojiOver)=\"emojiOver.emit($event)\"\n          (emojiLeave)=\"emojiLeave.emit($event)\"\n          (emojiClick)=\"emojiClick.emit($event)\"\n        ></ngx-emoji>\n    </ng-template>\n  `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  preserveWhitespaces: false,\n})\nexport class CategoryComponent implements OnChanges, OnInit, AfterViewInit {\n  @Input() emojis: any[] | null = null\n  @Input() hasStickyPosition = true;\n  @Input() name = '';\n  @Input() perLine = 9;\n  @Input() totalFrequentLines = 4;\n  @Input() recent: string[] = [];\n  @Input() custom: any[] = [];\n  @Input() i18n: any;\n  @Input() id: any;\n  @Input() hideObsolete = true;\n  @Input() notFoundEmoji?: string;\n  @Input() virtualize = false;\n  @Input() virtualizeOffset = 0;\n  @Input() emojiIsNative?: Emoji['isNative'];\n  @Input() emojiSkin!: Emoji['skin'];\n  @Input() emojiSize!: Emoji['size'];\n  @Input() emojiSet!: Emoji['set'];\n  @Input() emojiSheetSize!: Emoji['sheetSize'];\n  @Input() emojiForceSize!: Emoji['forceSize'];\n  @Input() emojiTooltip!: Emoji['tooltip'];\n  @Input() emojiBackgroundImageFn?: Emoji['backgroundImageFn'];\n  @Input() emojiImageUrlFn?: Emoji['imageUrlFn'];\n  @Input() emojiUseButton?: boolean;\n  @Output() emojiOver: Emoji['emojiOver'] = new EventEmitter();\n  @Output() emojiLeave: Emoji['emojiLeave'] = new EventEmitter();\n  @Output() emojiClick: Emoji['emojiClick'] = new EventEmitter();\n  @ViewChild('container', { static: true }) container!: ElementRef;\n  @ViewChild('label', { static: true }) label!: ElementRef;\n  containerStyles: any = {};\n  emojisToDisplay: any[]  = []\n  private filteredEmojisSubject = new Subject<any[] | null | undefined>();\n  filteredEmojis$: Observable<any[] | null | undefined> = this.filteredEmojisSubject.asObservable();\n  labelStyles: any = {};\n  labelSpanStyles: any = {};\n  margin = 0;\n  minMargin = 0;\n  maxMargin = 0;\n  top = 0;\n  rows = 0;\n\n  constructor(\n    public ref: ChangeDetectorRef,\n    private emojiService: EmojiService,\n    private frequently: EmojiFrequentlyService,\n  ) {}\n\n  ngOnInit() {\n    this.updateRecentEmojis();\n    this.emojisToDisplay = this.filterEmojis();\n\n    if (this.noEmojiToDisplay) {\n      this.containerStyles = { display: 'none' };\n    }\n\n    if (!this.hasStickyPosition) {\n      this.labelStyles = { height: 28 };\n      // this.labelSpanStyles = { position: 'absolute' };\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes.emojis?.currentValue?.length !== changes.emojis?.previousValue?.length) {\n      this.emojisToDisplay = this.filterEmojis();\n      this.ngAfterViewInit();\n    }\n  }\n\n  ngAfterViewInit() {\n    if (!this.virtualize) {\n      return;\n    }\n\n    const { width } = this.container.nativeElement.getBoundingClientRect();\n\n    const perRow = Math.floor(width / (this.emojiSize + 12));\n    this.rows = Math.ceil(this.emojisToDisplay.length / perRow);\n\n    this.containerStyles = {\n      ...this.containerStyles,\n      minHeight: `${this.rows * (this.emojiSize + 12) + 28}px`,\n    };\n\n    this.ref?.detectChanges();\n\n    this.handleScroll(this.container.nativeElement.parentNode.parentNode.scrollTop);\n  }\n\n\n  get noEmojiToDisplay():boolean{\n    return this.emojisToDisplay.length === 0;\n  }\n\n  memoizeSize() {\n    const parent = this.container.nativeElement.parentNode.parentNode;\n    const { top, height } = this.container.nativeElement.getBoundingClientRect();\n    const parentTop = parent.getBoundingClientRect().top;\n    const labelHeight = this.label.nativeElement.getBoundingClientRect().height;\n\n    this.top = top - parentTop + parent.scrollTop;\n\n    if (height === 0) {\n      this.maxMargin = 0;\n    } else {\n      this.maxMargin = height - labelHeight;\n    }\n  }\n\n  handleScroll(scrollTop: number): boolean {\n    let margin = scrollTop - this.top;\n    margin = margin < this.minMargin ? this.minMargin : margin;\n    margin = margin > this.maxMargin ? this.maxMargin : margin;\n\n    if (this.virtualize) {\n      const { top, height } = this.container.nativeElement.getBoundingClientRect();\n      const parentHeight = this.container.nativeElement.parentNode.parentNode.clientHeight;\n\n      if (parentHeight + (parentHeight + this.virtualizeOffset) >= top && -height - (parentHeight + this.virtualizeOffset) <= top) {\n        this.filteredEmojisSubject.next(this.emojisToDisplay);\n      } else {\n        this.filteredEmojisSubject.next([]);\n      }\n    }\n\n    if (margin === this.margin) {\n      this.ref.detectChanges();\n      return false;\n    }\n\n    if (!this.hasStickyPosition) {\n      this.label.nativeElement.style.top = `${margin}px`;\n    }\n\n    this.margin = margin;\n    this.ref.detectChanges();\n    return true;\n  }\n\n  updateRecentEmojis() {\n    if (this.name !== 'Recent') {\n      return;\n    }\n\n    let frequentlyUsed =\n      this.recent || this.frequently.get(this.perLine, this.totalFrequentLines);\n    if (!frequentlyUsed || !frequentlyUsed.length) {\n      frequentlyUsed = this.frequently.get(this.perLine, this.totalFrequentLines);\n    }\n    if (!frequentlyUsed.length) {\n      return\n    }\n    this.emojis = frequentlyUsed\n      .map(id => {\n        const emoji = this.custom.filter((e: any) => e.id === id)[0];\n        if (emoji) {\n          return emoji;\n        }\n\n        return id;\n      })\n      .filter(id => !!this.emojiService.getData(id));\n\n  }\n\n  updateDisplay(display: 'none' | 'block') {\n    this.containerStyles.display = display;\n    this.updateRecentEmojis();\n    this.ref.detectChanges();\n  }\n\n  trackById(index: number, item: any) {\n    return item;\n  }\n\n  private filterEmojis(): any[] {\n    const newEmojis = [];\n    for (const emoji of this.emojis || []) {\n      if (!emoji) {\n        continue;\n      }\n      const data = this.emojiService.getData(emoji);\n      if (!data || (data.obsoletedBy && this.hideObsolete) || (!data.unified && !data.custom)) {\n        continue;\n      }\n      newEmojis.push(emoji);\n    }\n    return newEmojis;\n  }\n}\n"]}

package/{esm2015/emoji-frequently.service.js → esm2020/emoji-frequently.service.mjs}

@@ -76,11 +76,13 @@ export class EmojiFrequentlyService {
         return sliced;
     }
 }
-EmojiFrequentlyService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EmojiFrequentlyService_Factory() { return new EmojiFrequentlyService(i0.ɵɵinject(i0.PLATFORM_ID)); }, token: EmojiFrequentlyService, providedIn: "root" });
-EmojiFrequentlyService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-EmojiFrequentlyService.ctorParameters = () => [
-    { type: String, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
-];
-//# sourceMappingURL=data:application/json;base64,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
+EmojiFrequentlyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EmojiFrequentlyService, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+EmojiFrequentlyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EmojiFrequentlyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: EmojiFrequentlyService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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