@worktile/theia 14.1.8 → 14.2.0

package/esm2020/components/listbox/listbox.mjs

@@ -0,0 +1,341 @@
+import { DOWN_ARROW, LEFT_ARROW, RIGHT_ARROW, UP_ARROW } from '@angular/cdk/keycodes';
+import { Optional, SkipSelf } from '@angular/core';
+import { ContentChildren, Directive, EventEmitter, HostBinding, Inject, Input, Output } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { THE_LISTBOX_TOKEN, THE_LISTBOX_PARENT_OPTION_TOKEN, THE_LISTBOX_PARENT_GROUP_TOKEN } from './listbox.type';
+import * as i0 from "@angular/core";
+export class TheListboxOptionDirective {
+    constructor(parentOption, parentGroup, elementRef) {
+        this.parentOption = parentOption;
+        this.parentGroup = parentGroup;
+        this.elementRef = elementRef;
+        this._active = false;
+        this.className = 'the-listbox-option';
+    }
+    get hasChild() {
+        return this._options.length > 0;
+    }
+    get firstChild() {
+        return this._options.first;
+    }
+    ngOnInit() { }
+    ngAfterContentInit() { }
+    getGroups() {
+        const groups = [];
+        this._options.forEach(option => {
+            if (option.parentOption && option.parentOption === this && !groups.includes(option.parentGroup)) {
+                groups.push(option.parentGroup);
+            }
+        });
+        return groups;
+    }
+    setActive(active) {
+        this._active = active;
+        if (active) {
+            this.elementRef.nativeElement.classList.add('active');
+        }
+        else {
+            this.elementRef.nativeElement.classList.remove('active');
+        }
+    }
+    getActive() {
+        return this._active;
+    }
+}
+TheListboxOptionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: TheListboxOptionDirective, deps: [{ token: THE_LISTBOX_PARENT_OPTION_TOKEN, optional: true, skipSelf: true }, { token: THE_LISTBOX_PARENT_GROUP_TOKEN }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+TheListboxOptionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: TheListboxOptionDirective, selector: "[theListboxOpton]", host: { properties: { "class": "this.className" } }, providers: [
+        {
+            provide: THE_LISTBOX_PARENT_OPTION_TOKEN,
+            useExisting: TheListboxOptionDirective
+        }
+    ], queries: [{ propertyName: "_options", predicate: TheListboxOptionDirective, descendants: true }], exportAs: ["theListboxOpton"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: TheListboxOptionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[theListboxOpton]',
+                    exportAs: 'theListboxOpton',
+                    providers: [
+                        {
+                            provide: THE_LISTBOX_PARENT_OPTION_TOKEN,
+                            useExisting: TheListboxOptionDirective
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: TheListboxOptionDirective, decorators: [{
+                    type: Inject,
+                    args: [THE_LISTBOX_PARENT_OPTION_TOKEN]
+                }, {
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: TheListboxGroupDirective, decorators: [{
+                    type: Inject,
+                    args: [THE_LISTBOX_PARENT_GROUP_TOKEN]
+                }] }, { type: i0.ElementRef }]; }, propDecorators: { className: [{
+                type: HostBinding,
+                args: ['class']
+            }], _options: [{
+                type: ContentChildren,
+                args: [TheListboxOptionDirective, { descendants: true }]
+            }] } });
+export class TheListboxGroupDirective {
+    constructor(parentOption, theListBox) {
+        this.parentOption = parentOption;
+        this.theListBox = theListBox;
+        this.className = 'the-listbox-group';
+        this.options = [];
+        /**
+         * 大于 1 表示水平分组，小于等于 1 表示垂直分组
+         */
+        this.horizontalColumn = 1;
+    }
+    ngOnInit() { }
+    ngAfterContentInit() {
+        this.filterOptions();
+    }
+    filterOptions() {
+        this.options = this._options.filter(_option => {
+            if (_option.parentGroup && _option.parentGroup === this) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    getSiblingGroups() {
+        if (this.parentOption) {
+            return this.parentOption.getGroups();
+        }
+        else {
+            return this.theListBox.groups;
+        }
+    }
+    getFirst() {
+        return this.options[0];
+    }
+    getLast() {
+        return this.options[this.options.length - 1];
+    }
+}
+TheListboxGroupDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: TheListboxGroupDirective, deps: [{ token: THE_LISTBOX_PARENT_OPTION_TOKEN, optional: true, skipSelf: true }, { token: THE_LISTBOX_TOKEN }], target: i0.ɵɵFactoryTarget.Directive });
+TheListboxGroupDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: TheListboxGroupDirective, selector: "[theListboxGroup]", inputs: { horizontalColumn: "horizontalColumn" }, host: { properties: { "class": "this.className" } }, providers: [
+        {
+            provide: THE_LISTBOX_PARENT_GROUP_TOKEN,
+            useExisting: TheListboxGroupDirective
+        }
+    ], queries: [{ propertyName: "_options", predicate: TheListboxOptionDirective, descendants: true }], exportAs: ["theListboxGroup"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: TheListboxGroupDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[theListboxGroup]',
+                    exportAs: 'theListboxGroup',
+                    providers: [
+                        {
+                            provide: THE_LISTBOX_PARENT_GROUP_TOKEN,
+                            useExisting: TheListboxGroupDirective
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: TheListboxOptionDirective, decorators: [{
+                    type: Inject,
+                    args: [THE_LISTBOX_PARENT_OPTION_TOKEN]
+                }, {
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: TheListboxDirective, decorators: [{
+                    type: Inject,
+                    args: [THE_LISTBOX_TOKEN]
+                }] }]; }, propDecorators: { className: [{
+                type: HostBinding,
+                args: ['class']
+            }], _options: [{
+                type: ContentChildren,
+                args: [TheListboxOptionDirective, { descendants: true }]
+            }], horizontalColumn: [{
+                type: Input
+            }] } });
+export class TheListboxDirective {
+    constructor(ngZone, elementRef) {
+        this.ngZone = ngZone;
+        this.elementRef = elementRef;
+        this.className = 'the-listbox-container';
+        this.groups = [];
+        this.theActiveOptionChange = new EventEmitter();
+    }
+    ngOnInit() { }
+    ngAfterContentInit() {
+        this.filterGroups();
+        if (this.groups.length > 0) {
+            this.setActiveItem(null, this.groups[0].getFirst(), 'init');
+        }
+        this._optionChangesSubscription = this._groups.changes.subscribe(() => {
+            this.filterGroups();
+            this.setActiveItem(null, this.groups[0].getFirst(), 'init');
+        });
+        this.ngZone.runOutsideAngular(() => {
+            this._keyboardSubscription = fromEvent(this.keyboardContainer || this.elementRef.nativeElement, 'keydown').subscribe(event => {
+                this.handleKeydown(event);
+            });
+        });
+    }
+    filterGroups() {
+        this.groups = this._groups.filter(group => {
+            if (!group.parentOption) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    handleKeydown(event) {
+        const { keyCode } = event;
+        switch (keyCode) {
+            case DOWN_ARROW:
+                this.setNextLineActive();
+                event.preventDefault();
+                break;
+            case UP_ARROW:
+                this.setPreviousLineActive();
+                event.preventDefault();
+                break;
+            case RIGHT_ARROW:
+                this.setNextItemActive();
+                event.preventDefault();
+                break;
+            case LEFT_ARROW:
+                this.setPreviousItemActive();
+                event.preventDefault();
+                break;
+        }
+    }
+    /**
+     * ←
+     */
+    setPreviousItemActive() {
+        if (this.activeOption.parentOption) {
+            this.setActiveItem(this.activeOption, this.activeOption.parentOption, 'parent');
+        }
+        else {
+            const groupOptions = this.activeOption.parentGroup.options;
+            let optionIndex = groupOptions.indexOf(this.activeOption);
+            let newOptionIndex = optionIndex - 1;
+            if (newOptionIndex >= 0) {
+                this.setActiveItem(this.activeOption, groupOptions[newOptionIndex], 'turn');
+            }
+            else {
+                this.enterPreviousGroup();
+            }
+        }
+    }
+    /**
+     * ↓ 键
+     */
+    setNextLineActive() {
+        const groupOptions = this.activeOption.parentGroup.options;
+        let optionIndex = groupOptions.indexOf(this.activeOption);
+        let newOptionIndex = optionIndex + this.activeOption.parentGroup.horizontalColumn;
+        if (newOptionIndex <= groupOptions.length - 1) {
+            this.setActiveItem(this.activeOption, groupOptions[newOptionIndex], 'turn');
+        }
+        else {
+            this.enterNextGroup();
+        }
+    }
+    /**
+     * → 键
+     */
+    setNextItemActive() {
+        if (this.activeOption.hasChild) {
+            this.setActiveItem(this.activeOption, this.activeOption.firstChild, 'child');
+        }
+        else {
+            const groupOptions = this.activeOption.parentGroup.options;
+            let optionIndex = groupOptions.indexOf(this.activeOption);
+            let newOptionIndex = optionIndex + 1;
+            if (newOptionIndex <= groupOptions.length - 1) {
+                this.setActiveItem(this.activeOption, groupOptions[newOptionIndex], 'turn');
+            }
+            else {
+                this.enterNextGroup();
+            }
+        }
+    }
+    /**
+     * ↑ 键
+     */
+    setPreviousLineActive() {
+        const groupOptions = this.activeOption.parentGroup.options;
+        let optionIndex = groupOptions.indexOf(this.activeOption);
+        let newOptionIndex = optionIndex - this.activeOption.parentGroup.horizontalColumn;
+        if (newOptionIndex >= 0) {
+            this.setActiveItem(this.activeOption, groupOptions[newOptionIndex], 'turn');
+        }
+        else {
+            this.enterPreviousGroup();
+        }
+    }
+    enterNextGroup() {
+        const groups = this.activeOption.parentGroup.getSiblingGroups();
+        const groupIndex = groups.indexOf(this.activeOption.parentGroup);
+        let newGroupIndex = groupIndex + 1;
+        if (newGroupIndex > groups.length - 1) {
+            newGroupIndex = 0;
+        }
+        this.setActiveItem(this.activeOption, groups[newGroupIndex].getFirst(), 'turn');
+    }
+    enterPreviousGroup() {
+        const groups = this.activeOption.parentGroup.getSiblingGroups();
+        const groupIndex = groups.indexOf(this.activeOption.parentGroup);
+        let newGroupIndex = groupIndex - 1;
+        if (newGroupIndex < 0) {
+            newGroupIndex = groups.length - 1;
+        }
+        this.setActiveItem(this.activeOption, groups[newGroupIndex].getLast(), 'turn');
+    }
+    setActiveItem(previous, option, type) {
+        if (previous) {
+            previous.setActive(false);
+        }
+        option.setActive(true);
+        this.activeOption = option;
+        this.theActiveOptionChange.emit({ option, type });
+    }
+    ngOnDestroy() {
+        this._optionChangesSubscription.unsubscribe();
+        this._keyboardSubscription.unsubscribe();
+    }
+}
+TheListboxDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: TheListboxDirective, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+TheListboxDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: TheListboxDirective, selector: "[theListBox]", inputs: { keyboardContainer: "keyboardContainer" }, outputs: { theActiveOptionChange: "theActiveOptionChange" }, host: { properties: { "class": "this.className" } }, providers: [
+        {
+            provide: THE_LISTBOX_TOKEN,
+            useExisting: TheListboxDirective
+        }
+    ], queries: [{ propertyName: "_groups", predicate: TheListboxGroupDirective, descendants: true }], exportAs: ["theListBox"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: TheListboxDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[theListBox]',
+                    exportAs: 'theListBox',
+                    providers: [
+                        {
+                            provide: THE_LISTBOX_TOKEN,
+                            useExisting: TheListboxDirective
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }]; }, propDecorators: { className: [{
+                type: HostBinding,
+                args: ['class']
+            }], _groups: [{
+                type: ContentChildren,
+                args: [TheListboxGroupDirective, { descendants: true }]
+            }], keyboardContainer: [{
+                type: Input
+            }], theActiveOptionChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"listbox.js","sourceRoot":"","sources":["../../../../../packages/src/components/listbox/listbox.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOWN_ARROW, LEFT_ARROW, RIGHT_ARROW, UP_ARROW } from '@angular/cdk/keycodes';\nimport { NgZone, Optional, SkipSelf } from '@angular/core';\nimport {\n    AfterContentInit,\n    ContentChildren,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    HostBinding,\n    Inject,\n    Input,\n    OnDestroy,\n    OnInit,\n    Output,\n    QueryList\n} from '@angular/core';\nimport { fromEvent } from 'rxjs';\nimport { Subscription } from 'rxjs/internal/Subscription';\nimport {\n    TheListboxChangeEventType,\n    THE_LISTBOX_TOKEN,\n    THE_LISTBOX_PARENT_OPTION_TOKEN,\n    THE_LISTBOX_PARENT_GROUP_TOKEN\n} from './listbox.type';\n\n@Directive({\n    selector: '[theListboxOpton]',\n    exportAs: 'theListboxOpton',\n    providers: [\n        {\n            provide: THE_LISTBOX_PARENT_OPTION_TOKEN,\n            useExisting: TheListboxOptionDirective\n        }\n    ]\n})\nexport class TheListboxOptionDirective implements OnInit, AfterContentInit {\n    private _active = false;\n\n    @HostBinding('class') className = 'the-listbox-option';\n\n    @ContentChildren(TheListboxOptionDirective, { descendants: true }) public _options: QueryList<TheListboxOptionDirective>;\n\n    get hasChild() {\n        return this._options.length > 0;\n    }\n\n    get firstChild() {\n        return this._options.first;\n    }\n\n    constructor(\n        @Inject(THE_LISTBOX_PARENT_OPTION_TOKEN) @Optional() @SkipSelf() public parentOption: TheListboxOptionDirective,\n        @Inject(THE_LISTBOX_PARENT_GROUP_TOKEN) public parentGroup: TheListboxGroupDirective,\n        private elementRef: ElementRef<HTMLElement>\n    ) {}\n\n    ngOnInit(): void {}\n\n    ngAfterContentInit(): void {}\n\n    getGroups() {\n        const groups: TheListboxGroupDirective[] = [];\n        this._options.forEach(option => {\n            if (option.parentOption && option.parentOption === this && !groups.includes(option.parentGroup)) {\n                groups.push(option.parentGroup);\n            }\n        });\n        return groups;\n    }\n\n    setActive(active: boolean) {\n        this._active = active;\n        if (active) {\n            this.elementRef.nativeElement.classList.add('active');\n        } else {\n            this.elementRef.nativeElement.classList.remove('active');\n        }\n    }\n\n    getActive() {\n        return this._active;\n    }\n}\n\n@Directive({\n    selector: '[theListboxGroup]',\n    exportAs: 'theListboxGroup',\n    providers: [\n        {\n            provide: THE_LISTBOX_PARENT_GROUP_TOKEN,\n            useExisting: TheListboxGroupDirective\n        }\n    ]\n})\nexport class TheListboxGroupDirective implements OnInit, AfterContentInit {\n    @HostBinding('class') className = 'the-listbox-group';\n\n    options: TheListboxOptionDirective[] = [];\n\n    @ContentChildren(TheListboxOptionDirective, { descendants: true }) public _options: QueryList<TheListboxOptionDirective>;\n\n    /**\n     * 大于 1 表示水平分组，小于等于 1 表示垂直分组\n     */\n    @Input() horizontalColumn = 1;\n\n    constructor(\n        @Inject(THE_LISTBOX_PARENT_OPTION_TOKEN) @Optional() @SkipSelf() public parentOption: TheListboxOptionDirective,\n        @Inject(THE_LISTBOX_TOKEN) public theListBox: TheListboxDirective\n    ) {}\n\n    ngOnInit(): void {}\n\n    ngAfterContentInit(): void {\n        this.filterOptions();\n    }\n\n    filterOptions() {\n        this.options = this._options.filter(_option => {\n            if (_option.parentGroup && _option.parentGroup === this) {\n                return true;\n            } else {\n                return false;\n            }\n        });\n    }\n\n    getSiblingGroups() {\n        if (this.parentOption) {\n            return this.parentOption.getGroups();\n        } else {\n            return this.theListBox.groups;\n        }\n    }\n\n    getFirst() {\n        return this.options[0];\n    }\n\n    getLast() {\n        return this.options[this.options.length - 1];\n    }\n}\n\n@Directive({\n    selector: '[theListBox]',\n    exportAs: 'theListBox',\n    providers: [\n        {\n            provide: THE_LISTBOX_TOKEN,\n            useExisting: TheListboxDirective\n        }\n    ]\n})\nexport class TheListboxDirective implements OnInit, AfterContentInit, OnDestroy {\n    @HostBinding('class') className = 'the-listbox-container';\n\n    private _optionChangesSubscription: Subscription;\n\n    private _keyboardSubscription: Subscription;\n\n    public activeOption: TheListboxOptionDirective;\n\n    public groups: TheListboxGroupDirective[] = [];\n\n    @ContentChildren(TheListboxGroupDirective, { descendants: true }) protected _groups: QueryList<TheListboxGroupDirective>;\n\n    @Input() keyboardContainer: HTMLElement;\n\n    @Output() theActiveOptionChange = new EventEmitter<TheListboxChangeEvent>();\n\n    constructor(private ngZone: NgZone, private elementRef: ElementRef<HTMLElement>) {}\n\n    ngOnInit(): void {}\n\n    ngAfterContentInit(): void {\n        this.filterGroups();\n        if (this.groups.length > 0) {\n            this.setActiveItem(null, this.groups[0].getFirst(), 'init');\n        }\n        this._optionChangesSubscription = this._groups.changes.subscribe(() => {\n            this.filterGroups();\n            this.setActiveItem(null, this.groups[0].getFirst(), 'init');\n        });\n        this.ngZone.runOutsideAngular(() => {\n            this._keyboardSubscription = fromEvent<KeyboardEvent>(\n                this.keyboardContainer || this.elementRef.nativeElement,\n                'keydown'\n            ).subscribe(event => {\n                this.handleKeydown(event);\n            });\n        });\n    }\n\n    filterGroups() {\n        this.groups = this._groups.filter(group => {\n            if (!group.parentOption) {\n                return true;\n            } else {\n                return false;\n            }\n        });\n    }\n\n    handleKeydown(event: KeyboardEvent) {\n        const { keyCode } = event;\n        switch (keyCode) {\n            case DOWN_ARROW:\n                this.setNextLineActive();\n                event.preventDefault();\n                break;\n            case UP_ARROW:\n                this.setPreviousLineActive();\n                event.preventDefault();\n                break;\n            case RIGHT_ARROW:\n                this.setNextItemActive();\n                event.preventDefault();\n                break;\n            case LEFT_ARROW:\n                this.setPreviousItemActive();\n                event.preventDefault();\n                break;\n        }\n    }\n\n    /**\n     * ←\n     */\n    setPreviousItemActive() {\n        if (this.activeOption.parentOption) {\n            this.setActiveItem(this.activeOption, this.activeOption.parentOption, 'parent');\n        } else {\n            const groupOptions = this.activeOption.parentGroup.options;\n            let optionIndex = groupOptions.indexOf(this.activeOption);\n            let newOptionIndex = optionIndex - 1;\n            if (newOptionIndex >= 0) {\n                this.setActiveItem(this.activeOption, groupOptions[newOptionIndex], 'turn');\n            } else {\n                this.enterPreviousGroup();\n            }\n        }\n    }\n\n    /**\n     * ↓ 键\n     */\n    setNextLineActive() {\n        const groupOptions = this.activeOption.parentGroup.options;\n        let optionIndex = groupOptions.indexOf(this.activeOption);\n        let newOptionIndex = optionIndex + this.activeOption.parentGroup.horizontalColumn;\n        if (newOptionIndex <= groupOptions.length - 1) {\n            this.setActiveItem(this.activeOption, groupOptions[newOptionIndex], 'turn');\n        } else {\n            this.enterNextGroup();\n        }\n    }\n\n    /**\n     * → 键\n     */\n    setNextItemActive() {\n        if (this.activeOption.hasChild) {\n            this.setActiveItem(this.activeOption, this.activeOption.firstChild, 'child');\n        } else {\n            const groupOptions = this.activeOption.parentGroup.options;\n            let optionIndex = groupOptions.indexOf(this.activeOption);\n            let newOptionIndex = optionIndex + 1;\n            if (newOptionIndex <= groupOptions.length - 1) {\n                this.setActiveItem(this.activeOption, groupOptions[newOptionIndex], 'turn');\n            } else {\n                this.enterNextGroup();\n            }\n        }\n    }\n\n    /**\n     * ↑ 键\n     */\n    setPreviousLineActive() {\n        const groupOptions = this.activeOption.parentGroup.options;\n        let optionIndex = groupOptions.indexOf(this.activeOption);\n        let newOptionIndex = optionIndex - this.activeOption.parentGroup.horizontalColumn;\n        if (newOptionIndex >= 0) {\n            this.setActiveItem(this.activeOption, groupOptions[newOptionIndex], 'turn');\n        } else {\n            this.enterPreviousGroup();\n        }\n    }\n\n    enterNextGroup() {\n        const groups = this.activeOption.parentGroup.getSiblingGroups();\n        const groupIndex = groups.indexOf(this.activeOption.parentGroup);\n        let newGroupIndex = groupIndex + 1;\n        if (newGroupIndex > groups.length - 1) {\n            newGroupIndex = 0;\n        }\n        this.setActiveItem(this.activeOption, groups[newGroupIndex].getFirst(), 'turn');\n    }\n\n    enterPreviousGroup() {\n        const groups = this.activeOption.parentGroup.getSiblingGroups();\n        const groupIndex = groups.indexOf(this.activeOption.parentGroup);\n        let newGroupIndex = groupIndex - 1;\n        if (newGroupIndex < 0) {\n            newGroupIndex = groups.length - 1;\n        }\n        this.setActiveItem(this.activeOption, groups[newGroupIndex].getLast(), 'turn');\n    }\n\n    setActiveItem(previous: TheListboxOptionDirective | null, option: TheListboxOptionDirective, type: TheListboxChangeEventType) {\n        if (previous) {\n            previous.setActive(false);\n        }\n        option.setActive(true);\n        this.activeOption = option;\n        this.theActiveOptionChange.emit({ option, type });\n    }\n\n    ngOnDestroy(): void {\n        this._optionChangesSubscription.unsubscribe();\n        this._keyboardSubscription.unsubscribe();\n    }\n}\n\nexport interface TheListboxChangeEvent {\n    option: TheListboxOptionDirective;\n    type: TheListboxChangeEventType;\n}\n"]}

package/esm2020/components/listbox/listbox.type.mjs

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@angular/core';
+export const THE_LISTBOX_PARENT_OPTION_TOKEN = new InjectionToken('THE_LISTBOX_PARENT_OPTION_TOKEN');
+export const THE_LISTBOX_PARENT_GROUP_TOKEN = new InjectionToken('THE_LISTBOX_PARENT_GROUP_TOKEN');
+export const THE_LISTBOX_TOKEN = new InjectionToken('THE_LISTBOX_TOKEN');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdGJveC50eXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvc3JjL2NvbXBvbmVudHMvbGlzdGJveC9saXN0Ym94LnR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUvQyxNQUFNLENBQUMsTUFBTSwrQkFBK0IsR0FBRyxJQUFJLGNBQWMsQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO0FBRXJHLE1BQU0sQ0FBQyxNQUFNLDhCQUE4QixHQUFHLElBQUksY0FBYyxDQUFDLGdDQUFnQyxDQUFDLENBQUM7QUFFbkcsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUcsSUFBSSxjQUFjLENBQUMsbUJBQW1CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBjb25zdCBUSEVfTElTVEJPWF9QQVJFTlRfT1BUSU9OX1RPS0VOID0gbmV3IEluamVjdGlvblRva2VuKCdUSEVfTElTVEJPWF9QQVJFTlRfT1BUSU9OX1RPS0VOJyk7XG5cbmV4cG9ydCBjb25zdCBUSEVfTElTVEJPWF9QQVJFTlRfR1JPVVBfVE9LRU4gPSBuZXcgSW5qZWN0aW9uVG9rZW4oJ1RIRV9MSVNUQk9YX1BBUkVOVF9HUk9VUF9UT0tFTicpO1xuXG5leHBvcnQgY29uc3QgVEhFX0xJU1RCT1hfVE9LRU4gPSBuZXcgSW5qZWN0aW9uVG9rZW4oJ1RIRV9MSVNUQk9YX1RPS0VOJyk7XG5cbmV4cG9ydCB0eXBlIFRoZUxpc3Rib3hDaGFuZ2VFdmVudFR5cGUgPSAndHVybicgfCAnY2hpbGQnIHwgJ3BhcmVudCcgfCAnaW5pdCc7XG4iXX0=

package/esm2020/components/plugin-menu/plugin-menu.component.mjs

@@ -0,0 +1,102 @@
+import { Component, Input, HostBinding } from '@angular/core';
+import { mixinUnsubscribe, MixinBase } from 'ngx-tethys/core';
+import { Editor, Node } from 'slate';
+import { AngularEditor } from 'slate-angular';
+import { buildPluginMenu, buildPluginMenuItemMap } from '../../core/utils/plugin-menu';
+import { DefaultPluginMenu, ThePluginMenuItemType } from '../../constants/plugin-menu';
+import { ThePluginMenu } from '../../interfaces/plugins/plugin-menu';
+import { getPluginOptions } from '../../core';
+import { PluginKeys } from '../../interfaces';
+import { QuickInsertEditor } from '../../plugins/public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "ngx-tethys/icon";
+import * as i3 from "ngx-tethys/tooltip";
+import * as i4 from "ngx-tethys/action";
+import * as i5 from "ngx-tethys/divider";
+import * as i6 from "ngx-tethys/dropdown";
+import * as i7 from "ngx-tethys/empty";
+import * as i8 from "../table-select/table-select.component";
+export class ThePluginMenuComponent extends mixinUnsubscribe(MixinBase) {
+    constructor(elementRef, cdr) {
+        super();
+        this.elementRef = elementRef;
+        this.cdr = cdr;
+        this.ThePluginMenu = ThePluginMenu;
+        this.groupMenu = [];
+        this.iconMenu = [];
+        this.ThePluginMenuItemType = ThePluginMenuItemType;
+        this.thyMessage = '暂无数据';
+        this.searchGroup = {
+            groupName: '搜索结果'
+        };
+        this.expandPopoverOptions = {
+            placement: 'rightTop',
+            width: '266px'
+        };
+        this.containerClassName = `the-plugin-menu-container`;
+        this.removeKeywords = () => {
+            const hotkey = getPluginOptions(this.editor, PluginKeys.quickInsert)?.hotkey;
+            const node = Node.get(this.editor, this.editor.selection.anchor.path);
+            if (node && node.text.includes(hotkey)) {
+                Editor.deleteBackward(this.editor, { unit: 'block' });
+            }
+        };
+    }
+    ngOnInit() {
+        this.editorElement = AngularEditor.toDOMNode(this.editor, this.editor);
+        let currentMenu = DefaultPluginMenu;
+        const menuItemsMap = buildPluginMenuItemMap(this.editor);
+        this.pluginMenu = this.editor.options.menu ? this.editor.options.menu : buildPluginMenu(menuItemsMap, currentMenu);
+        this.buildMenus();
+    }
+    buildMenus() {
+        if (this.keyWords) {
+            this.iconMenu = [];
+            this.groupMenu = this.pluginMenu.filter((item) => {
+                return item?.keywords && item?.keywords.includes(this.keyWords);
+            });
+            if (this.groupMenu.length > 0) {
+                this.groupMenu.unshift(this.searchGroup);
+            }
+        }
+        else {
+            this.iconMenu = this.pluginMenu.filter((item) => {
+                return item?.type === ThePluginMenuItemType.icon;
+            });
+            this.groupMenu = this.pluginMenu.filter((item) => {
+                return item?.type !== ThePluginMenuItemType.icon;
+            });
+        }
+        this.cdr.detectChanges();
+    }
+    executeItem(event, menuItem) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.removeKeywords();
+        const toolbarItem = this.pluginMenu.find((item) => item.key === menuItem.key);
+        if (toolbarItem.execute) {
+            toolbarItem.execute(this.editor);
+        }
+        QuickInsertEditor.closeMenu(this.editor);
+    }
+    updateKeywords(keywords) {
+        this.keyWords = keywords.toLowerCase().trim();
+        this.buildMenus();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+    }
+}
+ThePluginMenuComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ThePluginMenuComponent, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+ThePluginMenuComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: ThePluginMenuComponent, selector: "the-plugin-menu", inputs: { editor: "editor" }, host: { properties: { "class": "this.containerClassName" } }, usesInheritance: true, ngImport: i0, template: "<div *ngIf=\"groupMenu.length > 0; else thyEmpty\" class=\"thy-dropdown-menu py-2\">\n    <div class=\"icon-menu d-flex px-5 py-1\">\n        <ng-container *ngFor=\"let item of iconMenu\">\n            <a\n                *ngIf=\"item.type === ThePluginMenuItemType.icon\"\n                href=\"javascript:;\"\n                class=\"mt-2\"\n                thyAction\n                [thyActionIcon]=\"item.icon\"\n                [thyTooltip]=\"item.name\"\n                (mousedown)=\"executeItem($event, item)\"\n            ></a>\n        </ng-container>\n    </div>\n\n    <thy-divider *ngIf=\"this.iconMenu?.length\" class=\"my-2\"></thy-divider>\n\n    <ng-container *ngFor=\"let item of groupMenu\">\n        <ng-container *ngIf=\"ThePluginMenu.isMenuItem(item) && !item.isExpanded\">\n            <div thyDropdownMenuItem class=\"insert-menu-item mb-1 py-0\" (mousedown)=\"executeItem($event, item)\">\n                <div class=\"menu-icon mr-2\">\n                    <thy-icon [thyIconName]=\"item.menuIcon\"></thy-icon>\n                </div>\n                <div class=\"menu-content d-flex align-items-center\">\n                    <div class=\"menu-item-title w-100\">\n                        <span *ngIf=\"!item?.isExpanded\" class=\"menu-item-display-key font-size-sm text-placeholder\">\n                            {{ item.displayKey }}</span\n                        >\n                        {{ item.name }}\n                    </div>\n                    <div class=\"text-muted font-size-sm\">{{ item.description }}</div>\n                </div>\n            </div>\n        </ng-container>\n        <ng-container *ngIf=\"ThePluginMenu.isMenuItem(item) && item.isExpanded\" #hasExpanded>\n            <div\n                [thyDropdown]=\"expand\"\n                thyTrigger=\"hover\"\n                thyDropdownMenuItem\n                [thyPopoverOptions]=\"expandPopoverOptions\"\n                class=\"insert-menu-item mb-1 py-0\"\n                (mousedown)=\"executeItem($event, item)\"\n            >\n                <div class=\"menu-icon mr-2\">\n                    <thy-icon [thyIconName]=\"item.menuIcon\"></thy-icon>\n                </div>\n                <div class=\"menu-content d-flex align-items-center\">\n                    <div class=\"menu-item-title w-100\">\n                        <span *ngIf=\"!item?.isExpanded\" class=\"menu-item-display-key font-size-sm text-placeholder\">\n                            {{ item.displayKey }}</span\n                        >\n                        {{ item.name }}\n                    </div>\n                    <div class=\"text-muted font-size-sm\">{{ item.description }}</div>\n                </div>\n                <div *ngIf=\"item?.isExpanded\">\n                    <thy-icon class=\"text-muted\" thyIconName=\"angle-right\"></thy-icon>\n                </div>\n            </div>\n            <thy-dropdown-menu class=\"expand-menu\" #expand>\n                <div class=\"the-plugin-menu-container\">\n                    <div *ngFor=\"let child of item.children\" thyDropdownMenuItem class=\"insert-menu-item mb-1 py-0\">\n                        <div class=\"menu-icon mr-2\">\n                            <thy-icon [thyIconName]=\"child.menuIcon\"></thy-icon>\n                        </div>\n                        <div class=\"menu-content d-flex align-items-center\">\n                            <div class=\"menu-item-title w-100\">\n                                <span class=\"menu-item-display-key font-size-sm text-placeholder\"> {{ child.displayKey }}</span>\n                                {{ child.name }}\n                            </div>\n                            <div class=\"text-muted font-size-sm\">{{ child.description }}</div>\n                        </div>\n                    </div>\n                </div>\n                <table-select\n                    *ngIf=\"item.key === 'table'\"\n                    class=\"plugin-menu-table the-table-selector-panel\"\n                    [editor]=\"editor\"\n                    [beforeInsert]=\"removeKeywords\"\n                ></table-select>\n            </thy-dropdown-menu>\n        </ng-container>\n\n        <ng-container *ngIf=\"!ThePluginMenu.isMenuItem(item)\" #menuGroup>\n            <thy-dropdown-menu-group class=\"font-size-sm\" [thyTitle]=\"item.groupName\"></thy-dropdown-menu-group>\n        </ng-container>\n    </ng-container>\n</div>\n\n<ng-template #thyEmpty>\n    <div class=\"empty d-flex align-items-center justify-content-center\">\n        <thy-empty [thyMessage]=\"thyMessage\"></thy-empty>\n    </div>\n</ng-template>\n", dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.ThyIconComponent, selector: "thy-icon, [thy-icon]", inputs: ["thyIconType", "thyTwotoneColor", "thyIconName", "thyIconRotate", "thyIconSet", "thyIconLegging", "thyIconLinearGradient"] }, { kind: "directive", type: i3.ThyTooltipDirective, selector: "[thyTooltip],[thy-tooltip]", inputs: ["thyTooltip", "thyTooltipPlacement", "thyTooltipClass", "thyTooltipShowDelay", "thyTooltipHideDelay", "thyTooltipTrigger", "thyTooltipDisabled", "thyTooltipTemplateContext", "thyTooltipOffset", "thyTooltipPin"], exportAs: ["thyTooltip"] }, { kind: "component", type: i4.ThyActionComponent, selector: "thy-action, [thyAction]", inputs: ["thyType", "thyIcon", "thyActionIcon", "thyActive", "thyActionActive", "thyTheme", "thyHoverIcon", "thyDisabled"] }, { kind: "component", type: i5.ThyDividerComponent, selector: "thy-divider", inputs: ["thyVertical", "thyStyle", "thyColor", "thyText", "thyTextDirection", "thyDeeper"] }, { kind: "directive", type: i6.ThyDropdownDirective, selector: "[thyDropdown]", inputs: ["thyDropdownMenu", "thyDropdown", "thyTrigger", "thyActiveClass", "thyPopoverOptions"], outputs: ["thyActiveChange"] }, { kind: "component", type: i6.ThyDropdownMenuComponent, selector: "thy-dropdown-menu", inputs: ["thyWidth"] }, { kind: "component", type: i6.ThyDropdownMenuGroupComponent, selector: "thy-dropdown-menu-group", inputs: ["thyTitle"] }, { kind: "directive", type: i6.ThyDropdownMenuItemDirective, selector: "[thyDropdownMenuItem]", inputs: ["thyType", "thyDisabled"] }, { kind: "component", type: i7.ThyEmptyComponent, selector: "thy-empty", inputs: ["thyMessage", "thyTranslationKey", "thyTranslationValues", "thyEntityName", "thyEntityNameTranslateKey", "thyIconName", "thySize", "thyMarginTop", "thyTopAuto", "thyContainer", "thyImageUrl", "thyImageLoading", "thyImageFetchPriority", "thyDescription"] }, { kind: "component", type: i8.TheTableSelectComponent, selector: "table-select", inputs: ["optionsParam", "editor", "beforeInsert"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ThePluginMenuComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'the-plugin-menu', template: "<div *ngIf=\"groupMenu.length > 0; else thyEmpty\" class=\"thy-dropdown-menu py-2\">\n    <div class=\"icon-menu d-flex px-5 py-1\">\n        <ng-container *ngFor=\"let item of iconMenu\">\n            <a\n                *ngIf=\"item.type === ThePluginMenuItemType.icon\"\n                href=\"javascript:;\"\n                class=\"mt-2\"\n                thyAction\n                [thyActionIcon]=\"item.icon\"\n                [thyTooltip]=\"item.name\"\n                (mousedown)=\"executeItem($event, item)\"\n            ></a>\n        </ng-container>\n    </div>\n\n    <thy-divider *ngIf=\"this.iconMenu?.length\" class=\"my-2\"></thy-divider>\n\n    <ng-container *ngFor=\"let item of groupMenu\">\n        <ng-container *ngIf=\"ThePluginMenu.isMenuItem(item) && !item.isExpanded\">\n            <div thyDropdownMenuItem class=\"insert-menu-item mb-1 py-0\" (mousedown)=\"executeItem($event, item)\">\n                <div class=\"menu-icon mr-2\">\n                    <thy-icon [thyIconName]=\"item.menuIcon\"></thy-icon>\n                </div>\n                <div class=\"menu-content d-flex align-items-center\">\n                    <div class=\"menu-item-title w-100\">\n                        <span *ngIf=\"!item?.isExpanded\" class=\"menu-item-display-key font-size-sm text-placeholder\">\n                            {{ item.displayKey }}</span\n                        >\n                        {{ item.name }}\n                    </div>\n                    <div class=\"text-muted font-size-sm\">{{ item.description }}</div>\n                </div>\n            </div>\n        </ng-container>\n        <ng-container *ngIf=\"ThePluginMenu.isMenuItem(item) && item.isExpanded\" #hasExpanded>\n            <div\n                [thyDropdown]=\"expand\"\n                thyTrigger=\"hover\"\n                thyDropdownMenuItem\n                [thyPopoverOptions]=\"expandPopoverOptions\"\n                class=\"insert-menu-item mb-1 py-0\"\n                (mousedown)=\"executeItem($event, item)\"\n            >\n                <div class=\"menu-icon mr-2\">\n                    <thy-icon [thyIconName]=\"item.menuIcon\"></thy-icon>\n                </div>\n                <div class=\"menu-content d-flex align-items-center\">\n                    <div class=\"menu-item-title w-100\">\n                        <span *ngIf=\"!item?.isExpanded\" class=\"menu-item-display-key font-size-sm text-placeholder\">\n                            {{ item.displayKey }}</span\n                        >\n                        {{ item.name }}\n                    </div>\n                    <div class=\"text-muted font-size-sm\">{{ item.description }}</div>\n                </div>\n                <div *ngIf=\"item?.isExpanded\">\n                    <thy-icon class=\"text-muted\" thyIconName=\"angle-right\"></thy-icon>\n                </div>\n            </div>\n            <thy-dropdown-menu class=\"expand-menu\" #expand>\n                <div class=\"the-plugin-menu-container\">\n                    <div *ngFor=\"let child of item.children\" thyDropdownMenuItem class=\"insert-menu-item mb-1 py-0\">\n                        <div class=\"menu-icon mr-2\">\n                            <thy-icon [thyIconName]=\"child.menuIcon\"></thy-icon>\n                        </div>\n                        <div class=\"menu-content d-flex align-items-center\">\n                            <div class=\"menu-item-title w-100\">\n                                <span class=\"menu-item-display-key font-size-sm text-placeholder\"> {{ child.displayKey }}</span>\n                                {{ child.name }}\n                            </div>\n                            <div class=\"text-muted font-size-sm\">{{ child.description }}</div>\n                        </div>\n                    </div>\n                </div>\n                <table-select\n                    *ngIf=\"item.key === 'table'\"\n                    class=\"plugin-menu-table the-table-selector-panel\"\n                    [editor]=\"editor\"\n                    [beforeInsert]=\"removeKeywords\"\n                ></table-select>\n            </thy-dropdown-menu>\n        </ng-container>\n\n        <ng-container *ngIf=\"!ThePluginMenu.isMenuItem(item)\" #menuGroup>\n            <thy-dropdown-menu-group class=\"font-size-sm\" [thyTitle]=\"item.groupName\"></thy-dropdown-menu-group>\n        </ng-container>\n    </ng-container>\n</div>\n\n<ng-template #thyEmpty>\n    <div class=\"empty d-flex align-items-center justify-content-center\">\n        <thy-empty [thyMessage]=\"thyMessage\"></thy-empty>\n    </div>\n</ng-template>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { containerClassName: [{
+                type: HostBinding,
+                args: ['class']
+            }], editor: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin-menu.component.js","sourceRoot":"","sources":["../../../../../packages/src/components/plugin-menu/plugin-menu.component.ts","../../../../../packages/src/components/plugin-menu/plugin-menu.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, OnDestroy, ElementRef, ChangeDetectorRef, HostBinding } from '@angular/core';\nimport { mixinUnsubscribe, MixinBase } from 'ngx-tethys/core';\nimport { Editor, Node, Text } from 'slate';\nimport { AngularEditor } from 'slate-angular';\nimport { buildPluginMenu, buildPluginMenuItemMap } from '../../core/utils/plugin-menu';\nimport { DefaultPluginMenu, ThePluginMenuItemType } from '../../constants/plugin-menu';\nimport { ThePluginMenu, ThePluginMenuGroup, ThePluginMenuItem, ThePluginMenuItemConfig } from '../../interfaces/plugins/plugin-menu';\nimport { getPluginOptions } from '../../core';\nimport { QuickInsertPluginOptions } from '../../plugins/quick-insert/quick-insert.plugin';\nimport { PluginKeys } from '../../interfaces';\nimport { QuickInsertEditor } from '../../plugins/public-api';\n\n@Component({\n    selector: 'the-plugin-menu',\n    templateUrl: 'plugin-menu.component.html'\n})\nexport class ThePluginMenuComponent extends mixinUnsubscribe(MixinBase) implements OnInit, OnDestroy {\n    editorElement: HTMLElement;\n\n    ThePluginMenu = ThePluginMenu;\n\n    pluginMenu: ThePluginMenu;\n\n    groupMenu: ThePluginMenu = [];\n\n    iconMenu: ThePluginMenu = [];\n\n    ThePluginMenuItemType = ThePluginMenuItemType;\n\n    keyWords: string;\n\n    thyMessage = '暂无数据';\n\n    searchGroup: ThePluginMenuGroup = {\n        groupName: '搜索结果'\n    };\n\n    expandPopoverOptions = {\n        placement: 'rightTop',\n        width: '266px'\n    };\n\n    @HostBinding('class') containerClassName = `the-plugin-menu-container`;\n\n    @Input() editor: Editor;\n\n    constructor(public elementRef: ElementRef, public cdr: ChangeDetectorRef) {\n        super();\n    }\n\n    ngOnInit() {\n        this.editorElement = AngularEditor.toDOMNode(this.editor, this.editor);\n        let currentMenu = DefaultPluginMenu;\n        const menuItemsMap = buildPluginMenuItemMap(this.editor);\n        this.pluginMenu = this.editor.options.menu ? this.editor.options.menu : buildPluginMenu(menuItemsMap, currentMenu);\n        this.buildMenus();\n    }\n\n    buildMenus() {\n        if (this.keyWords) {\n            this.iconMenu = [];\n            this.groupMenu = this.pluginMenu.filter((item: any) => {\n                return item?.keywords && item?.keywords.includes(this.keyWords);\n            });\n\n            if (this.groupMenu.length > 0) {\n                this.groupMenu.unshift(this.searchGroup);\n            }\n        } else {\n            this.iconMenu = this.pluginMenu.filter((item: any) => {\n                return item?.type === ThePluginMenuItemType.icon;\n            });\n            this.groupMenu = this.pluginMenu.filter((item: any) => {\n                return item?.type !== ThePluginMenuItemType.icon;\n            });\n        }\n\n        this.cdr.detectChanges();\n    }\n\n    executeItem(event: MouseEvent, menuItem: ThePluginMenuItem) {\n        event.preventDefault();\n        event.stopPropagation();\n        this.removeKeywords();\n        const toolbarItem: any = this.pluginMenu.find((item: ThePluginMenuItem) => item.key === menuItem.key);\n        if (toolbarItem.execute) {\n            toolbarItem.execute(this.editor);\n        }\n        QuickInsertEditor.closeMenu(this.editor);\n    }\n\n    removeKeywords = () => {\n        const hotkey = getPluginOptions<QuickInsertPluginOptions>(this.editor, PluginKeys.quickInsert)?.hotkey;\n        const node = Node.get(this.editor, this.editor.selection.anchor.path) as Text;\n        if (node && node.text.includes(hotkey)) {\n            Editor.deleteBackward(this.editor, { unit: 'block' });\n        }\n    };\n\n    updateKeywords(keywords: string) {\n        this.keyWords = keywords.toLowerCase().trim();\n        this.buildMenus();\n    }\n\n    ngOnDestroy() {\n        super.ngOnDestroy();\n    }\n}\n","<div *ngIf=\"groupMenu.length > 0; else thyEmpty\" class=\"thy-dropdown-menu py-2\">\n    <div class=\"icon-menu d-flex px-5 py-1\">\n        <ng-container *ngFor=\"let item of iconMenu\">\n            <a\n                *ngIf=\"item.type === ThePluginMenuItemType.icon\"\n                href=\"javascript:;\"\n                class=\"mt-2\"\n                thyAction\n                [thyActionIcon]=\"item.icon\"\n                [thyTooltip]=\"item.name\"\n                (mousedown)=\"executeItem($event, item)\"\n            ></a>\n        </ng-container>\n    </div>\n\n    <thy-divider *ngIf=\"this.iconMenu?.length\" class=\"my-2\"></thy-divider>\n\n    <ng-container *ngFor=\"let item of groupMenu\">\n        <ng-container *ngIf=\"ThePluginMenu.isMenuItem(item) && !item.isExpanded\">\n            <div thyDropdownMenuItem class=\"insert-menu-item mb-1 py-0\" (mousedown)=\"executeItem($event, item)\">\n                <div class=\"menu-icon mr-2\">\n                    <thy-icon [thyIconName]=\"item.menuIcon\"></thy-icon>\n                </div>\n                <div class=\"menu-content d-flex align-items-center\">\n                    <div class=\"menu-item-title w-100\">\n                        <span *ngIf=\"!item?.isExpanded\" class=\"menu-item-display-key font-size-sm text-placeholder\">\n                            {{ item.displayKey }}</span\n                        >\n                        {{ item.name }}\n                    </div>\n                    <div class=\"text-muted font-size-sm\">{{ item.description }}</div>\n                </div>\n            </div>\n        </ng-container>\n        <ng-container *ngIf=\"ThePluginMenu.isMenuItem(item) && item.isExpanded\" #hasExpanded>\n            <div\n                [thyDropdown]=\"expand\"\n                thyTrigger=\"hover\"\n                thyDropdownMenuItem\n                [thyPopoverOptions]=\"expandPopoverOptions\"\n                class=\"insert-menu-item mb-1 py-0\"\n                (mousedown)=\"executeItem($event, item)\"\n            >\n                <div class=\"menu-icon mr-2\">\n                    <thy-icon [thyIconName]=\"item.menuIcon\"></thy-icon>\n                </div>\n                <div class=\"menu-content d-flex align-items-center\">\n                    <div class=\"menu-item-title w-100\">\n                        <span *ngIf=\"!item?.isExpanded\" class=\"menu-item-display-key font-size-sm text-placeholder\">\n                            {{ item.displayKey }}</span\n                        >\n                        {{ item.name }}\n                    </div>\n                    <div class=\"text-muted font-size-sm\">{{ item.description }}</div>\n                </div>\n                <div *ngIf=\"item?.isExpanded\">\n                    <thy-icon class=\"text-muted\" thyIconName=\"angle-right\"></thy-icon>\n                </div>\n            </div>\n            <thy-dropdown-menu class=\"expand-menu\" #expand>\n                <div class=\"the-plugin-menu-container\">\n                    <div *ngFor=\"let child of item.children\" thyDropdownMenuItem class=\"insert-menu-item mb-1 py-0\">\n                        <div class=\"menu-icon mr-2\">\n                            <thy-icon [thyIconName]=\"child.menuIcon\"></thy-icon>\n                        </div>\n                        <div class=\"menu-content d-flex align-items-center\">\n                            <div class=\"menu-item-title w-100\">\n                                <span class=\"menu-item-display-key font-size-sm text-placeholder\"> {{ child.displayKey }}</span>\n                                {{ child.name }}\n                            </div>\n                            <div class=\"text-muted font-size-sm\">{{ child.description }}</div>\n                        </div>\n                    </div>\n                </div>\n                <table-select\n                    *ngIf=\"item.key === 'table'\"\n                    class=\"plugin-menu-table the-table-selector-panel\"\n                    [editor]=\"editor\"\n                    [beforeInsert]=\"removeKeywords\"\n                ></table-select>\n            </thy-dropdown-menu>\n        </ng-container>\n\n        <ng-container *ngIf=\"!ThePluginMenu.isMenuItem(item)\" #menuGroup>\n            <thy-dropdown-menu-group class=\"font-size-sm\" [thyTitle]=\"item.groupName\"></thy-dropdown-menu-group>\n        </ng-container>\n    </ng-container>\n</div>\n\n<ng-template #thyEmpty>\n    <div class=\"empty d-flex align-items-center justify-content-center\">\n        <thy-empty [thyMessage]=\"thyMessage\"></thy-empty>\n    </div>\n</ng-template>\n"]}

