@theseam/ui-common 0.4.25 → 0.4.27

package/esm2020/rich-text/rich-text/rich-text.component.mjs

@@ -0,0 +1,594 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Component, EventEmitter, HostListener, Inject, Input, Optional, Output, ViewChild, forwardRef } from '@angular/core';
+import { FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';
+import 'quill-mention';
+import { BehaviorSubject, Subject, combineLatest, filter, lastValueFrom, map, of, shareReplay, startWith, switchMap, take, tap } from 'rxjs';
+import { isNullOrUndefined, notNullOrUndefined } from '@theseam/ui-common/utils';
+import { THESEAM_QUILL_EDITOR_CONFIG, THESEAM_QUILL_EDITOR_CONFIG_DEFAULT, THESEAM_QUILL_MENTION_OPTIONS_DEFAULT, defaultHtmlCharacterCounterFn, defaultMentionRenderListFn, defaultMentionSearchFn, isMentionMenuOption } from '../utils/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "ngx-quill";
+export const RICH_TEXT_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => RichTextComponent),
+    multi: true
+};
+export class RichTextComponent {
+    get required() {
+        return this._required;
+    }
+    set required(value) {
+        if (notNullOrUndefined(value)) {
+            this._required = coerceBooleanProperty(value);
+        }
+    }
+    /** @default '' (empty string) */
+    get placeholder() {
+        return this._placeholder;
+    }
+    set placeholder(value) {
+        if (notNullOrUndefined(value)) {
+            this._placeholder = value;
+        }
+    }
+    /**
+     * Initial rows visible in text area, set using `height` and `minHeight`.
+     *
+     * NOTE: Resizable editors will not be able to size below the height calculated from this value.
+     *
+     * @default 5
+     */
+    get rows() {
+        return this._rows;
+    }
+    set rows(value) {
+        if (notNullOrUndefined(value)) {
+            this._rows = value;
+            this._pollCalculatedRowHeight.next();
+        }
+    }
+    /**
+     * When `true`, text area can be resized vertically.
+     *
+     * @default true
+     */
+    get resizable() {
+        return this._resizable;
+    }
+    set resizable(value) {
+        if (notNullOrUndefined(value)) {
+            this._resizable = coerceBooleanProperty(value);
+        }
+    }
+    /** @default false */
+    get readOnly() {
+        return this._readOnly;
+    }
+    set readOnly(value) {
+        if (notNullOrUndefined(value)) {
+            this._readOnly = coerceBooleanProperty(value);
+        }
+    }
+    // TODO: fix bug where initial html value is rendered in plain text
+    /**
+     * When `true`, overrides all other provided settings to present the editor
+     * as a standard textbox.
+     *
+     * NOTE: For the moment, `<p></p>` tags are still allowed, triggered by the `Enter` key.
+     * https://github.com/slab/quill/issues/1432
+     *
+     * @default false
+     */
+    get disableRichText() {
+        return this._disableRichText;
+    }
+    set disableRichText(value) {
+        if (notNullOrUndefined(value)) {
+            this._disableRichText = coerceBooleanProperty(value);
+            this._updateQuillConfig();
+        }
+    }
+    /**
+     * When `true`, displays a character counter at the bottom of the editor.
+     * Character counter text is determined by values provided in `minLength`
+     * and `maxLength`.
+     *
+     * The default count algorithm strips out html entities and replaces them
+     * with spaces to get the string length. To override this behavior, pass
+     * a custom function to `characterCounterFn`.
+     *
+     * To override default character counter display, pass a custom template to `characterCountTpl`.
+     *
+     * @default false
+     */
+    get displayCharacterCounter() {
+        return this._displayCharacterCounter;
+    }
+    set displayCharacterCounter(value) {
+        if (notNullOrUndefined(value)) {
+            this._displayCharacterCounter = coerceBooleanProperty(value);
+        }
+    }
+    get minLength() {
+        return this._minLength;
+    }
+    set minLength(value) {
+        if (notNullOrUndefined(value)) {
+            this._minLength = value;
+        }
+    }
+    get maxLength() {
+        return this._maxLength;
+    }
+    set maxLength(value) {
+        if (notNullOrUndefined(value)) {
+            this._maxLength = value;
+        }
+    }
+    /**
+     * Set to override default character counter display.
+     *
+     * Template context includes variables `minLength`, `maxLength`, and `characterCount`.
+     */
+    get characterCounterTpl() {
+        return this._characterCounterTpl;
+    }
+    set characterCounterTpl(value) {
+        if (notNullOrUndefined(value)) {
+            this._characterCounterTpl = value;
+        }
+    }
+    /**
+     * Set to override default counter function, which strips html entities and
+     * replaces them with a space.
+     */
+    get characterCounterFn() {
+        return this._characterCounterFn;
+    }
+    set characterCounterFn(value) {
+        if (notNullOrUndefined(value)) {
+            this._characterCounterFn = value;
+        }
+    }
+    /**
+     * If `true`, component will configure the Quill editor with the quill-mentions extension
+     * and listen for values passed to `mentionItems` to populate the mentions menu.
+     *
+     * @default false
+     */
+    get useMentions() {
+        return this._useMentions;
+    }
+    set useMentions(value) {
+        if (notNullOrUndefined(value)) {
+            this._useMentions = coerceBooleanProperty(value);
+            this._updateQuillConfig();
+        }
+    }
+    /**
+     * List of users, user groups, or other entities to display in mentions menu.
+     * Minimum required properties are `id` (unique) and `value`, which acts as the label.
+     *
+     * By default, the menu is triggered by typing the `@` symbol into the text area.
+     */
+    get mentionItems() {
+        return this._mentionItems.value;
+    }
+    set mentionItems(value) {
+        if (notNullOrUndefined(value)) {
+            this._mentionItems.next(value);
+        }
+    }
+    /**
+     * Set to override default search function when user is typing a mention.
+     */
+    get mentionSearchFn() {
+        return this._mentionSearchFn;
+    }
+    set mentionSearchFn(value) {
+        if (notNullOrUndefined(value)) {
+            this._mentionSearchFn = value;
+        }
+    }
+    /**
+     * Set to override default render function for mentions list.
+     *
+     * Function should call `renderList`.
+     */
+    get mentionRenderListFn() {
+        return this._mentionRenderListFn;
+    }
+    set mentionRenderListFn(value) {
+        if (notNullOrUndefined(value)) {
+            this._mentionRenderListFn = value;
+        }
+    }
+    /**
+     * Set to override default text shown while mention items are loading.
+     *
+     * @default 'Loading...'
+     */
+    get mentionListLoadingText() {
+        return this._mentionListLoadingText;
+    }
+    set mentionListLoadingText(value) {
+        if (notNullOrUndefined(value)) {
+            this._mentionListLoadingText = value;
+        }
+    }
+    /**
+     * Set to override default text shown when a mention search returns no items.
+     *
+     * @default 'No matches found.'
+     */
+    get mentionListEmptyText() {
+        return this._mentionListEmptyText;
+    }
+    set mentionListEmptyText(value) {
+        if (notNullOrUndefined(value)) {
+            this._mentionListEmptyText = value;
+        }
+    }
+    get mentionListEmptyItem() {
+        return {
+            id: 'undefined',
+            value: this.mentionListEmptyText,
+            disabled: true,
+            emptyList: true
+        };
+    }
+    get quillEditor() {
+        return this._quillEditor;
+    }
+    set quillEditor(value) {
+        this._quillEditor = value;
+        // setTimeout because full html isn't available until the next tick
+        setTimeout(() => {
+            this._pollCalculatedRowHeight.next();
+        }, 0);
+    }
+    _handleKeydown(event) {
+        if (event.code === 'Escape') {
+            const qlEditor = this._quillEditor?.editorElem?.querySelector('.ql-editor');
+            if (notNullOrUndefined(qlEditor) && qlEditor === document.activeElement && qlEditor instanceof HTMLElement) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                qlEditor.blur();
+            }
+        }
+    }
+    constructor(_renderer, _customConfig) {
+        this._renderer = _renderer;
+        this._customConfig = _customConfig;
+        this.formControl = new FormControl(null);
+        this._required = false;
+        this._placeholder = '';
+        this._rows = 5;
+        this._resizable = true;
+        this._readOnly = false;
+        this._disableRichText = false;
+        this._displayCharacterCounter = false;
+        this._characterCounterTpl = null;
+        this._characterCounterFn = defaultHtmlCharacterCounterFn;
+        this._useMentions = false;
+        this._mentionItems = new BehaviorSubject(undefined);
+        this.mentionItems$ = this._mentionItems.asObservable().pipe(filter(mentions => notNullOrUndefined(mentions) && mentions.length > 0), shareReplay({ bufferSize: 1, refCount: true }));
+        this._mentionSearchFn = defaultMentionSearchFn;
+        this._mentionRenderListFn = defaultMentionRenderListFn;
+        this._mentionListLoadingText = 'Loading...';
+        this._mentionListEmptyText = 'No matches found.';
+        this.quillEditorCreated = new EventEmitter();
+        this.quillEditorChanged = new EventEmitter();
+        this.quillContentChanged = new EventEmitter();
+        this.quillSelectionChanged = new EventEmitter();
+        this.quillFocus = new EventEmitter();
+        this.quillBlur = new EventEmitter();
+        this.mentionsUpdated = new EventEmitter();
+        this._isWritingValue = false;
+        this._pollCalculatedRowHeight = new Subject();
+        this._configSet = new BehaviorSubject(false);
+        this.configSet$ = this._configSet.asObservable();
+        this._stylesSet = new BehaviorSubject(false);
+        this._templateSet = new BehaviorSubject(false);
+        this._config = new BehaviorSubject(undefined);
+        this.config$ = this._config.asObservable();
+        this._selectedMentions = new BehaviorSubject([]);
+        this.selectedMentions$ = this._selectedMentions.asObservable();
+        this.initialized$ = combineLatest([
+            this._configSet.asObservable(),
+            this._stylesSet.asObservable(),
+            this._templateSet.asObservable(),
+        ]).pipe(map(sets => sets.findIndex(s => !s) === -1));
+        this.characterCount$ = this.initialized$.pipe(filter(i => i), switchMap(() => {
+            if (notNullOrUndefined(this.formControl)) {
+                return this.formControl.valueChanges.pipe(startWith(this.formControl.value), map(v => this.characterCounterFn(v || '', this._config.value?.format)));
+            }
+            return of(0);
+        }));
+        this.selectedMentions$.pipe(tap(mentions => this.mentionsUpdated.emit(mentions))).subscribe();
+    }
+    ngOnInit() {
+        // TODO: test this more
+        // ignore quill initial valueChange event, to keep functionality in line with other inputs
+        let initialEmitComplete = false;
+        this._configSet.pipe(filter(s => s), switchMap(() => this.formControl.valueChanges.pipe(
+        // skip(1),
+        take(1), tap(() => initialEmitComplete = true)))).subscribe();
+        this.formControl.valueChanges.pipe(filter(() => !this._isWritingValue && initialEmitComplete), tap(value => this.value = value)).subscribe();
+        this._pollCalculatedRowHeight.asObservable().pipe(tap(() => {
+            this._stylesSet.next(false);
+            const calculatedRowsHeight = `${this.rows * 1.5}rem`;
+            if (notNullOrUndefined(this.rows) && notNullOrUndefined(this._quillEditor)) {
+                const editorEl = this._quillEditor.elementRef.nativeElement.querySelector('.ql-editor');
+                if (notNullOrUndefined(editorEl)) {
+                    this._renderer.setStyle(editorEl, 'height', calculatedRowsHeight);
+                    this._renderer.setStyle(editorEl, 'min-height', calculatedRowsHeight);
+                }
+            }
+            this._stylesSet.next(true);
+        })).subscribe();
+        this._buildQuillConfig();
+    }
+    ngAfterViewInit() {
+        if (isNullOrUndefined(this.characterCounterTpl)) {
+            this.characterCounterTpl = this.defaultCharacterCounterTpl || null;
+        }
+        this._templateSet.next(true);
+    }
+    ngOnDestroy() {
+        // hacky way to ensure mentions menu gets destroyed when component is destroyed
+        const mentionModule = this._quillEditor?.quillEditor.getModule('mention');
+        const hideMentionList = mentionModule?.hideMentionList;
+        if (hideMentionList && typeof hideMentionList === 'function') {
+            hideMentionList.call(mentionModule);
+        }
+    }
+    _buildQuillConfig() {
+        this._configSet.next(false);
+        const config = {
+            ...THESEAM_QUILL_EDITOR_CONFIG_DEFAULT
+        };
+        if (this.disableRichText) {
+            config.format = 'text';
+            config.formats = [];
+            config.modules = {
+                toolbar: false
+            };
+        }
+        else {
+            config.format = this._getConfigOrDefault('format');
+            config.formats = this._getConfigOrDefault('formats');
+            config.modules = {
+                ...this._getConfigOrDefault('modules')
+            };
+        }
+        if (this.useMentions) {
+            const mentionModules = {
+                ...config.modules,
+                mention: {
+                    ...THESEAM_QUILL_MENTION_OPTIONS_DEFAULT,
+                    renderLoading: () => this.mentionListLoadingText,
+                    source: async (searchTerm, renderList, mentionChar) => {
+                        // this function is called every time the menu is triggered,
+                        // so it will always have the latest value from mentionItems$
+                        const mentionsAsync = await lastValueFrom(this.mentionItems$.pipe(take(1)));
+                        if (notNullOrUndefined(mentionsAsync)) {
+                            this.mentionRenderListFn(mentionsAsync, this.mentionSearchFn, this.mentionListEmptyItem, searchTerm, renderList, mentionChar);
+                        }
+                    },
+                    ...config.modules?.mention,
+                }
+            };
+            config.modules = mentionModules;
+        }
+        config.theme = this._getConfigOrDefault('theme');
+        config.debug = this._getConfigOrDefault('debug');
+        config.customToolbarPosition = this._getConfigOrDefault('customToolbarPosition');
+        config.sanitize = this._getConfigOrDefault('sanitize');
+        config.styles = this._getConfigOrDefault('styles');
+        config.strict = this._getConfigOrDefault('strict');
+        config.scrollingContainer = this._getConfigOrDefault('scrollingContainer');
+        config.bounds = this._getConfigOrDefault('bounds');
+        config.customOptions = this._getConfigOrDefault('customOptions');
+        config.customModules = this._getConfigOrDefault('customModules');
+        config.trackChanges = this._getConfigOrDefault('trackChanges');
+        config.preserveWhitespace = this._getConfigOrDefault('preserveWhitespace');
+        config.classes = this._getConfigOrDefault('classes');
+        config.trimOnValidation = this._getConfigOrDefault('trimOnValidation');
+        config.linkPlaceholder = this._getConfigOrDefault('linkPlaceholder');
+        config.compareValues = this._getConfigOrDefault('compareValues');
+        config.filterNull = this._getConfigOrDefault('filterNull');
+        config.debounceTime = this._getConfigOrDefault('debounceTime');
+        this._config.next(config);
+        // setTimeout bc ngx-quill library doesn't listen for input changes,
+        // so we must destroy and create the component each time config is updated
+        setTimeout(() => {
+            this._configSet.next(true);
+        }, 0);
+    }
+    _getConfigOrDefault(prop) {
+        if (this._customConfig && Object.prototype.hasOwnProperty.call(this._customConfig, prop)) {
+            return this._customConfig[prop];
+        }
+        return THESEAM_QUILL_EDITOR_CONFIG_DEFAULT[prop];
+    }
+    _updateQuillConfig() {
+        if (this._configSet.value) {
+            this._buildQuillConfig();
+        }
+    }
+    // Not usable, bc config has to be set immediately, potentially before mentions populate.
+    // To set customDataAttributes, provide a custom config.
+    // private _getCustomDataAttributes(mentions: TheSeamQuillMentionMenuOption[]): string[] {
+    //   return mentions.reduce((acc, mention) => {
+    //     const keys = Object.keys(mention)
+    //     keys.forEach(key => {
+    //       if (acc.findIndex(a => a === key) === -1) {
+    //         acc.push(key)
+    //       }
+    //     })
+    //     return acc
+    //   }, <string[]>[] satisfies string[])
+    // }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+        if (this.onChange) {
+            this.onChange(value);
+        }
+        if (this.onTouched) {
+            this.onTouched();
+        }
+    }
+    writeValue(value) {
+        this._isWritingValue = true;
+        this.formControl.setValue(value);
+        this.value = value;
+        this._isWritingValue = false;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.readOnly = isDisabled;
+    }
+    _onEditorCreated(event) {
+        this.quillEditorCreated.emit(event);
+    }
+    _onEditorChanged(event) {
+        this.quillEditorChanged.emit(event);
+    }
+    _onContentChanged(event) {
+        this.quillContentChanged.emit(event);
+        this._updateMentionsFromDelta(event.content);
+    }
+    _onSelectionChanged(event) {
+        this.quillSelectionChanged.emit(event);
+    }
+    _onFocus(event) {
+        this.quillFocus.emit(event);
+    }
+    _onBlur(event) {
+        this.quillBlur.emit(event);
+        if (this.onTouched) {
+            this.onTouched();
+        }
+    }
+    /**
+     * Hacky way to track mention inserts/deletes
+     */
+    _updateMentionsFromDelta(content) {
+        if (notNullOrUndefined(content.ops)) {
+            const contentMentionIds = content.ops.map(o => o.insert?.mention?.id).filter(notNullOrUndefined);
+            const selectedMentions = [...this._selectedMentions.value];
+            const mentionOptions = [...this._mentionItems.value || []];
+            const newMentions = contentMentionIds.reduce((acc, mentionId) => {
+                const insertMention = mentionOptions.find(m => isMentionMenuOption(m) && m.id === mentionId);
+                if (notNullOrUndefined(insertMention)) {
+                    acc.push(insertMention);
+                }
+                else {
+                    console.warn('Mention addition failed! Selected mention option not found:', mentionId);
+                }
+                return acc;
+            }, []);
+            let emitUpdate = false;
+            if (selectedMentions.length !== newMentions.length) {
+                // if the length has changed, we know an update occurred
+                emitUpdate = true;
+            }
+            else {
+                // otherwise, test ids for old and new items to see if we need to emit a change
+                const selectedMentionIds = this._selectedMentions.value.map(m => m.id);
+                const newMentionIds = newMentions.map(m => m.id);
+                if (selectedMentionIds.findIndex(m => !newMentionIds.includes(m)) !== -1 ||
+                    newMentionIds.findIndex(m => !selectedMentionIds.includes(m)) !== -1) {
+                    emitUpdate = true;
+                }
+            }
+            if (emitUpdate) {
+                this._selectedMentions.next(newMentions);
+            }
+        }
+    }
+}
+RichTextComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RichTextComponent, deps: [{ token: i0.Renderer2 }, { token: THESEAM_QUILL_EDITOR_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+RichTextComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.7", type: RichTextComponent, selector: "seam-rich-text", inputs: { val: ["value", "val"], required: "required", placeholder: "placeholder", rows: "rows", resizable: "resizable", disableRichText: "disableRichText", displayCharacterCounter: "displayCharacterCounter", minLength: "minLength", maxLength: "maxLength", characterCounterTpl: "characterCounterTpl", characterCounterFn: "characterCounterFn", useMentions: "useMentions", mentionItems: "mentionItems", mentionSearchFn: "mentionSearchFn", mentionRenderListFn: "mentionRenderListFn", mentionListLoadingText: "mentionListLoadingText", mentionListEmptyText: "mentionListEmptyText" }, outputs: { quillEditorCreated: "quillEditorCreated", quillEditorChanged: "quillEditorChanged", quillContentChanged: "quillContentChanged", quillSelectionChanged: "quillSelectionChanged", quillFocus: "quillFocus", quillBlur: "quillBlur", mentionsUpdated: "mentionsUpdated" }, host: { listeners: { "keydown": "_handleKeydown($event)" } }, providers: [
+        RICH_TEXT_VALUE_ACCESSOR
+    ], viewQueries: [{ propertyName: "quillEditor", first: true, predicate: ["quillEditor"], descendants: true }, { propertyName: "defaultCharacterCounterTpl", first: true, predicate: ["characterCounter"], descendants: true }], ngImport: i0, template: "<div class=\"editor\" *ngIf=\"configSet$ | async\" [class.initializing]=\"!(initialized$ | async)\">\n  <ng-container *ngIf=\"config$ | async as config\">\n    <quill-editor\n      #quillEditor\n      seamInput\n      [class.disabled]=\"readOnly\"\n      [attr.disabled]=\"readOnly\"\n      [formControl]=\"formControl\"\n      [placeholder]=\"placeholder\"\n      [readOnly]=\"readOnly\"\n      [required]=\"required\"\n      [minLength]=\"minLength\"\n      [maxLength]=\"maxLength\"\n      [format]=\"config.format\"\n      [theme]=\"config.theme\"\n      [modules]=\"config.modules\"\n      [debug]=\"config.debug\"\n      [formats]=\"config.formats\"\n      [customToolbarPosition]=\"config.customToolbarPosition\"\n      [sanitize]=\"config.sanitize\"\n      [styles]=\"config.styles\"\n      [strict]=\"config.strict\"\n      [scrollingContainer]=\"config.scrollingContainer\"\n      [bounds]=\"config.bounds\"\n      [customOptions]=\"config.customOptions\"\n      [customModules]=\"config.customModules\"\n      [trackChanges]=\"config.trackChanges\"\n      [preserveWhitespace]=\"config.preserveWhitespace\"\n      [classes]=\"config.classes\"\n      [trimOnValidation]=\"config.trimOnValidation\"\n      [linkPlaceholder]=\"config.linkPlaceholder\"\n      [compareValues]=\"config.compareValues\"\n      [filterNull]=\"config.filterNull\"\n      [debounceTime]=\"config.debounceTime\"\n      [class.can-resize]=\"resizable\"\n      (onEditorCreated)=\"_onEditorCreated($event)\"\n      (onEditorChanged)=\"_onEditorChanged($event)\"\n      (onContentChanged)=\"_onContentChanged($event)\"\n      (onSelectionChanged)=\"_onSelectionChanged($event)\"\n      (onFocus)=\"_onFocus($event)\"\n      (onBlur)=\"_onBlur($event)\"></quill-editor>\n    <ng-container *ngIf=\"displayCharacterCounter\">\n      <ng-container\n        [ngTemplateOutlet]=\"characterCounterTpl\"\n        [ngTemplateOutletContext]=\"{ $implicit: characterCount$ | async, minLength: minLength, maxLength: maxLength, characterCount: characterCount$ | async }\"></ng-container>\n    </ng-container>\n  </ng-container>\n</div>\n\n<ng-template #characterCounter let-implicit let-minLength=\"minLength\" let-maxLength=\"maxLength\" let-characterCount=\"characterCount\">\n  <div class=\"small text-black-50 text-right\">\n    <ng-container *ngIf=\"characterCount || characterCount === 0\">\n      Character Count:\n      <span [class.text-danger]=\"characterCount && ((maxLength && characterCount > maxLength) || (minLength && characterCount < minLength))\">\n        {{ characterCount | number }}\n      </span>\n      <ng-container *ngIf=\"maxLength\">\n        / {{ maxLength }}\n      </ng-container>\n      <span *ngIf=\"minLength\" class=\"font-italic\">\n        (minimum {{ minLength }} expected)\n      </span>\n    </ng-container>\n  </div>\n</ng-template>\n", styles: [":host .editor{position:relative}:host .editor.initializing:before{content:\"\";position:absolute;top:0;left:0;width:100%;height:100%;background:#f8f9fa;z-index:1}:host quill-editor.can-resize ::ng-deep .ql-editor{overflow:auto;resize:vertical}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "component", type: i3.QuillEditorComponent, selector: "quill-editor" }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i1.DecimalPipe, name: "number" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: RichTextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-rich-text', providers: [
+                        RICH_TEXT_VALUE_ACCESSOR
+                    ], template: "<div class=\"editor\" *ngIf=\"configSet$ | async\" [class.initializing]=\"!(initialized$ | async)\">\n  <ng-container *ngIf=\"config$ | async as config\">\n    <quill-editor\n      #quillEditor\n      seamInput\n      [class.disabled]=\"readOnly\"\n      [attr.disabled]=\"readOnly\"\n      [formControl]=\"formControl\"\n      [placeholder]=\"placeholder\"\n      [readOnly]=\"readOnly\"\n      [required]=\"required\"\n      [minLength]=\"minLength\"\n      [maxLength]=\"maxLength\"\n      [format]=\"config.format\"\n      [theme]=\"config.theme\"\n      [modules]=\"config.modules\"\n      [debug]=\"config.debug\"\n      [formats]=\"config.formats\"\n      [customToolbarPosition]=\"config.customToolbarPosition\"\n      [sanitize]=\"config.sanitize\"\n      [styles]=\"config.styles\"\n      [strict]=\"config.strict\"\n      [scrollingContainer]=\"config.scrollingContainer\"\n      [bounds]=\"config.bounds\"\n      [customOptions]=\"config.customOptions\"\n      [customModules]=\"config.customModules\"\n      [trackChanges]=\"config.trackChanges\"\n      [preserveWhitespace]=\"config.preserveWhitespace\"\n      [classes]=\"config.classes\"\n      [trimOnValidation]=\"config.trimOnValidation\"\n      [linkPlaceholder]=\"config.linkPlaceholder\"\n      [compareValues]=\"config.compareValues\"\n      [filterNull]=\"config.filterNull\"\n      [debounceTime]=\"config.debounceTime\"\n      [class.can-resize]=\"resizable\"\n      (onEditorCreated)=\"_onEditorCreated($event)\"\n      (onEditorChanged)=\"_onEditorChanged($event)\"\n      (onContentChanged)=\"_onContentChanged($event)\"\n      (onSelectionChanged)=\"_onSelectionChanged($event)\"\n      (onFocus)=\"_onFocus($event)\"\n      (onBlur)=\"_onBlur($event)\"></quill-editor>\n    <ng-container *ngIf=\"displayCharacterCounter\">\n      <ng-container\n        [ngTemplateOutlet]=\"characterCounterTpl\"\n        [ngTemplateOutletContext]=\"{ $implicit: characterCount$ | async, minLength: minLength, maxLength: maxLength, characterCount: characterCount$ | async }\"></ng-container>\n    </ng-container>\n  </ng-container>\n</div>\n\n<ng-template #characterCounter let-implicit let-minLength=\"minLength\" let-maxLength=\"maxLength\" let-characterCount=\"characterCount\">\n  <div class=\"small text-black-50 text-right\">\n    <ng-container *ngIf=\"characterCount || characterCount === 0\">\n      Character Count:\n      <span [class.text-danger]=\"characterCount && ((maxLength && characterCount > maxLength) || (minLength && characterCount < minLength))\">\n        {{ characterCount | number }}\n      </span>\n      <ng-container *ngIf=\"maxLength\">\n        / {{ maxLength }}\n      </ng-container>\n      <span *ngIf=\"minLength\" class=\"font-italic\">\n        (minimum {{ minLength }} expected)\n      </span>\n    </ng-container>\n  </div>\n</ng-template>\n", styles: [":host .editor{position:relative}:host .editor.initializing:before{content:\"\";position:absolute;top:0;left:0;width:100%;height:100%;background:#f8f9fa;z-index:1}:host quill-editor.can-resize ::ng-deep .ql-editor{overflow:auto;resize:vertical}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [THESEAM_QUILL_EDITOR_CONFIG]
+                }] }]; }, propDecorators: { val: [{
+                type: Input,
+                args: ['value']
+            }], required: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], rows: [{
+                type: Input
+            }], resizable: [{
+                type: Input
+            }], disableRichText: [{
+                type: Input
+            }], displayCharacterCounter: [{
+                type: Input
+            }], minLength: [{
+                type: Input
+            }], maxLength: [{
+                type: Input
+            }], characterCounterTpl: [{
+                type: Input
+            }], characterCounterFn: [{
+                type: Input
+            }], useMentions: [{
+                type: Input
+            }], mentionItems: [{
+                type: Input
+            }], mentionSearchFn: [{
+                type: Input
+            }], mentionRenderListFn: [{
+                type: Input
+            }], mentionListLoadingText: [{
+                type: Input
+            }], mentionListEmptyText: [{
+                type: Input
+            }], quillEditorCreated: [{
+                type: Output
+            }], quillEditorChanged: [{
+                type: Output
+            }], quillContentChanged: [{
+                type: Output
+            }], quillSelectionChanged: [{
+                type: Output
+            }], quillFocus: [{
+                type: Output
+            }], quillBlur: [{
+                type: Output
+            }], mentionsUpdated: [{
+                type: Output
+            }], quillEditor: [{
+                type: ViewChild,
+                args: ['quillEditor']
+            }], defaultCharacterCounterTpl: [{
+                type: ViewChild,
+                args: ['characterCounter']
+            }], _handleKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rich-text.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/rich-text/rich-text/rich-text.component.ts","../../../../../projects/ui-common/rich-text/rich-text/rich-text.component.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { AfterViewInit, Component, EventEmitter, HostListener, Inject, Input, OnDestroy, OnInit, Optional, Output, Provider, Renderer2, TemplateRef, ViewChild, forwardRef } from '@angular/core';\nimport { ControlValueAccessor, FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { Blur, ContentChange, EditorChangeContent, EditorChangeSelection, Focus, QuillEditorComponent, SelectionChange } from 'ngx-quill';\nimport { Delta } from 'quill';\nimport 'quill-mention';\nimport { BehaviorSubject, Observable, Subject, combineLatest, filter, lastValueFrom, map, of, shareReplay, startWith, switchMap, take, tap } from 'rxjs';\n\nimport { isNullOrUndefined, notNullOrUndefined } from '@theseam/ui-common/utils';\nimport { TheSeamCharacterCounterFn, TheSeamQuillEditorConfig, TheSeamQuillMentionMenuItem, TheSeamQuillMentionMenuOption, TheSeamQuillMentionSearchFn, TheSeamQuillMentionSourceFn, TheSeamQuillModules } from '../utils/models';\nimport { THESEAM_QUILL_EDITOR_CONFIG, THESEAM_QUILL_EDITOR_CONFIG_DEFAULT, THESEAM_QUILL_MENTION_OPTIONS_DEFAULT, defaultHtmlCharacterCounterFn, defaultMentionRenderListFn, defaultMentionSearchFn, isMentionMenuOption } from '../utils/utils';\n\nexport const RICH_TEXT_VALUE_ACCESSOR: Provider = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => RichTextComponent),\n  multi: true\n}\n\n@Component({\n  selector: 'seam-rich-text',\n  templateUrl: './rich-text.component.html',\n  styleUrls: ['./rich-text.component.scss'],\n  providers: [\n    RICH_TEXT_VALUE_ACCESSOR\n  ]\n})\nexport class RichTextComponent implements OnInit, AfterViewInit, OnDestroy, ControlValueAccessor {\n\n  onChange: any\n  onTouched: any\n\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('value') val: string | undefined\n\n  formControl = new FormControl<string | null>(null)\n\n  @Input()\n  get required(): boolean {\n    return this._required\n  }\n  set required(value: boolean | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._required = coerceBooleanProperty(value)\n    }\n  }\n  private _required = false\n\n  /** @default '' (empty string) */\n  @Input()\n  get placeholder(): string {\n    return this._placeholder\n  }\n  set placeholder(value: string | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._placeholder = value\n    }\n  }\n  private _placeholder = ''\n\n  /**\n   * Initial rows visible in text area, set using `height` and `minHeight`.\n   *\n   * NOTE: Resizable editors will not be able to size below the height calculated from this value.\n   *\n   * @default 5\n   */\n  @Input()\n  get rows(): number {\n    return this._rows\n  }\n  set rows(value: number | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._rows = value\n\n      this._pollCalculatedRowHeight.next()\n    }\n  }\n  private _rows = 5\n\n  /**\n   * When `true`, text area can be resized vertically.\n   *\n   * @default true\n   */\n  @Input()\n  get resizable(): boolean {\n    return this._resizable\n  }\n  set resizable(value: boolean | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._resizable = coerceBooleanProperty(value)\n    }\n  }\n  private _resizable = true\n\n  /** @default false */\n  get readOnly(): boolean {\n    return this._readOnly\n  }\n  set readOnly(value: boolean | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._readOnly = coerceBooleanProperty(value)\n    }\n  }\n  private _readOnly = false\n\n  // TODO: fix bug where initial html value is rendered in plain text\n  /**\n   * When `true`, overrides all other provided settings to present the editor\n   * as a standard textbox.\n   *\n   * NOTE: For the moment, `<p></p>` tags are still allowed, triggered by the `Enter` key.\n   * https://github.com/slab/quill/issues/1432\n   *\n   * @default false\n   */\n  @Input()\n  get disableRichText(): boolean {\n    return this._disableRichText\n  }\n  set disableRichText(value: boolean | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._disableRichText = coerceBooleanProperty(value)\n\n      this._updateQuillConfig()\n    }\n  }\n  private _disableRichText = false\n\n  /**\n   * When `true`, displays a character counter at the bottom of the editor.\n   * Character counter text is determined by values provided in `minLength`\n   * and `maxLength`.\n   *\n   * The default count algorithm strips out html entities and replaces them\n   * with spaces to get the string length. To override this behavior, pass\n   * a custom function to `characterCounterFn`.\n   *\n   * To override default character counter display, pass a custom template to `characterCountTpl`.\n   *\n   * @default false\n   */\n  @Input()\n  get displayCharacterCounter(): boolean {\n    return this._displayCharacterCounter\n  }\n  set displayCharacterCounter(value: boolean | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._displayCharacterCounter = coerceBooleanProperty(value)\n    }\n  }\n  private _displayCharacterCounter = false\n\n  @Input()\n  get minLength(): number | undefined {\n    return this._minLength\n  }\n  set minLength(value: number | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._minLength = value\n    }\n  }\n  private _minLength: number | undefined\n\n  @Input()\n  get maxLength(): number | undefined {\n    return this._maxLength\n  }\n  set maxLength(value: number | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._maxLength = value\n    }\n  }\n  private _maxLength: number | undefined\n\n  /**\n   * Set to override default character counter display.\n   *\n   * Template context includes variables `minLength`, `maxLength`, and `characterCount`.\n   */\n  @Input()\n  get characterCounterTpl(): TemplateRef<any> | null {\n    return this._characterCounterTpl\n  }\n  set characterCounterTpl(value) {\n    if (notNullOrUndefined(value)) {\n      this._characterCounterTpl = value\n    }\n  }\n  private _characterCounterTpl: TemplateRef<any> | null = null\n\n  /**\n   * Set to override default counter function, which strips html entities and\n   * replaces them with a space.\n   */\n  @Input() get characterCounterFn(): TheSeamCharacterCounterFn {\n    return this._characterCounterFn\n  }\n  set characterCounterFn(value: TheSeamCharacterCounterFn | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._characterCounterFn = value\n    }\n  }\n  private _characterCounterFn = defaultHtmlCharacterCounterFn\n\n  /**\n   * If `true`, component will configure the Quill editor with the quill-mentions extension\n   * and listen for values passed to `mentionItems` to populate the mentions menu.\n   *\n   * @default false\n   */\n  @Input()\n  get useMentions(): boolean {\n    return this._useMentions\n  }\n  set useMentions(value: boolean | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._useMentions = coerceBooleanProperty(value)\n\n      this._updateQuillConfig()\n    }\n  }\n  private _useMentions: boolean = false\n\n  /**\n   * List of users, user groups, or other entities to display in mentions menu.\n   * Minimum required properties are `id` (unique) and `value`, which acts as the label.\n   *\n   * By default, the menu is triggered by typing the `@` symbol into the text area.\n   */\n  @Input()\n  get mentionItems(): TheSeamQuillMentionMenuItem[] | null | undefined {\n    return this._mentionItems.value\n  }\n  set mentionItems(value: TheSeamQuillMentionMenuItem[] | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._mentionItems.next(value)\n    }\n  }\n  private _mentionItems = new BehaviorSubject<TheSeamQuillMentionMenuItem[] | null | undefined>(undefined)\n  public mentionItems$ = this._mentionItems.asObservable().pipe(\n    filter(mentions => notNullOrUndefined(mentions) && mentions.length > 0),\n    shareReplay({ bufferSize: 1, refCount: true })\n  )\n\n  /**\n   * Set to override default search function when user is typing a mention.\n   */\n  @Input()\n  get mentionSearchFn(): TheSeamQuillMentionSearchFn {\n    return this._mentionSearchFn\n  }\n  set mentionSearchFn(value: TheSeamQuillMentionSearchFn | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._mentionSearchFn = value\n    }\n  }\n  private _mentionSearchFn: TheSeamQuillMentionSearchFn = defaultMentionSearchFn\n\n  /**\n   * Set to override default render function for mentions list.\n   *\n   * Function should call `renderList`.\n   */\n  @Input()\n  get mentionRenderListFn(): TheSeamQuillMentionSourceFn {\n    return this._mentionRenderListFn\n  }\n  set mentionRenderListFn(value: TheSeamQuillMentionSourceFn | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._mentionRenderListFn = value\n    }\n  }\n  private _mentionRenderListFn: TheSeamQuillMentionSourceFn = defaultMentionRenderListFn\n\n  /**\n   * Set to override default text shown while mention items are loading.\n   *\n   * @default 'Loading...'\n   */\n  @Input()\n  get mentionListLoadingText(): string {\n    return this._mentionListLoadingText\n  }\n  set mentionListLoadingText(value: string | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._mentionListLoadingText = value\n    }\n  }\n  private _mentionListLoadingText: string = 'Loading...'\n\n  /**\n   * Set to override default text shown when a mention search returns no items.\n   *\n   * @default 'No matches found.'\n   */\n  @Input()\n  get mentionListEmptyText(): string {\n    return this._mentionListEmptyText\n  }\n  set mentionListEmptyText(value: string | null | undefined) {\n    if (notNullOrUndefined(value)) {\n      this._mentionListEmptyText = value\n    }\n  }\n  private _mentionListEmptyText: string = 'No matches found.'\n\n  get mentionListEmptyItem(): TheSeamQuillMentionMenuOption {\n    return {\n      id: 'undefined',\n      value: this.mentionListEmptyText,\n      disabled: true,\n      emptyList: true\n    }\n  }\n\n  @Output() quillEditorCreated: EventEmitter<any> = new EventEmitter()\n  @Output() quillEditorChanged: EventEmitter<EditorChangeContent | EditorChangeSelection> = new EventEmitter()\n  @Output() quillContentChanged: EventEmitter<ContentChange> = new EventEmitter()\n  @Output() quillSelectionChanged: EventEmitter<SelectionChange> = new EventEmitter()\n  @Output() quillFocus: EventEmitter<Focus> = new EventEmitter()\n  @Output() quillBlur: EventEmitter<Blur> = new EventEmitter()\n\n  @Output() mentionsUpdated: EventEmitter<TheSeamQuillMentionMenuOption[]> = new EventEmitter()\n\n  @ViewChild('quillEditor')\n  get quillEditor(): QuillEditorComponent | undefined {\n    return this._quillEditor\n  }\n  set quillEditor(value: QuillEditorComponent | undefined) {\n    this._quillEditor = value\n\n    // setTimeout because full html isn't available until the next tick\n    setTimeout(() => {\n      this._pollCalculatedRowHeight.next()\n    }, 0)\n  }\n  private _quillEditor: QuillEditorComponent | undefined\n\n  @ViewChild('characterCounter') defaultCharacterCounterTpl: TemplateRef<any> | undefined\n\n  @HostListener('keydown', ['$event'])\n  _handleKeydown(event: KeyboardEvent) {\n    if (event.code === 'Escape') {\n      const qlEditor = this._quillEditor?.editorElem?.querySelector('.ql-editor')\n      if (notNullOrUndefined(qlEditor) && qlEditor === document.activeElement && qlEditor instanceof HTMLElement) {\n        event.preventDefault()\n        event.stopImmediatePropagation()\n        qlEditor.blur()\n      }\n    }\n  }\n\n  private _isWritingValue = false\n\n  private _pollCalculatedRowHeight = new Subject<void>()\n\n  private _configSet = new BehaviorSubject<boolean>(false)\n  public configSet$ = this._configSet.asObservable()\n\n  private _stylesSet = new BehaviorSubject<boolean>(false)\n  private _templateSet = new BehaviorSubject<boolean>(false)\n\n  public initialized$: Observable<boolean>\n\n  public characterCount$: Observable<number>\n\n  private _config = new BehaviorSubject<TheSeamQuillEditorConfig | undefined>(undefined)\n  public config$ = this._config.asObservable()\n\n  private _selectedMentions = new BehaviorSubject<TheSeamQuillMentionMenuOption[]>([])\n  public selectedMentions$ = this._selectedMentions.asObservable()\n\n  constructor(\n    private readonly _renderer: Renderer2,\n    @Optional() @Inject(THESEAM_QUILL_EDITOR_CONFIG) private _customConfig?: TheSeamQuillEditorConfig\n  ) {\n    this.initialized$ = combineLatest([\n      this._configSet.asObservable(),\n      this._stylesSet.asObservable(),\n      this._templateSet.asObservable(),\n    ]).pipe(\n      map(sets => sets.findIndex(s => !s) === -1)\n    )\n\n    this.characterCount$ = this.initialized$.pipe(\n      filter(i => i),\n      switchMap(() => {\n        if (notNullOrUndefined(this.formControl)) {\n          return this.formControl.valueChanges.pipe(\n            startWith(this.formControl.value),\n            map(v => this.characterCounterFn(v || '' as string, this._config.value?.format)),\n          )\n        }\n\n        return of(0)\n      })\n    )\n\n    this.selectedMentions$.pipe(\n      tap(mentions => this.mentionsUpdated.emit(mentions))\n    ).subscribe()\n  }\n\n  ngOnInit(): void {\n    // TODO: test this more\n    // ignore quill initial valueChange event, to keep functionality in line with other inputs\n    let initialEmitComplete = false\n    this._configSet.pipe(\n      filter(s => s),\n      switchMap(() => this.formControl.valueChanges.pipe(\n        // skip(1),\n        take(1),\n        tap(() => initialEmitComplete = true)\n      ))\n    ).subscribe()\n\n    this.formControl.valueChanges.pipe(\n      filter(() => !this._isWritingValue && initialEmitComplete),\n      tap(value => this.value = value)\n    ).subscribe()\n\n    this._pollCalculatedRowHeight.asObservable().pipe(\n      tap(() => {\n        this._stylesSet.next(false)\n\n        const calculatedRowsHeight = `${this.rows * 1.5}rem`\n\n        if (notNullOrUndefined(this.rows) && notNullOrUndefined(this._quillEditor)) {\n          const editorEl = this._quillEditor.elementRef.nativeElement.querySelector('.ql-editor')\n\n          if (notNullOrUndefined(editorEl)) {\n            this._renderer.setStyle(editorEl, 'height', calculatedRowsHeight)\n            this._renderer.setStyle(editorEl, 'min-height', calculatedRowsHeight)\n          }\n        }\n\n        this._stylesSet.next(true)\n      })\n    ).subscribe()\n\n    this._buildQuillConfig()\n  }\n\n  ngAfterViewInit(): void {\n    if (isNullOrUndefined(this.characterCounterTpl)) {\n      this.characterCounterTpl = this.defaultCharacterCounterTpl || null\n    }\n\n    this._templateSet.next(true)\n  }\n\n  ngOnDestroy(): void {\n    // hacky way to ensure mentions menu gets destroyed when component is destroyed\n    const mentionModule = this._quillEditor?.quillEditor.getModule('mention')\n    const hideMentionList = mentionModule?.hideMentionList\n    if (hideMentionList && typeof hideMentionList === 'function') {\n      hideMentionList.call(mentionModule)\n    }\n  }\n\n  private _buildQuillConfig() {\n    this._configSet.next(false)\n\n    const config: TheSeamQuillEditorConfig = {\n      ...THESEAM_QUILL_EDITOR_CONFIG_DEFAULT\n    }\n\n    if (this.disableRichText) {\n      config.format = 'text'\n      config.formats = []\n      config.modules = {\n        toolbar: false\n      }\n    }\n    else {\n      config.format = this._getConfigOrDefault('format')\n      config.formats = this._getConfigOrDefault('formats')\n      config.modules = {\n        ...this._getConfigOrDefault('modules')\n      }\n    }\n\n    if (this.useMentions) {\n      const mentionModules: TheSeamQuillModules = {\n        ...config.modules,\n        mention: {\n          ...THESEAM_QUILL_MENTION_OPTIONS_DEFAULT,\n          renderLoading: () => this.mentionListLoadingText,\n          source: async (searchTerm: string, renderList: (list: any[], searchTerm: string) => void, mentionChar: string) => {\n            // this function is called every time the menu is triggered,\n            // so it will always have the latest value from mentionItems$\n            const mentionsAsync = await lastValueFrom(this.mentionItems$.pipe(take(1)))\n\n            if (notNullOrUndefined(mentionsAsync)) {\n              this.mentionRenderListFn(mentionsAsync, this.mentionSearchFn, this.mentionListEmptyItem, searchTerm, renderList, mentionChar)\n            }\n          },\n          ...config.modules?.mention,\n        }\n      }\n\n      config.modules = mentionModules\n    }\n\n    config.theme = this._getConfigOrDefault('theme')\n    config.debug = this._getConfigOrDefault('debug')\n    config.customToolbarPosition = this._getConfigOrDefault('customToolbarPosition')\n    config.sanitize = this._getConfigOrDefault('sanitize')\n    config.styles = this._getConfigOrDefault('styles')\n    config.strict = this._getConfigOrDefault('strict')\n    config.scrollingContainer = this._getConfigOrDefault('scrollingContainer')\n    config.bounds = this._getConfigOrDefault('bounds')\n    config.customOptions = this._getConfigOrDefault('customOptions')\n    config.customModules = this._getConfigOrDefault('customModules')\n    config.trackChanges = this._getConfigOrDefault('trackChanges')\n    config.preserveWhitespace = this._getConfigOrDefault('preserveWhitespace')\n    config.classes = this._getConfigOrDefault('classes')\n    config.trimOnValidation = this._getConfigOrDefault('trimOnValidation')\n    config.linkPlaceholder = this._getConfigOrDefault('linkPlaceholder')\n    config.compareValues = this._getConfigOrDefault('compareValues')\n    config.filterNull = this._getConfigOrDefault('filterNull')\n    config.debounceTime = this._getConfigOrDefault('debounceTime')\n\n    this._config.next(config)\n\n    // setTimeout bc ngx-quill library doesn't listen for input changes,\n    // so we must destroy and create the component each time config is updated\n    setTimeout(() => {\n      this._configSet.next(true)\n    }, 0)\n  }\n\n  private _getConfigOrDefault<K extends keyof TheSeamQuillEditorConfig>(prop: K): TheSeamQuillEditorConfig[K] {\n    if (this._customConfig && Object.prototype.hasOwnProperty.call(this._customConfig, prop)) {\n      return this._customConfig[prop]\n    }\n    return THESEAM_QUILL_EDITOR_CONFIG_DEFAULT[prop]\n  }\n\n  private _updateQuillConfig() {\n    if (this._configSet.value) {\n      this._buildQuillConfig()\n    }\n  }\n\n  // Not usable, bc config has to be set immediately, potentially before mentions populate.\n  // To set customDataAttributes, provide a custom config.\n  // private _getCustomDataAttributes(mentions: TheSeamQuillMentionMenuOption[]): string[] {\n  //   return mentions.reduce((acc, mention) => {\n  //     const keys = Object.keys(mention)\n\n  //     keys.forEach(key => {\n  //       if (acc.findIndex(a => a === key) === -1) {\n  //         acc.push(key)\n  //       }\n  //     })\n\n  //     return acc\n  //   }, <string[]>[] satisfies string[])\n  // }\n\n  get value(): string | undefined | null {\n    return this._value\n  }\n  set value(value: string | undefined | null) {\n    this._value = value\n\n    if (this.onChange) { this.onChange(value) }\n    if (this.onTouched) { this.onTouched() }\n  }\n  private _value: string | undefined | null\n\n  writeValue(value: any): void {\n    this._isWritingValue = true\n\n    this.formControl.setValue(value)\n    this.value = value\n\n    this._isWritingValue = false\n  }\n\n  registerOnChange(fn: any): void {\n    this.onChange = fn\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.readOnly = isDisabled\n  }\n\n  _onEditorCreated(event: any) {\n    this.quillEditorCreated.emit(event)\n  }\n\n  _onEditorChanged(event: EditorChangeContent | EditorChangeSelection) {\n    this.quillEditorChanged.emit(event)\n  }\n\n  _onContentChanged(event: ContentChange) {\n    this.quillContentChanged.emit(event)\n\n    this._updateMentionsFromDelta(event.content)\n  }\n\n  _onSelectionChanged(event: SelectionChange) {\n    this.quillSelectionChanged.emit(event)\n  }\n\n  _onFocus(event: Focus) {\n    this.quillFocus.emit(event)\n  }\n\n  _onBlur(event: Blur) {\n    this.quillBlur.emit(event)\n\n    if (this.onTouched) {\n      this.onTouched()\n    }\n  }\n\n  /**\n   * Hacky way to track mention inserts/deletes\n   */\n  private _updateMentionsFromDelta(content: Delta) {\n    if (notNullOrUndefined(content.ops)) {\n      const contentMentionIds = content.ops.map(o => o.insert?.mention?.id).filter(notNullOrUndefined)\n      const selectedMentions = [ ...this._selectedMentions.value ]\n      const mentionOptions = [ ...this._mentionItems.value || [] ]\n\n      const newMentions: TheSeamQuillMentionMenuOption[] = contentMentionIds.reduce((acc, mentionId) => {\n        const insertMention = mentionOptions.find(m => isMentionMenuOption(m) && m.id === mentionId)\n\n        if (notNullOrUndefined(insertMention)) {\n          acc.push(insertMention)\n        }\n        else {\n          console.warn('Mention addition failed! Selected mention option not found:', mentionId)\n        }\n\n        return acc\n      }, <TheSeamQuillMentionMenuOption[]>[])\n\n      let emitUpdate = false\n      if (selectedMentions.length !== newMentions.length) {\n        // if the length has changed, we know an update occurred\n        emitUpdate = true\n      }\n      else {\n        // otherwise, test ids for old and new items to see if we need to emit a change\n        const selectedMentionIds = this._selectedMentions.value.map(m => m.id)\n        const newMentionIds = newMentions.map(m => m.id)\n\n        if (\n          selectedMentionIds.findIndex(m => !newMentionIds.includes(m)) !== -1 ||\n          newMentionIds.findIndex(m => !selectedMentionIds.includes(m)) !== -1\n        ) {\n          emitUpdate = true\n        }\n      }\n\n      if (emitUpdate) {\n        this._selectedMentions.next(newMentions)\n      }\n    }\n  }\n}\n","<div class=\"editor\" *ngIf=\"configSet$ | async\" [class.initializing]=\"!(initialized$ | async)\">\n  <ng-container *ngIf=\"config$ | async as config\">\n    <quill-editor\n      #quillEditor\n      seamInput\n      [class.disabled]=\"readOnly\"\n      [attr.disabled]=\"readOnly\"\n      [formControl]=\"formControl\"\n      [placeholder]=\"placeholder\"\n      [readOnly]=\"readOnly\"\n      [required]=\"required\"\n      [minLength]=\"minLength\"\n      [maxLength]=\"maxLength\"\n      [format]=\"config.format\"\n      [theme]=\"config.theme\"\n      [modules]=\"config.modules\"\n      [debug]=\"config.debug\"\n      [formats]=\"config.formats\"\n      [customToolbarPosition]=\"config.customToolbarPosition\"\n      [sanitize]=\"config.sanitize\"\n      [styles]=\"config.styles\"\n      [strict]=\"config.strict\"\n      [scrollingContainer]=\"config.scrollingContainer\"\n      [bounds]=\"config.bounds\"\n      [customOptions]=\"config.customOptions\"\n      [customModules]=\"config.customModules\"\n      [trackChanges]=\"config.trackChanges\"\n      [preserveWhitespace]=\"config.preserveWhitespace\"\n      [classes]=\"config.classes\"\n      [trimOnValidation]=\"config.trimOnValidation\"\n      [linkPlaceholder]=\"config.linkPlaceholder\"\n      [compareValues]=\"config.compareValues\"\n      [filterNull]=\"config.filterNull\"\n      [debounceTime]=\"config.debounceTime\"\n      [class.can-resize]=\"resizable\"\n      (onEditorCreated)=\"_onEditorCreated($event)\"\n      (onEditorChanged)=\"_onEditorChanged($event)\"\n      (onContentChanged)=\"_onContentChanged($event)\"\n      (onSelectionChanged)=\"_onSelectionChanged($event)\"\n      (onFocus)=\"_onFocus($event)\"\n      (onBlur)=\"_onBlur($event)\"></quill-editor>\n    <ng-container *ngIf=\"displayCharacterCounter\">\n      <ng-container\n        [ngTemplateOutlet]=\"characterCounterTpl\"\n        [ngTemplateOutletContext]=\"{ $implicit: characterCount$ | async, minLength: minLength, maxLength: maxLength, characterCount: characterCount$ | async }\"></ng-container>\n    </ng-container>\n  </ng-container>\n</div>\n\n<ng-template #characterCounter let-implicit let-minLength=\"minLength\" let-maxLength=\"maxLength\" let-characterCount=\"characterCount\">\n  <div class=\"small text-black-50 text-right\">\n    <ng-container *ngIf=\"characterCount || characterCount === 0\">\n      Character Count:\n      <span [class.text-danger]=\"characterCount && ((maxLength && characterCount > maxLength) || (minLength && characterCount < minLength))\">\n        {{ characterCount | number }}\n      </span>\n      <ng-container *ngIf=\"maxLength\">\n        / {{ maxLength }}\n      </ng-container>\n      <span *ngIf=\"minLength\" class=\"font-italic\">\n        (minimum {{ minLength }} expected)\n      </span>\n    </ng-container>\n  </div>\n</ng-template>\n"]}