@libs-ui/components-inputs-emoji 0.2.355-9 → 0.2.356-1

package/README.md

@@ -1,3 +1,144 @@
-# inputs-emoji
+# @libs-ui/components-inputs-emoji
 
-This library was generated with [Nx](https://nx.dev).
+> Component chọn Emoji (Emoji Picker) tích hợp trong Popover với tính năng tìm kiếm và phân loại.
+
+## Giới thiệu
+
+`LibsUiComponentsEmojiComponent` cung cấp một giao diện chọn emoji trực quan, hỗ trợ đầy đủ các nhóm emoji tiêu chuẩn, tìm kiếm theo tên và tối ưu hóa hiệu năng bằng lazy loading khi cuộn danh sách.
+
+### Tính năng
+
+- ✅ Danh sách Emoji đầy đủ, phân loại theo nhóm
+- ✅ Tìm kiếm Emoji nhanh chóng
+- ✅ Tích hợp sẵn Popover thông minh
+- ✅ Lazy loading (scroll to load more) tối ưu hiệu năng
+- ✅ Hỗ trợ Custom Trigger qua `ng-content`
+- ✅ Tùy chỉnh linh hoạt kích thước và vị trí popup
+
+## Khi nào sử dụng
+
+- Khi cần cho phép người dùng chèn cảm xúc (emoji) vào nội dung văn bản.
+- Phù hợp cho ứng dụng Chat, Comment, Social Media.
+- Khi cần một bộ chọn emoji chuyên nghiệp nhưng vẫn tiết kiệm diện tích giao diện.
+
+## Cài đặt
+
+```bash
+# npm
+npm install @libs-ui/components-inputs-emoji
+
+# yarn
+yarn add @libs-ui/components-inputs-emoji
+```
+
+## Import
+
+```typescript
+import { LibsUiComponentsEmojiComponent } from '@libs-ui/components-inputs-emoji';
+
+@Component({
+  standalone: true,
+  imports: [LibsUiComponentsEmojiComponent],
+  // ...
+})
+export class YourComponent {}
+```
+
+## Ví dụ
+
+### Cơ bản
+
+```html
+<libs_ui-components-emoji (outEventEmoji)="onSelect($event)" />
+```
+
+### Custom Trigger
+
+```html
+<libs_ui-components-emoji
+  [isNgContent]="true"
+  (outEventEmoji)="onSelect($event)">
+  <button>Chọn Emoji</button>
+</libs_ui-components-emoji>
+```
+
+## API
+
+### libs_ui-components-emoji
+
+#### Inputs
+
+| Property                | Type                           | Default                  | Description                                  |
+| ----------------------- | ------------------------------ | ------------------------ | -------------------------------------------- |
+| `[classIconInclude]`    | `string`                       | `'libs-ui-icon-add'`     | CSS class cho icon trigger mặc định          |
+| `[classInclude]`        | `string`                       | `''`                     | CSS class bổ sung cho trigger container      |
+| `[classPopup]`          | `string`                       | `'w-[290px] h-[245px]'`  | CSS class cho container của popup chọn emoji |
+| `[configPopover]`       | `IPopoverOverlay`              | `defaultConfigPopover()` | Cấu hình overlay cho Popover                 |
+| `[isNgContent]`         | `boolean`                      | `false`                  | Sử dụng ng-content làm trigger thay vì icon  |
+| `[modePopoverPosition]` | `'start' \| 'center' \| 'end'` | `undefined`              | Chế độ căn lề cho Popover                    |
+| `[zIndex]`              | `number`                       | `0`                      | Giá trị Z-index nền của popup                |
+
+#### Outputs
+
+| Property                | Type                           | Description                                         |
+| ----------------------- | ------------------------------ | --------------------------------------------------- |
+| `(outEventEmoji)`       | `string`                       | Emit khi người dùng chọn một emoji                  |
+| `(outFunctionsControl)` | `IPopoverFunctionControlEvent` | Emit các functions điều khiển Popover (show/remove) |
+
+## Types & Interfaces
+
+```typescript
+// Interface configure Popover
+export interface IPopoverOverlay {
+  isAddContentToParentDocument?: boolean;
+  classInclude?: string;
+  widthByParent?: boolean;
+  width?: number;
+  minWidth?: number;
+  maxWidth?: number;
+  maxHeight?: number | null;
+  zIndex?: number;
+  direction?: 'top' | 'right' | 'bottom' | 'left';
+  position?: {
+    mode: 'start' | 'center' | 'end';
+    distance: number;
+  };
+  // ... (see @libs-ui/components-popover for full list)
+}
+
+export interface IPopoverFunctionControlEvent {
+  showPopoverOverlay: () => void;
+  removePopoverOverlay: () => void;
+}
+```
+
+## Công nghệ
+
+| Technology      | Version | Purpose          |
+| --------------- | ------- | ---------------- |
+| Angular         | 18+     | Framework        |
+| Angular Signals | -       | State management |
+| TailwindCSS     | 3.x     | Styling          |
+| OnPush          | -       | Change Detection |
+
+## Demo
+
+```bash
+npx nx serve core-ui
+```
+
+Truy cập: `http://localhost:4500/inputs/emoji`
+
+## Unit Tests
+
+```bash
+# Chạy tests
+npx nx test components-inputs-emoji
+
+# Coverage
+npx nx test components-inputs-emoji --coverage
+```
+
+## License
+
+MIT

package/emoji.component.d.ts

@@ -2,6 +2,10 @@ import { AfterViewInit } from '@angular/core';
 import { IPopoverFunctionControlEvent, IPopoverOverlay } from '@libs-ui/components-popover';
 import { IEmoji, IGroupEmoji } from './interfaces/emoji.interface';
 import * as i0 from "@angular/core";
+/**
+ * Component chọn Emoji (Emoji Picker) với tính năng tìm kiếm và phân loại
+ * Hỗ trợ hiển thị trong Popover hoàn chỉnh với lazy loading danh sách emoji
+ */
 export declare class LibsUiComponentsEmojiComponent implements AfterViewInit {
     private functionsControl;
     protected emojisCategories: import("@angular/core").WritableSignal<IGroupEmoji[]>;
@@ -15,14 +19,23 @@ export declare class LibsUiComponentsEmojiComponent implements AfterViewInit {
         dataView: Array<IEmoji>;
         allData: Array<IEmoji>;
     }>;
+    /** Cấu hình overlay cho Popover chứa Emoji Picker */
     readonly configPopover: import("@angular/core").InputSignalWithTransform<IPopoverOverlay, IPopoverOverlay | undefined>;
+    /** Sử dụng ng-content làm trigger thay vì icon mặc định */
     readonly isNgContent: import("@angular/core").InputSignal<boolean | undefined>;
+    /** Giá trị Z-index cho popup. Tự động offset +5 cho content. */
     readonly zIndex: import("@angular/core").InputSignalWithTransform<number, number | undefined>;
+    /** Chế độ căn lề cho Popover (start | center | end) */
     readonly modePopoverPosition: import("@angular/core").InputSignal<"start" | "center" | "end" | undefined>;
+    /** CSS class cho container của popup chọn emoji */
     readonly classPopup: import("@angular/core").InputSignalWithTransform<string, string | undefined>;
+    /** CSS class bổ sung cho trigger container */
     readonly classInclude: import("@angular/core").InputSignalWithTransform<string, string | undefined>;
+    /** CSS class cho icon trigger (mặc định: libs-ui-icon-add) */
     readonly classIconInclude: import("@angular/core").InputSignalWithTransform<string, string | undefined>;
+    /** Event emit khi người dùng chọn một emoji. Trả về ký tự emoji. */
     readonly outEventEmoji: import("@angular/core").OutputEmitterRef<string>;
+    /** Emit các functions điều khiển Popover (show/remove) */
     readonly outFunctionsControl: import("@angular/core").OutputEmitterRef<IPopoverFunctionControlEvent>;
     private readonly emojiRef;
     private readonly elementViewEmoji;

package/esm2022/emoji.component.mjs

@@ -7,6 +7,10 @@ import { TranslateModule } from '@ngx-translate/core';
 import { defaultConfigPopover, emojis } from './defines/emoji.define';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngx-translate/core";
+/**
+ * Component chọn Emoji (Emoji Picker) với tính năng tìm kiếm và phân loại
+ * Hỗ trợ hiển thị trong Popover hoàn chỉnh với lazy loading danh sách emoji
+ */
 export class LibsUiComponentsEmojiComponent {
     // #region PROPERTY
     functionsControl = signal(undefined);
@@ -14,15 +18,24 @@ export class LibsUiComponentsEmojiComponent {
     filter = signal({ page: 0, keySearch: '', groupSelected: 'Smileys & Emotion', perPage: 170 });
     dataEmojiView = signal({ dataView: [], allData: [] });
     // #region INPUT
+    /** Cấu hình overlay cho Popover chứa Emoji Picker */
     configPopover = input(defaultConfigPopover(), { transform: (value) => (value ? value : defaultConfigPopover()) });
+    /** Sử dụng ng-content làm trigger thay vì icon mặc định */
     isNgContent = input();
+    /** Giá trị Z-index cho popup. Tự động offset +5 cho content. */
     zIndex = input(0, { transform: (value) => value ?? 0 });
+    /** Chế độ căn lề cho Popover (start | center | end) */
     modePopoverPosition = input();
+    /** CSS class cho container của popup chọn emoji */
     classPopup = input('w-[290px] h-[245px]', { transform: (val) => val ?? 'w-[290px] h-[245px]' });
+    /** CSS class bổ sung cho trigger container */
     classInclude = input('', { transform: (val) => val ?? '' });
+    /** CSS class cho icon trigger (mặc định: libs-ui-icon-add) */
     classIconInclude = input('libs-ui-icon-add', { transform: (val) => val ?? 'libs-ui-icon-add' });
     // #region OUTPUT
+    /** Event emit khi người dùng chọn một emoji. Trả về ký tự emoji. */
     outEventEmoji = output();
+    /** Emit các functions điều khiển Popover (show/remove) */
     outFunctionsControl = output();
     /* VIEW CHILD */
     emojiRef = viewChild('emojiRef');
@@ -93,4 +106,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
             type: Component,
             args: [{ selector: 'libs_ui-components-emoji', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, imports: [TranslateModule, LibsUiComponentsInputsSearchComponent, LibsUiComponentsPopoverComponent, LibsUiComponentsScrollOverlayDirective], template: "<libs_ui-components-popover\n  [classInclude]=\"classInclude()\"\n  [config]=\"{\n    content: 'i18n_text_emoji',\n    zIndex: (zIndex() || 1200) + 4,\n  }\"\n  (outFunctionsControl)=\"handlerFunctionsControl($event)\">\n  <libs_ui-components-popover\n    type=\"other\"\n    mode=\"click-toggle\"\n    class=\"flex\"\n    [ignoreHiddenPopoverContentWhenMouseLeave]=\"true\"\n    [config]=\"configPopover()\"\n    [debugId]=\"'debug icon emoij'\"\n    (outFunctionsControl)=\"handlerFunctionsControl($event)\">\n    @if (!isNgContent()) {\n      <i class=\"before:!text-[16px] before:!text-[#6a7383] {{ classIconInclude() }}\"></i>\n    } @else {\n      <ng-content></ng-content>\n    }\n  </libs_ui-components-popover>\n</libs_ui-components-popover>\n<ng-template #emojiRef>\n  <div class=\"py-[10px] flex flex-col {{ classPopup() }}\">\n    <div class=\"mx-[10px] mb-[12px]\">\n      <div\n        class=\"flex\"\n        LibsUiComponentsScrollOverlayDirective>\n        @for (category of emojisCategories(); track category) {\n          <div\n            class=\"grow p-[4px] rounded-[4px] bg-[#ffffff] libs-ui-bg-list-hover\"\n            [class.libs-ui-bg-list-active]=\"filter().groupSelected === category.group_name\"\n            (click)=\"handlerChooseCategory($event, category)\">\n            <div class=\"mt-[1px] cursor-pointer text-[18px]\">\n              {{ category.iconGroup }}\n            </div>\n          </div>\n        }\n      </div>\n    </div>\n    <div class=\"mx-[10px] mb-[12px]\">\n      <libs_ui-components-inputs-search\n        [searchConfig]=\"{\n          placeholder: 'i18n_search',\n        }\"\n        [debounceTime]=\"0\"\n        (outSearch)=\"handlerSearchEmoji($event)\" />\n    </div>\n    <div class=\"h-full w-full relative\">\n      <div\n        #elementViewEmoji\n        class=\"w-full h-full px-[10px] absolute\"\n        LibsUiComponentsScrollOverlayDirective\n        (outScrollBottom)=\"handlerScrollBottom()\">\n        @if (dataEmojiView().dataView.length) {\n          @for (item of dataEmojiView().dataView; track $index) {\n            <!-- n\u1EBFu sau c\u00F3 y\u00EAu c\u00E2u hover hi\u1EC3n th\u1ECB tooltio th\u00EC b\u1ECF [ignoreShowPopover]=\"true\" -->\n            <span\n              LibsUiComponentsPopoverDirective\n              [ignoreShowPopover]=\"true\"\n              [config]=\"{ content: item.description, zIndex: (zIndex() || 1200) + 5 }\"\n              class=\"cursor-pointer flex shrink-0 h-fit m-[2px] float-left\"\n              (click)=\"handlerAddEmoji(item)\">\n              {{ item.emoji }}\n            </span>\n          }\n        } @else {\n          <div class=\"libs-ui-font-h5r text-[#9ca2ad] h-full w-full items-center justify-center\">\n            {{ 'i18n_no_result' | translate }}\n          </div>\n        }\n      </div>\n    </div>\n  </div>\n</ng-template>\n" }]
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emoji.component.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/inputs/emoji/src/emoji.component.ts","../../../../../../libs-ui/components/inputs/emoji/src/emoji.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectionStrategy, Component, effect, ElementRef, input, output, signal, TemplateRef, untracked, viewChild } from '@angular/core';\nimport { LibsUiComponentsInputsSearchComponent } from '@libs-ui/components-inputs-search';\nimport { IPopoverFunctionControlEvent, IPopoverOverlay, LibsUiComponentsPopoverComponent } from '@libs-ui/components-popover';\nimport { LibsUiComponentsScrollOverlayDirective } from '@libs-ui/components-scroll-overlay';\nimport { TYPE_TEMPLATE_REF } from '@libs-ui/interfaces-types';\nimport { deleteUnicode } from '@libs-ui/utils';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { defaultConfigPopover, emojis } from './defines/emoji.define';\nimport { IEmoji, IGroupEmoji } from './interfaces/emoji.interface';\n@Component({\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'libs_ui-components-emoji',\n  templateUrl: './emoji.component.html',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [TranslateModule, LibsUiComponentsInputsSearchComponent, LibsUiComponentsPopoverComponent, LibsUiComponentsScrollOverlayDirective],\n})\nexport class LibsUiComponentsEmojiComponent implements AfterViewInit {\n  // #region PROPERTY\n  private functionsControl = signal<IPopoverFunctionControlEvent | undefined>(undefined);\n\n  protected emojisCategories = signal<Array<IGroupEmoji>>(new Array<IGroupEmoji>());\n  protected filter = signal({ page: 0, keySearch: '', groupSelected: 'Smileys & Emotion', perPage: 170 });\n  protected dataEmojiView = signal<{ dataView: Array<IEmoji>; allData: Array<IEmoji> }>({ dataView: [], allData: [] });\n\n  // #region INPUT\n  readonly configPopover = input<IPopoverOverlay, IPopoverOverlay | undefined>(defaultConfigPopover(), { transform: (value) => (value ? value : defaultConfigPopover()) });\n  readonly isNgContent = input<boolean>();\n  readonly zIndex = input<number, number | undefined>(0, { transform: (value) => value ?? 0 });\n  readonly modePopoverPosition = input<'start' | 'center' | 'end' | undefined>();\n  readonly classPopup = input<string, string | undefined>('w-[290px] h-[245px]', { transform: (val) => val ?? 'w-[290px] h-[245px]' });\n  readonly classInclude = input<string, string | undefined>('', { transform: (val) => val ?? '' });\n  readonly classIconInclude = input<string, string | undefined>('libs-ui-icon-add', { transform: (val) => val ?? 'libs-ui-icon-add' });\n\n  // #region OUTPUT\n  readonly outEventEmoji = output<string>();\n  readonly outFunctionsControl = output<IPopoverFunctionControlEvent>();\n\n  /* VIEW CHILD */\n  private readonly emojiRef = viewChild<TemplateRef<TYPE_TEMPLATE_REF>>('emojiRef');\n  private readonly elementViewEmoji = viewChild<ElementRef<TYPE_TEMPLATE_REF>>('elementViewEmoji');\n\n  constructor() {\n    this.emojisCategories.set(\n      emojis().map((item) => ({\n        ...item,\n        iconGroup: item.emojis[0].emoji,\n        emojis: new Array<IEmoji>(),\n      }))\n    );\n\n    effect(() => {\n      if (this.zIndex()) {\n        untracked(() => {\n          this.configPopover().zIndex = this.zIndex() + 5;\n        });\n      }\n\n      if (this.modePopoverPosition() && this.configPopover().position) {\n        untracked(() => {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (this.configPopover() as any).position.mode = this.modePopoverPosition();\n        });\n      }\n\n      if (this.configPopover()) {\n        this.configPopover().template = this.emojiRef();\n      }\n    });\n  }\n\n  ngAfterViewInit(): void {\n    this.getDataView();\n  }\n\n  /* FUNCTIONS */\n  protected async handlerAddEmoji(data: IEmoji) {\n    this.outEventEmoji.emit(data.emoji);\n  }\n\n  protected async handlerFunctionsControl(event: IPopoverFunctionControlEvent) {\n    this.functionsControl.set(event);\n    this.outFunctionsControl.emit(event);\n  }\n\n  public get FunctionsControl(): IPopoverFunctionControlEvent | undefined {\n    return this.functionsControl();\n  }\n\n  protected async handlerChooseCategory(event: Event, category: IGroupEmoji) {\n    event.stopPropagation();\n    this.filter.update((data) => ({ ...data, page: 0, groupSelected: category.group_name }));\n    this.getDataView();\n    this.elementViewEmoji()?.nativeElement.scroll({ top: 0 });\n  }\n\n  protected async handlerSearchEmoji(keySearch: string) {\n    this.filter.update((data) => ({ ...data, page: 0, keySearch: keySearch.trim() }));\n    this.getDataView();\n    this.elementViewEmoji()?.nativeElement.scroll({ top: 0 });\n  }\n\n  protected handlerScrollBottom() {\n    this.filter.update((data) => ({ ...data, page: data.page + 1 }));\n    this.getDataView();\n  }\n\n  private getDataView() {\n    const emojiByGroup = emojis().find((item) => item.group_name === this.filter().groupSelected) as IGroupEmoji;\n    const emojiMatch = emojiByGroup.emojis.filter((item) => deleteUnicode(item.description).toLocaleLowerCase().includes(deleteUnicode(this.filter().keySearch.toLocaleLowerCase())));\n\n    const { page, perPage } = this.filter();\n    const dataInPage = emojiMatch.slice(page * perPage, page * perPage + perPage);\n\n    this.dataEmojiView.update((item) => ({ ...item, allData: emojiMatch, dataView: page ? [...item.dataView, ...dataInPage] : dataInPage }));\n  }\n}\n","<libs_ui-components-popover\n  [classInclude]=\"classInclude()\"\n  [config]=\"{\n    content: 'i18n_text_emoji',\n    zIndex: (zIndex() || 1200) + 4,\n  }\"\n  (outFunctionsControl)=\"handlerFunctionsControl($event)\">\n  <libs_ui-components-popover\n    type=\"other\"\n    mode=\"click-toggle\"\n    class=\"flex\"\n    [ignoreHiddenPopoverContentWhenMouseLeave]=\"true\"\n    [config]=\"configPopover()\"\n    [debugId]=\"'debug icon emoij'\"\n    (outFunctionsControl)=\"handlerFunctionsControl($event)\">\n    @if (!isNgContent()) {\n      <i class=\"before:!text-[16px] before:!text-[#6a7383] {{ classIconInclude() }}\"></i>\n    } @else {\n      <ng-content></ng-content>\n    }\n  </libs_ui-components-popover>\n</libs_ui-components-popover>\n<ng-template #emojiRef>\n  <div class=\"py-[10px] flex flex-col {{ classPopup() }}\">\n    <div class=\"mx-[10px] mb-[12px]\">\n      <div\n        class=\"flex\"\n        LibsUiComponentsScrollOverlayDirective>\n        @for (category of emojisCategories(); track category) {\n          <div\n            class=\"grow p-[4px] rounded-[4px] bg-[#ffffff] libs-ui-bg-list-hover\"\n            [class.libs-ui-bg-list-active]=\"filter().groupSelected === category.group_name\"\n            (click)=\"handlerChooseCategory($event, category)\">\n            <div class=\"mt-[1px] cursor-pointer text-[18px]\">\n              {{ category.iconGroup }}\n            </div>\n          </div>\n        }\n      </div>\n    </div>\n    <div class=\"mx-[10px] mb-[12px]\">\n      <libs_ui-components-inputs-search\n        [searchConfig]=\"{\n          placeholder: 'i18n_search',\n        }\"\n        [debounceTime]=\"0\"\n        (outSearch)=\"handlerSearchEmoji($event)\" />\n    </div>\n    <div class=\"h-full w-full relative\">\n      <div\n        #elementViewEmoji\n        class=\"w-full h-full px-[10px] absolute\"\n        LibsUiComponentsScrollOverlayDirective\n        (outScrollBottom)=\"handlerScrollBottom()\">\n        @if (dataEmojiView().dataView.length) {\n          @for (item of dataEmojiView().dataView; track $index) {\n            <!-- nếu sau có yêu câu hover hiển thị tooltio thì bỏ [ignoreShowPopover]=\"true\" -->\n            <span\n              LibsUiComponentsPopoverDirective\n              [ignoreShowPopover]=\"true\"\n              [config]=\"{ content: item.description, zIndex: (zIndex() || 1200) + 5 }\"\n              class=\"cursor-pointer flex shrink-0 h-fit m-[2px] float-left\"\n              (click)=\"handlerAddEmoji(item)\">\n              {{ item.emoji }}\n            </span>\n          }\n        } @else {\n          <div class=\"libs-ui-font-h5r text-[#9ca2ad] h-full w-full items-center justify-center\">\n            {{ 'i18n_no_result' | translate }}\n          </div>\n        }\n      </div>\n    </div>\n  </div>\n</ng-template>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"emoji.component.js","sourceRoot":"","sources":["../../../../../../libs-ui/components/inputs/emoji/src/emoji.component.ts","../../../../../../libs-ui/components/inputs/emoji/src/emoji.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectionStrategy, Component, effect, ElementRef, input, output, signal, TemplateRef, untracked, viewChild } from '@angular/core';\nimport { LibsUiComponentsInputsSearchComponent } from '@libs-ui/components-inputs-search';\nimport { IPopoverFunctionControlEvent, IPopoverOverlay, LibsUiComponentsPopoverComponent } from '@libs-ui/components-popover';\nimport { LibsUiComponentsScrollOverlayDirective } from '@libs-ui/components-scroll-overlay';\nimport { TYPE_TEMPLATE_REF } from '@libs-ui/interfaces-types';\nimport { deleteUnicode } from '@libs-ui/utils';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { defaultConfigPopover, emojis } from './defines/emoji.define';\nimport { IEmoji, IGroupEmoji } from './interfaces/emoji.interface';\n/**\n * Component chọn Emoji (Emoji Picker) với tính năng tìm kiếm và phân loại\n * Hỗ trợ hiển thị trong Popover hoàn chỉnh với lazy loading danh sách emoji\n */\n@Component({\n  // eslint-disable-next-line @angular-eslint/component-selector\n  selector: 'libs_ui-components-emoji',\n  templateUrl: './emoji.component.html',\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  imports: [TranslateModule, LibsUiComponentsInputsSearchComponent, LibsUiComponentsPopoverComponent, LibsUiComponentsScrollOverlayDirective],\n})\nexport class LibsUiComponentsEmojiComponent implements AfterViewInit {\n  // #region PROPERTY\n  private functionsControl = signal<IPopoverFunctionControlEvent | undefined>(undefined);\n\n  protected emojisCategories = signal<Array<IGroupEmoji>>(new Array<IGroupEmoji>());\n  protected filter = signal({ page: 0, keySearch: '', groupSelected: 'Smileys & Emotion', perPage: 170 });\n  protected dataEmojiView = signal<{ dataView: Array<IEmoji>; allData: Array<IEmoji> }>({ dataView: [], allData: [] });\n\n  // #region INPUT\n  /** Cấu hình overlay cho Popover chứa Emoji Picker */\n  readonly configPopover = input<IPopoverOverlay, IPopoverOverlay | undefined>(defaultConfigPopover(), { transform: (value) => (value ? value : defaultConfigPopover()) });\n\n  /** Sử dụng ng-content làm trigger thay vì icon mặc định */\n  readonly isNgContent = input<boolean>();\n\n  /** Giá trị Z-index cho popup. Tự động offset +5 cho content. */\n  readonly zIndex = input<number, number | undefined>(0, { transform: (value) => value ?? 0 });\n\n  /** Chế độ căn lề cho Popover (start | center | end) */\n  readonly modePopoverPosition = input<'start' | 'center' | 'end' | undefined>();\n\n  /** CSS class cho container của popup chọn emoji */\n  readonly classPopup = input<string, string | undefined>('w-[290px] h-[245px]', { transform: (val) => val ?? 'w-[290px] h-[245px]' });\n\n  /** CSS class bổ sung cho trigger container */\n  readonly classInclude = input<string, string | undefined>('', { transform: (val) => val ?? '' });\n\n  /** CSS class cho icon trigger (mặc định: libs-ui-icon-add) */\n  readonly classIconInclude = input<string, string | undefined>('libs-ui-icon-add', { transform: (val) => val ?? 'libs-ui-icon-add' });\n\n  // #region OUTPUT\n  /** Event emit khi người dùng chọn một emoji. Trả về ký tự emoji. */\n  readonly outEventEmoji = output<string>();\n\n  /** Emit các functions điều khiển Popover (show/remove) */\n  readonly outFunctionsControl = output<IPopoverFunctionControlEvent>();\n\n  /* VIEW CHILD */\n  private readonly emojiRef = viewChild<TemplateRef<TYPE_TEMPLATE_REF>>('emojiRef');\n  private readonly elementViewEmoji = viewChild<ElementRef<TYPE_TEMPLATE_REF>>('elementViewEmoji');\n\n  constructor() {\n    this.emojisCategories.set(\n      emojis().map((item) => ({\n        ...item,\n        iconGroup: item.emojis[0].emoji,\n        emojis: new Array<IEmoji>(),\n      }))\n    );\n\n    effect(() => {\n      if (this.zIndex()) {\n        untracked(() => {\n          this.configPopover().zIndex = this.zIndex() + 5;\n        });\n      }\n\n      if (this.modePopoverPosition() && this.configPopover().position) {\n        untracked(() => {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (this.configPopover() as any).position.mode = this.modePopoverPosition();\n        });\n      }\n\n      if (this.configPopover()) {\n        this.configPopover().template = this.emojiRef();\n      }\n    });\n  }\n\n  ngAfterViewInit(): void {\n    this.getDataView();\n  }\n\n  /* FUNCTIONS */\n  protected async handlerAddEmoji(data: IEmoji) {\n    this.outEventEmoji.emit(data.emoji);\n  }\n\n  protected async handlerFunctionsControl(event: IPopoverFunctionControlEvent) {\n    this.functionsControl.set(event);\n    this.outFunctionsControl.emit(event);\n  }\n\n  public get FunctionsControl(): IPopoverFunctionControlEvent | undefined {\n    return this.functionsControl();\n  }\n\n  protected async handlerChooseCategory(event: Event, category: IGroupEmoji) {\n    event.stopPropagation();\n    this.filter.update((data) => ({ ...data, page: 0, groupSelected: category.group_name }));\n    this.getDataView();\n    this.elementViewEmoji()?.nativeElement.scroll({ top: 0 });\n  }\n\n  protected async handlerSearchEmoji(keySearch: string) {\n    this.filter.update((data) => ({ ...data, page: 0, keySearch: keySearch.trim() }));\n    this.getDataView();\n    this.elementViewEmoji()?.nativeElement.scroll({ top: 0 });\n  }\n\n  protected handlerScrollBottom() {\n    this.filter.update((data) => ({ ...data, page: data.page + 1 }));\n    this.getDataView();\n  }\n\n  private getDataView() {\n    const emojiByGroup = emojis().find((item) => item.group_name === this.filter().groupSelected) as IGroupEmoji;\n    const emojiMatch = emojiByGroup.emojis.filter((item) => deleteUnicode(item.description).toLocaleLowerCase().includes(deleteUnicode(this.filter().keySearch.toLocaleLowerCase())));\n\n    const { page, perPage } = this.filter();\n    const dataInPage = emojiMatch.slice(page * perPage, page * perPage + perPage);\n\n    this.dataEmojiView.update((item) => ({ ...item, allData: emojiMatch, dataView: page ? [...item.dataView, ...dataInPage] : dataInPage }));\n  }\n}\n","<libs_ui-components-popover\n  [classInclude]=\"classInclude()\"\n  [config]=\"{\n    content: 'i18n_text_emoji',\n    zIndex: (zIndex() || 1200) + 4,\n  }\"\n  (outFunctionsControl)=\"handlerFunctionsControl($event)\">\n  <libs_ui-components-popover\n    type=\"other\"\n    mode=\"click-toggle\"\n    class=\"flex\"\n    [ignoreHiddenPopoverContentWhenMouseLeave]=\"true\"\n    [config]=\"configPopover()\"\n    [debugId]=\"'debug icon emoij'\"\n    (outFunctionsControl)=\"handlerFunctionsControl($event)\">\n    @if (!isNgContent()) {\n      <i class=\"before:!text-[16px] before:!text-[#6a7383] {{ classIconInclude() }}\"></i>\n    } @else {\n      <ng-content></ng-content>\n    }\n  </libs_ui-components-popover>\n</libs_ui-components-popover>\n<ng-template #emojiRef>\n  <div class=\"py-[10px] flex flex-col {{ classPopup() }}\">\n    <div class=\"mx-[10px] mb-[12px]\">\n      <div\n        class=\"flex\"\n        LibsUiComponentsScrollOverlayDirective>\n        @for (category of emojisCategories(); track category) {\n          <div\n            class=\"grow p-[4px] rounded-[4px] bg-[#ffffff] libs-ui-bg-list-hover\"\n            [class.libs-ui-bg-list-active]=\"filter().groupSelected === category.group_name\"\n            (click)=\"handlerChooseCategory($event, category)\">\n            <div class=\"mt-[1px] cursor-pointer text-[18px]\">\n              {{ category.iconGroup }}\n            </div>\n          </div>\n        }\n      </div>\n    </div>\n    <div class=\"mx-[10px] mb-[12px]\">\n      <libs_ui-components-inputs-search\n        [searchConfig]=\"{\n          placeholder: 'i18n_search',\n        }\"\n        [debounceTime]=\"0\"\n        (outSearch)=\"handlerSearchEmoji($event)\" />\n    </div>\n    <div class=\"h-full w-full relative\">\n      <div\n        #elementViewEmoji\n        class=\"w-full h-full px-[10px] absolute\"\n        LibsUiComponentsScrollOverlayDirective\n        (outScrollBottom)=\"handlerScrollBottom()\">\n        @if (dataEmojiView().dataView.length) {\n          @for (item of dataEmojiView().dataView; track $index) {\n            <!-- nếu sau có yêu câu hover hiển thị tooltio thì bỏ [ignoreShowPopover]=\"true\" -->\n            <span\n              LibsUiComponentsPopoverDirective\n              [ignoreShowPopover]=\"true\"\n              [config]=\"{ content: item.description, zIndex: (zIndex() || 1200) + 5 }\"\n              class=\"cursor-pointer flex shrink-0 h-fit m-[2px] float-left\"\n              (click)=\"handlerAddEmoji(item)\">\n              {{ item.emoji }}\n            </span>\n          }\n        } @else {\n          <div class=\"libs-ui-font-h5r text-[#9ca2ad] h-full w-full items-center justify-center\">\n            {{ 'i18n_no_result' | translate }}\n          </div>\n        }\n      </div>\n    </div>\n  </div>\n</ng-template>\n"]}

package/esm2022/interfaces/emoji.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1vamkuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy11aS9jb21wb25lbnRzL2lucHV0cy9lbW9qaS9zcmMvaW50ZXJmYWNlcy9lbW9qaS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgSUdyb3VwRW1vamkge1xuICBncm91cF9uYW1lOiBzdHJpbmc7XG4gIGVtb2ppczogQXJyYXk8SUVtb2ppPjtcbiAgaWNvbkdyb3VwPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElFbW9qaSB7XG4gIGVtb2ppOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIGNhdGVnb3J5OiBzdHJpbmc7XG4gIGRpc3BsYXk/OiBib29sZWFuO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1vamkuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy11aS9jb21wb25lbnRzL2lucHV0cy9lbW9qaS9zcmMvaW50ZXJmYWNlcy9lbW9qaS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBUaMO0bmcgdGluIG5ow7NtIEVtb2ppICovXG5leHBvcnQgaW50ZXJmYWNlIElHcm91cEVtb2ppIHtcbiAgLyoqIFTDqm4gbmjDs20gKHZkOiBTbWlsZXlzICYgRW1vdGlvbikgKi9cbiAgZ3JvdXBfbmFtZTogc3RyaW5nO1xuICAvKiogRGFuaCBzw6FjaCBlbW9qaSB0cm9uZyBuaMOzbSAqL1xuICBlbW9qaXM6IEFycmF5PElFbW9qaT47XG4gIC8qKiBLw70gdOG7sSDEkeG6oWkgZGnhu4duIGNobyBuaMOzbSAodGjGsOG7nW5nIGzDoCBlbW9qaSDEkeG6p3UgdGnDqm4pICovXG4gIGljb25Hcm91cD86IHN0cmluZztcbn1cblxuLyoqIENoaSB0aeG6v3QgbeG7mXQgRW1vamkgKi9cbmV4cG9ydCBpbnRlcmZhY2UgSUVtb2ppIHtcbiAgLyoqIEvDvSB04buxIGVtb2ppIHRo4buxYyB04bq/ICovXG4gIGVtb2ppOiBzdHJpbmc7XG4gIC8qKiBNw7QgdOG6oyBlbW9qaSAqL1xuICBkZXNjcmlwdGlvbjogc3RyaW5nO1xuICAvKiogRGFuaCBt4bulYyBj4bunYSBlbW9qaSAqL1xuICBjYXRlZ29yeTogc3RyaW5nO1xuICAvKiogVHLhuqFuZyB0aMOhaSBoaeG7g24gdGjhu4sgKi9cbiAgZGlzcGxheT86IGJvb2xlYW47XG59XG4iXX0=

package/fesm2022/libs-ui-components-inputs-emoji.mjs

@@ -1805,6 +1805,10 @@ const emojis = () => [
     },
 ];
 
+/**
+ * Component chọn Emoji (Emoji Picker) với tính năng tìm kiếm và phân loại
+ * Hỗ trợ hiển thị trong Popover hoàn chỉnh với lazy loading danh sách emoji
+ */
 class LibsUiComponentsEmojiComponent {
     // #region PROPERTY
     functionsControl = signal(undefined);
@@ -1812,15 +1816,24 @@ class LibsUiComponentsEmojiComponent {
     filter = signal({ page: 0, keySearch: '', groupSelected: 'Smileys & Emotion', perPage: 170 });
     dataEmojiView = signal({ dataView: [], allData: [] });
     // #region INPUT
+    /** Cấu hình overlay cho Popover chứa Emoji Picker */
     configPopover = input(defaultConfigPopover(), { transform: (value) => (value ? value : defaultConfigPopover()) });
+    /** Sử dụng ng-content làm trigger thay vì icon mặc định */
     isNgContent = input();
+    /** Giá trị Z-index cho popup. Tự động offset +5 cho content. */
     zIndex = input(0, { transform: (value) => value ?? 0 });
+    /** Chế độ căn lề cho Popover (start | center | end) */
     modePopoverPosition = input();
+    /** CSS class cho container của popup chọn emoji */
     classPopup = input('w-[290px] h-[245px]', { transform: (val) => val ?? 'w-[290px] h-[245px]' });
+    /** CSS class bổ sung cho trigger container */
     classInclude = input('', { transform: (val) => val ?? '' });
+    /** CSS class cho icon trigger (mặc định: libs-ui-icon-add) */
     classIconInclude = input('libs-ui-icon-add', { transform: (val) => val ?? 'libs-ui-icon-add' });
     // #region OUTPUT
+    /** Event emit khi người dùng chọn một emoji. Trả về ký tự emoji. */
     outEventEmoji = output();
+    /** Emit các functions điều khiển Popover (show/remove) */
     outFunctionsControl = output();
     /* VIEW CHILD */
     emojiRef = viewChild('emojiRef');