package/esm2020/components/table-select/table-select.component.mjs

@@ -1,4 +1,4 @@
-import { Component, Input, HostListener } from '@angular/core';
+import { Component, Input } from '@angular/core';
 import { insertTable } from '../../plugins/table/transforms/insert-table';
 import { TableOptions } from '../../plugins/table/table.types';
 import * as i0 from "@angular/core";
@@ -7,15 +7,11 @@ import * as i2 from "@angular/common";
 export class TheTableSelectComponent {
     constructor(popoverRef) {
         this.popoverRef = popoverRef;
+        this.beforeInsert = () => { };
         this.tableData = new Array(10);
         this.maxRowIndex = -1;
         this.maxColIndex = -1;
     }
-    handleDocumentMouseDown(event) {
-        if (!document.querySelector('.table-selector-container').contains(event.target)) {
-            this.popoverRef.close();
-        }
-    }
     ngOnInit() { }
     onSelectCells(rowIndex, colIndex) {
         this.maxRowIndex = rowIndex;
@@ -24,6 +20,7 @@ export class TheTableSelectComponent {
     executeTable(event) {
         event.preventDefault();
         event.stopPropagation();
+        this.beforeInsert();
         const opts = new TableOptions(this.optionsParam);
         insertTable(opts, this.editor, this.maxRowIndex + 1, this.maxColIndex + 1);
         if (this.popoverRef) {
@@ -34,7 +31,7 @@ export class TheTableSelectComponent {
     }
 }
 TheTableSelectComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: TheTableSelectComponent, deps: [{ token: i1.ThyPopoverRef }], target: i0.ɵɵFactoryTarget.Component });
-TheTableSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: TheTableSelectComponent, selector: "table-select", inputs: { optionsParam: "optionsParam", editor: "editor" }, host: { listeners: { "document: mousedown": "handleDocumentMouseDown($event)" } }, ngImport: i0, template: "<div class=\"table-selector-container\">\n    <div *ngFor=\"let item of tableData; let rowIndex = index\" class=\"selector-row\" (mousedown)=\"executeTable($event)\">\n        <span\n            *ngFor=\"let item of tableData; let colIndex = index\"\n            [ngClass]=\"{ 'active-cell': rowIndex <= maxRowIndex && colIndex <= maxColIndex, 'selector-cell': true }\"\n            (mouseenter)=\"onSelectCells(rowIndex, colIndex)\"\n        >\n        </span>\n    </div>\n    <span class=\"selector-text\">{{ maxRowIndex + 1 }} x {{ maxColIndex + 1 }}</span>\n</div>\n", dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+TheTableSelectComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: TheTableSelectComponent, selector: "table-select", inputs: { optionsParam: "optionsParam", editor: "editor", beforeInsert: "beforeInsert" }, ngImport: i0, template: "<div class=\"table-selector-container\">\n    <div *ngFor=\"let item of tableData; let rowIndex = index\" class=\"selector-row\" (mousedown)=\"executeTable($event)\">\n        <span\n            *ngFor=\"let item of tableData; let colIndex = index\"\n            [ngClass]=\"{ 'active-cell': rowIndex <= maxRowIndex && colIndex <= maxColIndex, 'selector-cell': true }\"\n            (mouseenter)=\"onSelectCells(rowIndex, colIndex)\"\n        >\n        </span>\n    </div>\n    <span class=\"selector-text\">{{ maxRowIndex + 1 }} x {{ maxColIndex + 1 }}</span>\n</div>\n", dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: TheTableSelectComponent, decorators: [{
             type: Component,
             args: [{ selector: 'table-select', template: "<div class=\"table-selector-container\">\n    <div *ngFor=\"let item of tableData; let rowIndex = index\" class=\"selector-row\" (mousedown)=\"executeTable($event)\">\n        <span\n            *ngFor=\"let item of tableData; let colIndex = index\"\n            [ngClass]=\"{ 'active-cell': rowIndex <= maxRowIndex && colIndex <= maxColIndex, 'selector-cell': true }\"\n            (mouseenter)=\"onSelectCells(rowIndex, colIndex)\"\n        >\n        </span>\n    </div>\n    <span class=\"selector-text\">{{ maxRowIndex + 1 }} x {{ maxColIndex + 1 }}</span>\n</div>\n" }]
@@ -42,8 +39,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImpor
                 type: Input
             }], editor: [{
                 type: Input
-            }], handleDocumentMouseDown: [{
-                type: HostListener,
-                args: ['document: mousedown', ['$event']]
+            }], beforeInsert: [{
+                type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUtc2VsZWN0LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3NyYy9jb21wb25lbnRzL3RhYmxlLXNlbGVjdC90YWJsZS1zZWxlY3QuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvc3JjL2NvbXBvbmVudHMvdGFibGUtc2VsZWN0L3RhYmxlLXNlbGVjdC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBd0IsTUFBTSxlQUFlLENBQUM7QUFFdkUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDZDQUE2QyxDQUFDO0FBRTFFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQzs7OztBQU0vRCxNQUFNLE9BQU8sdUJBQXVCO0lBYWhDLFlBQW9CLFVBQWtEO1FBQWxELGVBQVUsR0FBVixVQUFVLENBQXdDO1FBUjdELGlCQUFZLEdBQUcsR0FBRyxFQUFFLEdBQUUsQ0FBQyxDQUFDO1FBRWpDLGNBQVMsR0FBRyxJQUFJLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUUxQixnQkFBVyxHQUFHLENBQUMsQ0FBQyxDQUFDO1FBRWpCLGdCQUFXLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFFd0QsQ0FBQztJQUUxRSxRQUFRLEtBQVUsQ0FBQztJQUVuQixhQUFhLENBQUMsUUFBUSxFQUFFLFFBQVE7UUFDNUIsSUFBSSxDQUFDLFdBQVcsR0FBRyxRQUFRLENBQUM7UUFDNUIsSUFBSSxDQUFDLFdBQVcsR0FBRyxRQUFRLENBQUM7SUFDaEMsQ0FBQztJQUVELFlBQVksQ0FBQyxLQUFpQjtRQUMxQixLQUFLLENBQUMsY0FBYyxFQUFFLENBQUM7UUFDdkIsS0FBSyxDQUFDLGVBQWUsRUFBRSxDQUFDO1FBQ3hCLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztRQUNwQixNQUFNLElBQUksR0FBRyxJQUFJLFlBQVksQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDakQsV0FBVyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxXQUFXLEdBQUcsQ0FBQyxFQUFFLElBQUksQ0FBQyxXQUFXLEdBQUcsQ0FBQyxDQUFDLENBQUM7UUFDM0UsSUFBSSxJQUFJLENBQUMsVUFBVSxFQUFFO1lBQ2pCLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDeEIsSUFBSSxDQUFDLFdBQVcsR0FBRyxDQUFDLENBQUMsQ0FBQztZQUN0QixJQUFJLENBQUMsV0FBVyxHQUFHLENBQUMsQ0FBQyxDQUFDO1NBQ3pCO0lBQ0wsQ0FBQzs7b0hBakNRLHVCQUF1Qjt3R0FBdkIsdUJBQXVCLDhJQ1ZwQyw2akJBV0E7MkZERGEsdUJBQXVCO2tCQUpuQyxTQUFTOytCQUNJLGNBQWM7b0dBSWYsWUFBWTtzQkFBcEIsS0FBSztnQkFFRyxNQUFNO3NCQUFkLEtBQUs7Z0JBRUcsWUFBWTtzQkFBcEIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQsIE9uSW5pdCwgSG9zdExpc3RlbmVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUaHlQb3BvdmVyUmVmIH0gZnJvbSAnbmd4LXRldGh5cy9wb3BvdmVyJztcbmltcG9ydCB7IGluc2VydFRhYmxlIH0gZnJvbSAnLi4vLi4vcGx1Z2lucy90YWJsZS90cmFuc2Zvcm1zL2luc2VydC10YWJsZSc7XG5pbXBvcnQgeyBUaGVFZGl0b3IgfSBmcm9tICcuLi8uLi9pbnRlcmZhY2VzJztcbmltcG9ydCB7IFRhYmxlT3B0aW9ucyB9IGZyb20gJy4uLy4uL3BsdWdpbnMvdGFibGUvdGFibGUudHlwZXMnO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogJ3RhYmxlLXNlbGVjdCcsXG4gICAgdGVtcGxhdGVVcmw6ICcuL3RhYmxlLXNlbGVjdC5jb21wb25lbnQuaHRtbCdcbn0pXG5leHBvcnQgY2xhc3MgVGhlVGFibGVTZWxlY3RDb21wb25lbnQgaW1wbGVtZW50cyBPbkluaXQge1xuICAgIEBJbnB1dCgpIG9wdGlvbnNQYXJhbTogVGFibGVPcHRpb25zO1xuXG4gICAgQElucHV0KCkgZWRpdG9yOiBUaGVFZGl0b3I7XG5cbiAgICBASW5wdXQoKSBiZWZvcmVJbnNlcnQgPSAoKSA9PiB7fTtcblxuICAgIHRhYmxlRGF0YSA9IG5ldyBBcnJheSgxMCk7XG5cbiAgICBtYXhSb3dJbmRleCA9IC0xO1xuXG4gICAgbWF4Q29sSW5kZXggPSAtMTtcblxuICAgIGNvbnN0cnVjdG9yKHByaXZhdGUgcG9wb3ZlclJlZjogVGh5UG9wb3ZlclJlZjxUaGVUYWJsZVNlbGVjdENvbXBvbmVudD4pIHt9XG5cbiAgICBuZ09uSW5pdCgpOiB2b2lkIHt9XG5cbiAgICBvblNlbGVjdENlbGxzKHJvd0luZGV4LCBjb2xJbmRleCkge1xuICAgICAgICB0aGlzLm1heFJvd0luZGV4ID0gcm93SW5kZXg7XG4gICAgICAgIHRoaXMubWF4Q29sSW5kZXggPSBjb2xJbmRleDtcbiAgICB9XG5cbiAgICBleGVjdXRlVGFibGUoZXZlbnQ6IE1vdXNlRXZlbnQpIHtcbiAgICAgICAgZXZlbnQucHJldmVudERlZmF1bHQoKTtcbiAgICAgICAgZXZlbnQuc3RvcFByb3BhZ2F0aW9uKCk7XG4gICAgICAgIHRoaXMuYmVmb3JlSW5zZXJ0KCk7XG4gICAgICAgIGNvbnN0IG9wdHMgPSBuZXcgVGFibGVPcHRpb25zKHRoaXMub3B0aW9uc1BhcmFtKTtcbiAgICAgICAgaW5zZXJ0VGFibGUob3B0cywgdGhpcy5lZGl0b3IsIHRoaXMubWF4Um93SW5kZXggKyAxLCB0aGlzLm1heENvbEluZGV4ICsgMSk7XG4gICAgICAgIGlmICh0aGlzLnBvcG92ZXJSZWYpIHtcbiAgICAgICAgICAgIHRoaXMucG9wb3ZlclJlZi5jbG9zZSgpO1xuICAgICAgICAgICAgdGhpcy5tYXhDb2xJbmRleCA9IC0xO1xuICAgICAgICAgICAgdGhpcy5tYXhSb3dJbmRleCA9IC0xO1xuICAgICAgICB9XG4gICAgfVxufVxuIiwiPGRpdiBjbGFzcz1cInRhYmxlLXNlbGVjdG9yLWNvbnRhaW5lclwiPlxuICAgIDxkaXYgKm5nRm9yPVwibGV0IGl0ZW0gb2YgdGFibGVEYXRhOyBsZXQgcm93SW5kZXggPSBpbmRleFwiIGNsYXNzPVwic2VsZWN0b3Itcm93XCIgKG1vdXNlZG93bik9XCJleGVjdXRlVGFibGUoJGV2ZW50KVwiPlxuICAgICAgICA8c3BhblxuICAgICAgICAgICAgKm5nRm9yPVwibGV0IGl0ZW0gb2YgdGFibGVEYXRhOyBsZXQgY29sSW5kZXggPSBpbmRleFwiXG4gICAgICAgICAgICBbbmdDbGFzc109XCJ7ICdhY3RpdmUtY2VsbCc6IHJvd0luZGV4IDw9IG1heFJvd0luZGV4ICYmIGNvbEluZGV4IDw9IG1heENvbEluZGV4LCAnc2VsZWN0b3ItY2VsbCc6IHRydWUgfVwiXG4gICAgICAgICAgICAobW91c2VlbnRlcik9XCJvblNlbGVjdENlbGxzKHJvd0luZGV4LCBjb2xJbmRleClcIlxuICAgICAgICA+XG4gICAgICAgIDwvc3Bhbj5cbiAgICA8L2Rpdj5cbiAgICA8c3BhbiBjbGFzcz1cInNlbGVjdG9yLXRleHRcIj57eyBtYXhSb3dJbmRleCArIDEgfX0geCB7eyBtYXhDb2xJbmRleCArIDEgfX08L3NwYW4+XG48L2Rpdj5cbiJdfQ==