mat-contenteditable
Version:
Angular contenteditable directive for Angular forms and Material Design
704 lines (694 loc) • 59.4 kB
JavaScript
import { Directive, ElementRef, Renderer2, HostListener, Input, HostBinding, Optional, Self, ViewContainerRef, NgModule } from '@angular/core';
import { MatFormFieldControl } from '@angular/material/form-field';
import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
import { ErrorStateMatcher, mixinErrorState } from '@angular/material/core';
import { coerceBooleanProperty } from '@angular/cdk/coercion';
import { Subject } from 'rxjs';
import { MatFormFieldControl as MatFormFieldControl$1, ErrorStateMatcher as ErrorStateMatcher$1 } from '@angular/material';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* \@docs-private
*/
class MatInputBase {
/**
* @param {?} _defaultErrorStateMatcher
* @param {?} _parentForm
* @param {?} _parentFormGroup
* @param {?} ngControl
*/
constructor(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl) {
this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
this._parentForm = _parentForm;
this._parentFormGroup = _parentFormGroup;
this.ngControl = ngControl;
}
}
/** @type {?} */
const _MatInputMixinBase = mixinErrorState(MatInputBase);
class MatContenteditableDirective extends _MatInputMixinBase {
/**
* @param {?} elementRef
* @param {?} renderer
* @param {?} ngControl
* @param {?} _parentForm
* @param {?} _parentFormGroup
* @param {?} _defaultErrorStateMatcher
*/
constructor(elementRef, renderer, ngControl, _parentForm, _parentFormGroup, _defaultErrorStateMatcher) {
super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);
this.elementRef = elementRef;
this.renderer = renderer;
this.ngControl = ngControl;
this.stateChanges = new Subject();
this.id = `mat-input-${MatContenteditableDirective.nextId++}`;
this.focused = false;
this.contentEmpty = ['<br>', '<div><br></div>'];
this._required = false;
this._disabled = false;
this.controlType = 'mat-input';
this.describedBy = '';
this.propValueAccessor = 'innerHTML';
// Setting the value accessor directly (instead of using
// the providers) to avoid running into a circular import.
if (this.ngControl != null) {
this.ngControl.valueAccessor = this;
}
}
/**
* @return {?}
*/
get value() { return this.elementRef.nativeElement[this.propValueAccessor]; }
/**
* @param {?} value
* @return {?}
*/
set value(value) {
if (value !== this.value) {
this.elementRef.nativeElement[this.propValueAccessor] = value;
this.stateChanges.next();
}
}
/**
* @return {?}
*/
get placeholder() {
return this._placeholder;
}
/**
* @param {?} plh
* @return {?}
*/
set placeholder(plh) {
this._placeholder = plh;
this.stateChanges.next();
}
/**
* @return {?}
*/
get empty() {
return !this.value || this.contentEmpty.includes(this.value);
}
/**
* @return {?}
*/
get shouldLabelFloat() { return this.focused || !this.empty; }
/**
* @return {?}
*/
get required() {
return this._required;
}
/**
* @param {?} req
* @return {?}
*/
set required(req) {
this._required = coerceBooleanProperty(req);
this.stateChanges.next();
}
/**
* @return {?}
*/
get disabled() {
return this._disabled;
}
/**
* @param {?} dis
* @return {?}
*/
set disabled(dis) {
this._disabled = coerceBooleanProperty(dis);
this.stateChanges.next();
}
/**
* @return {?}
*/
ngDoCheck() {
if (this.ngControl) {
// We need to re-evaluate this on every change detection cycle, because there are some
// error triggers that we can't subscribe to (e.g. parent form submissions). This means
// that whatever logic is in here has to be super lean or we risk destroying the performance.
this.updateErrorState();
}
}
/**
* @return {?}
*/
callOnChange() {
if (typeof this.onChange === 'function') {
this.onChange(this.elementRef.nativeElement[this.propValueAccessor]);
}
}
/**
* @return {?}
*/
callOnFocused() {
if (this.focused !== true) {
this.focused = true;
this.stateChanges.next();
}
}
/**
* @return {?}
*/
callOnTouched() {
if (typeof this.onTouched === 'function') {
this.onTouched();
}
if (this.focused !== false) {
this.focused = false;
this.stateChanges.next();
}
}
/**
* @param {?} ids
* @return {?}
*/
setDescribedByIds(ids) {
this.describedBy = ids.join(' ');
}
/**
* @return {?}
*/
onContainerClick() { this.elementRef.nativeElement.focus(); }
/**
* Writes a new value to the element.
* This method will be called by the forms API to write
* to the view when programmatic (model -> view) changes are requested.
*
* See: [ControlValueAccessor](https://angular.io/api/forms/ControlValueAccessor#members)
* @param {?} value
* @return {?}
*/
writeValue(value) {
/** @type {?} */
const normalizedValue = value == null ? '' : value;
this.renderer.setProperty(this.elementRef.nativeElement, this.propValueAccessor, normalizedValue);
}
/**
* Registers a callback function that should be called when
* the control's value changes in the UI.
*
* This is called by the forms API on initialization so it can update
* the form model when values propagate from the view (view -> model).
* @param {?} fn
* @return {?}
*/
registerOnChange(fn) {
this.onChange = fn;
}
/**
* Registers a callback function that should be called when the control receives a blur event.
* This is called by the forms API on initialization so it can update the form model on blur.
* @param {?} fn
* @return {?}
*/
registerOnTouched(fn) {
this.onTouched = fn;
}
/**
* This function is called by the forms API when the control status changes to or from "DISABLED".
* Depending on the value, it should enable or disable the appropriate DOM element.
* @param {?} isDisabled
* @return {?}
*/
setDisabledState(isDisabled) {
if (isDisabled) {
this.renderer.setAttribute(this.elementRef.nativeElement, 'disabled', 'true');
this.removeDisabledState = this.renderer.listen(this.elementRef.nativeElement, 'keydown', this.listenerDisabledState);
}
else {
if (this.removeDisabledState) {
this.renderer.removeAttribute(this.elementRef.nativeElement, 'disabled');
this.removeDisabledState();
}
}
}
/**
* @param {?} e
* @return {?}
*/
listenerDisabledState(e) {
e.preventDefault();
}
}
/**
* Implemented as part of MatFormFieldControl.
* See https://material.angular.io/guide/creating-a-custom-form-field-control
*/
MatContenteditableDirective.nextId = 0;
MatContenteditableDirective.decorators = [
{ type: Directive, args: [{
selector: '[contenteditable]',
providers: [
{ provide: MatFormFieldControl, useExisting: MatContenteditableDirective },
]
},] }
];
/** @nocollapse */
MatContenteditableDirective.ctorParameters = () => [
{ type: ElementRef },
{ type: Renderer2 },
{ type: NgControl, decorators: [{ type: Optional }, { type: Self }] },
{ type: NgForm, decorators: [{ type: Optional }] },
{ type: FormGroupDirective, decorators: [{ type: Optional }] },
{ type: ErrorStateMatcher }
];
MatContenteditableDirective.propDecorators = {
value: [{ type: Input }],
id: [{ type: HostBinding }],
placeholder: [{ type: Input }],
contentEmpty: [{ type: Input }],
required: [{ type: Input }],
disabled: [{ type: Input }],
errorState: [{ type: HostBinding, args: ['attr.aria-invalid',] }],
errorStateMatcher: [{ type: Input }],
describedBy: [{ type: HostBinding, args: ['attr.aria-describedby',] }],
propValueAccessor: [{ type: Input }],
callOnChange: [{ type: HostListener, args: ['input',] }],
callOnFocused: [{ type: HostListener, args: ['focus',] }],
callOnTouched: [{ type: HostListener, args: ['blur',] }]
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class MatCkeditorDirective extends _MatInputMixinBase {
/**
* @param {?} viewRef
* @param {?} ngControl
* @param {?} _parentForm
* @param {?} _parentFormGroup
* @param {?} _defaultErrorStateMatcher
*/
constructor(
// @Host() @Self() @Optional() public editor: CKEditorComponent,
viewRef, ngControl, _parentForm, _parentFormGroup, _defaultErrorStateMatcher) {
super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);
this.viewRef = viewRef;
this.ngControl = ngControl;
this.stateChanges = new Subject();
this.id = `mat-input-${MatCkeditorDirective.nextId++}`;
// Need support from Ckeditor
this.placeholder = '';
this.contentEmpty = ['<br>', '<p> </p>'];
this.focused = false;
this.required = false;
this.controlType = 'mat-input';
this.describedBy = '';
}
/**
* @return {?}
*/
get value() {
return !!this.editor.editorInstance && this.editor.editorInstance.getData();
}
/**
* @param {?} value
* @return {?}
*/
set value(value) {
if (value !== this.value) {
this.editor.data = value;
this.stateChanges.next();
}
}
/**
* @return {?}
*/
get empty() {
return !this.value || this.contentEmpty.includes(this.value);
}
/**
* @return {?}
*/
get shouldLabelFloat() { return this.focused || !this.empty; }
/**
* @param {?} isDisabled
* @return {?}
*/
set disabled(isDisabled) {
this.editor.setDisabledState(isDisabled);
this.stateChanges.next();
}
/**
* @return {?}
*/
get disabled() {
return this.editor.disabled;
}
/**
* @return {?}
*/
ngOnInit() {
// Can't use injection to get component reference
// https://github.com/angular/angular/issues/8277
this.editor = this.viewRef['_data'].componentView.component;
this.editor.blur.subscribe(() => {
this.focused = false;
this.stateChanges.next();
});
this.editor.focus.subscribe(() => {
this.focused = true;
this.stateChanges.next();
});
}
/**
* @return {?}
*/
ngDoCheck() {
if (this.ngControl) {
// We need to re-evaluate this on every change detection cycle, because there are some
// error triggers that we can't subscribe to (e.g. parent form submissions). This means
// that whatever logic is in here has to be super lean or we risk destroying the performance.
this.updateErrorState();
}
}
/**
* @param {?} ids
* @return {?}
*/
setDescribedByIds(ids) {
this.describedBy = ids.join(' ');
}
/**
* @return {?}
*/
onContainerClick() {
if (this.editor.editorInstance) {
this.editor.editorInstance.editing.view.focus();
this.stateChanges.next();
}
}
}
/**
* Implemented as part of MatFormFieldControl.
* See https://material.angular.io/guide/creating-a-custom-form-field-control
*/
MatCkeditorDirective.nextId = 0;
MatCkeditorDirective.decorators = [
{ type: Directive, args: [{
selector: '[matCkeditor]',
providers: [
{ provide: MatFormFieldControl$1, useExisting: MatCkeditorDirective },
]
},] }
];
/** @nocollapse */
MatCkeditorDirective.ctorParameters = () => [
{ type: ViewContainerRef },
{ type: NgControl, decorators: [{ type: Optional }, { type: Self }] },
{ type: NgForm, decorators: [{ type: Optional }] },
{ type: FormGroupDirective, decorators: [{ type: Optional }] },
{ type: ErrorStateMatcher$1 }
];
MatCkeditorDirective.propDecorators = {
value: [{ type: Input }],
id: [{ type: HostBinding }],
placeholder: [{ type: Input }],
contentEmpty: [{ type: Input }],
required: [{ type: Input }],
disabled: [{ type: Input }],
errorState: [{ type: HostBinding, args: ['attr.aria-invalid',] }],
errorStateMatcher: [{ type: Input }],
describedBy: [{ type: HostBinding, args: ['attr.aria-describedby',] }]
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class MatCkeditorBalloonDirective extends MatCkeditorDirective {
/**
* @param {?} show
* @return {?}
*/
set toolbar(show) {
if (this.editor && show !== this.toolbarOpen) {
/** @type {?} */
const balloon = this.editor.editorInstance.plugins.get('BalloonToolbar');
if (show) {
this.showToolbar(balloon);
}
else {
balloon.hide();
this.toolbarOpen = false;
}
}
}
/**
* @return {?}
*/
ngOnInit() {
super.ngOnInit();
this.editor.ready.subscribe(editor => {
/** @type {?} */
const balloon = editor.plugins.get('BalloonToolbar');
balloon.stopListening(editor.model.document.selection, 'change:range');
balloon.stopListening(balloon, '_selectionChangeDebounced');
});
this.editor.focus.subscribe(() => {
if (this.toolbarOpen) {
/** @type {?} */
const balloon = this.editor.editorInstance.plugins.get('BalloonToolbar');
this.showToolbar(balloon);
}
});
}
/**
* @param {?} balloon
* @return {?}
*/
showToolbar(balloon) {
if (!balloon._balloon.hasView(balloon.toolbarView)) {
balloon.listenTo(this.editor.editorInstance.ui, 'update', () => {
balloon._balloon.updatePosition(balloon._getBalloonPositionData());
});
balloon._balloon.add({
view: balloon.toolbarView,
position: balloon._getBalloonPositionData(),
balloonClassName: 'ck-toolbar-container'
});
this.toolbarOpen = true;
}
}
}
MatCkeditorBalloonDirective.decorators = [
{ type: Directive, args: [{
selector: '[matCkeditorBalloon]',
providers: [
{ provide: MatFormFieldControl, useExisting: MatCkeditorBalloonDirective },
]
},] }
];
MatCkeditorBalloonDirective.propDecorators = {
toolbar: [{ type: Input }]
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class FormFieldSizerDirective {
/**
* @param {?} renderer
* @param {?} elementRef
*/
constructor(renderer, elementRef) {
this.renderer = renderer;
this.elementRef = elementRef;
}
/**
* @return {?}
*/
ngAfterContentInit() {
this.updateSize();
}
/**
* @return {?}
*/
updateSize() {
/** @type {?} */
const infix = this.getElement('mat-form-field-infix');
this.renderer.removeStyle(infix, 'min-height');
setTimeout(() => {
/** @type {?} */
const wrapper = this.getElement('mat-form-field-wrapper');
/** @type {?} */
const offset = this.elementRef.nativeElement.offsetHeight -
wrapper.offsetHeight -
parseFloat(getComputedStyle(wrapper).marginTop) -
parseFloat(getComputedStyle(wrapper).marginBottom) +
parseFloat(getComputedStyle(infix).height);
this.renderer.setStyle(infix, 'min-height', `${offset}px`);
});
}
/**
* @param {?} name
* @return {?}
*/
getElement(name) {
return this.elementRef.nativeElement.getElementsByClassName(name).item(0);
}
}
FormFieldSizerDirective.decorators = [
{ type: Directive, args: [{
selector: '[formFieldSizer]'
},] }
];
/** @nocollapse */
FormFieldSizerDirective.ctorParameters = () => [
{ type: Renderer2 },
{ type: ElementRef }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class MatContenteditableModule {
}
MatContenteditableModule.decorators = [
{ type: NgModule, args: [{
imports: [],
declarations: [MatContenteditableDirective, MatCkeditorDirective, MatCkeditorBalloonDirective, FormFieldSizerDirective],
exports: [MatContenteditableDirective, MatCkeditorDirective, MatCkeditorBalloonDirective, FormFieldSizerDirective],
},] }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @param {?} html
* @return {?}
*/
function getText(html) {
if (html) {
/** @type {?} */
const element = document.createElement('span');
element.innerHTML = html;
return element.textContent.replace(/\s/g, '');
}
return '';
}
/**
* \@description
* Provides a set of built-in validators that can be used by form controls.
*
* A validator is a function that processes a `FormControl` or collection of
* controls and returns an error map or null. A null map means that validation has passed.
*
* @see [Form Validation](/guide/form-validation)
*
* \@publicApi
*/
class HtmlValidators {
/**
* \@description
* Validator that requires the control have a non-empty value.
*
* \@usageNotes
*
* ### Validate that the field is non-empty
*
* ```typescript
* const control = new FormControl('', Validators.required);
*
* console.log(control.errors); // {required: true}
* ```
*
* @param {?} control
* @return {?} An error map with the `required` property
* if the validation check fails, otherwise `null`.
*
*/
static required(control) {
/** @type {?} */
const text = getText(control.value);
return text ? null : { 'required': true };
}
/**
* \@description
* Validator that requires the length of the control's value to be greater than or equal
* to the provided minimum length. This validator is also provided by default if you use the
* the HTML5 `minlength` attribute.
*
* \@usageNotes
*
* ### Validate that the field has a minimum of 3 characters
*
* ```typescript
* const control = new FormControl('ng', Validators.minLength(3));
*
* console.log(control.errors); // {minlength: {requiredLength: 3, actualLength: 2}}
* ```
*
* ```html
* <input minlength="5">
* ```
*
* @param {?} minLength
* @return {?} A validator function that returns an error map with the
* `minlength` if the validation check fails, otherwise `null`.
*/
static minLength(minLength) {
/** @type {?} */
const fn = (control) => {
/** @type {?} */
const text = getText(control.value);
if (text) {
return text.length < minLength ?
{ 'minlength': { 'requiredLength': minLength, 'actualLength': text.length } } :
null;
}
return null; // don't validate empty values to allow optional controls
};
return fn;
}
/**
* \@description
* Validator that requires the length of the control's value to be less than or equal
* to the provided maximum length. This validator is also provided by default if you use the
* the HTML5 `maxlength` attribute.
*
* \@usageNotes
*
* ### Validate that the field has maximum of 5 characters
*
* ```typescript
* const control = new FormControl('Angular', Validators.maxLength(5));
*
* console.log(control.errors); // {maxlength: {requiredLength: 5, actualLength: 7}}
* ```
*
* ```html
* <input maxlength="5">
* ```
*
* @param {?} maxLength
* @return {?} A validator function that returns an error map with the
* `maxlength` property if the validation check fails, otherwise `null`.
*/
static maxLength(maxLength) {
/** @type {?} */
const fn = (control) => {
/** @type {?} */
const text = getText(control.value);
return text.length > maxLength ?
{ 'maxlength': { 'requiredLength': maxLength, 'actualLength': text.length } } :
null;
};
return fn;
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
export { _MatInputMixinBase, MatContenteditableDirective, MatCkeditorDirective, MatCkeditorBalloonDirective, FormFieldSizerDirective, MatContenteditableModule, HtmlValidators };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mat-contenteditable.js.map","sources":["ng://mat-contenteditable/lib/mat-contenteditable.directive.ts","ng://mat-contenteditable/lib/mat-ckeditor.directive.ts","ng://mat-contenteditable/lib/mat-ckeditor-balloon.directive.ts","ng://mat-contenteditable/lib/form-field-sizer.directive.ts","ng://mat-contenteditable/lib/mat-contenteditable.module.ts","ng://mat-contenteditable/lib/validators.ts"],"sourcesContent":["import {\n  Directive,\n  ElementRef,\n  Renderer2,\n  HostListener,\n  Input,\n  HostBinding,\n  Optional,\n  Self,\n  DoCheck,\n} from '@angular/core';\nimport { MatFormFieldControl } from '@angular/material/form-field';\nimport { ControlValueAccessor, FormGroupDirective, NgControl, NgForm } from '@angular/forms';\nimport { ErrorStateMatcher, mixinErrorState, CanUpdateErrorStateCtor, CanUpdateErrorState } from '@angular/material/core';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Subject } from 'rxjs';\n\n// Boilerplate for applying mixins to MatInput.\n/** @docs-private */\nclass MatInputBase {\n  constructor(public _defaultErrorStateMatcher: ErrorStateMatcher,\n              public _parentForm: NgForm,\n              public _parentFormGroup: FormGroupDirective,\n              /** @docs-private */\n              public ngControl: NgControl) {}\n}\nexport const _MatInputMixinBase: CanUpdateErrorStateCtor & typeof MatInputBase =\n  mixinErrorState(MatInputBase);\n\n\n@Directive({\n  selector: '[contenteditable]',\n  providers: [\n    { provide: MatFormFieldControl, useExisting: MatContenteditableDirective },\n  ]\n})\nexport class MatContenteditableDirective extends _MatInputMixinBase\n  implements ControlValueAccessor, MatFormFieldControl<string>, DoCheck, CanUpdateErrorState {\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * See https://material.angular.io/guide/creating-a-custom-form-field-control\n   */\n  static nextId = 0;\n\n  @Input()\n  get value(): string { return this.elementRef.nativeElement[this.propValueAccessor]; }\n  set value(value: string) {\n    if (value !== this.value) {\n      this.elementRef.nativeElement[this.propValueAccessor] = value;\n      this.stateChanges.next();\n    }\n  }\n\n  readonly stateChanges: Subject<void> = new Subject<void>();\n\n  @HostBinding() id = `mat-input-${MatContenteditableDirective.nextId++}`;\n\n  @Input()\n  get placeholder() {\n    return this._placeholder;\n  }\n  set placeholder(plh) {\n    this._placeholder = plh;\n    this.stateChanges.next();\n  }\n  private _placeholder: string;\n\n  focused = false;\n\n  @Input() contentEmpty: Array<string> = ['<br>', '<div><br></div>'];\n  get empty(): boolean {\n    return !this.value || this.contentEmpty.includes(this.value);\n  }\n\n  get shouldLabelFloat(): boolean { return this.focused || !this.empty; }\n\n  @Input()\n  get required() {\n    return this._required;\n  }\n  set required(req) {\n    this._required = coerceBooleanProperty(req);\n    this.stateChanges.next();\n  }\n  private _required = false;\n\n  @Input()\n  get disabled() {\n    return this._disabled;\n  }\n  set disabled(dis) {\n    this._disabled = coerceBooleanProperty(dis);\n    this.stateChanges.next();\n  }\n  private _disabled = false;\n\n  @HostBinding('attr.aria-invalid') errorState: boolean;\n  @Input() errorStateMatcher: ErrorStateMatcher;\n\n  controlType = 'mat-input';\n\n  @HostBinding('attr.aria-describedby') describedBy = '';\n\n\n  // Part of ControlValueAccessor\n  private onChange: (value: string) => void;\n  private onTouched: () => void;\n  private removeDisabledState: () => void;\n\n  @Input() propValueAccessor = 'innerHTML';\n\n  constructor(\n    private elementRef: ElementRef,\n    private renderer: Renderer2,\n    @Optional() @Self() public ngControl: NgControl,\n    @Optional() _parentForm: NgForm,\n    @Optional() _parentFormGroup: FormGroupDirective,\n    _defaultErrorStateMatcher: ErrorStateMatcher,\n  ) {\n    super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\n    // Setting the value accessor directly (instead of using\n    // the providers) to avoid running into a circular import.\n    if (this.ngControl != null) { this.ngControl.valueAccessor = this; }\n  }\n\n  ngDoCheck() {\n    if (this.ngControl) {\n      // We need to re-evaluate this on every change detection cycle, because there are some\n      // error triggers that we can't subscribe to (e.g. parent form submissions). This means\n      // that whatever logic is in here has to be super lean or we risk destroying the performance.\n      this.updateErrorState();\n    }\n  }\n\n  @HostListener('input')\n  callOnChange() {\n    if (typeof this.onChange === 'function') {\n      this.onChange(this.elementRef.nativeElement[this.propValueAccessor]);\n    }\n  }\n\n  @HostListener('focus')\n  callOnFocused() {\n    if (this.focused !== true) {\n      this.focused = true;\n      this.stateChanges.next();\n    }\n  }\n\n  @HostListener('blur')\n  callOnTouched() {\n    if (typeof this.onTouched === 'function') {\n      this.onTouched();\n    }\n    if (this.focused !== false) {\n      this.focused = false;\n      this.stateChanges.next();\n    }\n  }\n\n  setDescribedByIds(ids: string[]) {\n    this.describedBy = ids.join(' ');\n  }\n\n  onContainerClick() { this.elementRef.nativeElement.focus(); }\n\n  /**\n   * Writes a new value to the element.\n   * This method will be called by the forms API to write\n   * to the view when programmatic (model -> view) changes are requested.\n   *\n   * See: [ControlValueAccessor](https://angular.io/api/forms/ControlValueAccessor#members)\n   */\n  writeValue(value: any): void {\n    const normalizedValue = value == null ? '' : value;\n    this.renderer.setProperty(this.elementRef.nativeElement, this.propValueAccessor, normalizedValue);\n  }\n\n  /**\n   * Registers a callback function that should be called when\n   * the control's value changes in the UI.\n   *\n   * This is called by the forms API on initialization so it can update\n   * the form model when values propagate from the view (view -> model).\n   */\n  registerOnChange(fn: () => void): void {\n    this.onChange = fn;\n  }\n\n  /**\n   * Registers a callback function that should be called when the control receives a blur event.\n   * This is called by the forms API on initialization so it can update the form model on blur.\n   */\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  /**\n   * This function is called by the forms API when the control status changes to or from \"DISABLED\".\n   * Depending on the value, it should enable or disable the appropriate DOM element.\n   */\n  setDisabledState(isDisabled: boolean): void {\n    if (isDisabled) {\n      this.renderer.setAttribute(this.elementRef.nativeElement, 'disabled', 'true');\n      this.removeDisabledState = this.renderer.listen(this.elementRef.nativeElement, 'keydown', this.listenerDisabledState);\n    } else {\n      if (this.removeDisabledState) {\n        this.renderer.removeAttribute(this.elementRef.nativeElement, 'disabled');\n        this.removeDisabledState();\n      }\n    }\n  }\n\n  private listenerDisabledState(e: KeyboardEvent) {\n    e.preventDefault();\n  }\n}\n","import { Directive, Input, HostBinding, ViewContainerRef, OnInit, Optional, Self, DoCheck } from '@angular/core';\nimport { MatFormFieldControl, ErrorStateMatcher, CanUpdateErrorState } from '@angular/material';\n// import { CKEditorComponent } from '@ckeditor/ckeditor5-angular//ckeditor.component';\nimport { Subject } from 'rxjs';\nimport { NgControl, NgForm, FormGroupDirective } from '@angular/forms';\nimport { _MatInputMixinBase } from './mat-contenteditable.directive';\n\n\n@Directive({\n  selector: '[matCkeditor]',\n  providers: [\n    { provide: MatFormFieldControl, useExisting: MatCkeditorDirective },\n  ]\n})\nexport class MatCkeditorDirective  extends _MatInputMixinBase\n  implements MatFormFieldControl<string>, DoCheck, CanUpdateErrorState , OnInit {\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * See https://material.angular.io/guide/creating-a-custom-form-field-control\n   */\n  static nextId = 0;\n\n  @Input()\n  get value(): string {\n    return !!this.editor.editorInstance && this.editor.editorInstance.getData();\n  }\n  set value(value: string) {\n    if (value !== this.value) {\n      this.editor.data = value;\n      this.stateChanges.next();\n    }\n  }\n\n  readonly stateChanges: Subject<void> = new Subject<void>();\n\n  @HostBinding() id = `mat-input-${MatCkeditorDirective.nextId++}`;\n\n  // Need support from Ckeditor\n  @Input() placeholder = '';\n\n  @Input() contentEmpty: string[] = ['<br>', '<p>&nbsp;</p>'];\n  get empty(): boolean {\n    return !this.value || this.contentEmpty.includes(this.value);\n  }\n\n  get shouldLabelFloat(): boolean { return this.focused || !this.empty; }\n\n  focused = false;\n\n  @Input() required = false;\n\n  @Input()\n  set disabled(isDisabled: boolean) {\n    this.editor.setDisabledState(isDisabled);\n    this.stateChanges.next();\n  }\n  get disabled() {\n    return this.editor.disabled;\n  }\n\n  @HostBinding('attr.aria-invalid') errorState: boolean;\n  @Input() errorStateMatcher: ErrorStateMatcher;\n\n  controlType = 'mat-input';\n\n  @HostBinding('attr.aria-describedby') describedBy = '';\n\n  protected editor;\n\n  constructor(\n    // @Host() @Self() @Optional() public editor: CKEditorComponent,\n    protected readonly viewRef: ViewContainerRef,\n    @Optional() @Self() public ngControl: NgControl,\n    @Optional() _parentForm: NgForm,\n    @Optional() _parentFormGroup: FormGroupDirective,\n    _defaultErrorStateMatcher: ErrorStateMatcher,\n  ) {\n    super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\n  }\n\n  ngOnInit() {\n    // Can't use injection to get component reference\n    // https://github.com/angular/angular/issues/8277\n    this.editor = this.viewRef['_data'].componentView.component;\n    this.editor.blur.subscribe(() => {\n      this.focused = false;\n      this.stateChanges.next();\n    });\n    this.editor.focus.subscribe(() => {\n      this.focused = true;\n      this.stateChanges.next();\n    });\n  }\n\n  ngDoCheck() {\n    if (this.ngControl) {\n      // We need to re-evaluate this on every change detection cycle, because there are some\n      // error triggers that we can't subscribe to (e.g. parent form submissions). This means\n      // that whatever logic is in here has to be super lean or we risk destroying the performance.\n      this.updateErrorState();\n    }\n  }\n\n  setDescribedByIds(ids: string[]) {\n    this.describedBy = ids.join(' ');\n  }\n\n  onContainerClick() {\n    if (this.editor.editorInstance) {\n      this.editor.editorInstance.editing.view.focus();\n      this.stateChanges.next();\n    }\n  }\n\n}\n","import { Directive, Input } from '@angular/core';\nimport { MatFormFieldControl } from '@angular/material/form-field';\n\nimport { MatCkeditorDirective } from './mat-ckeditor.directive';\n\n@Directive({\n  selector: '[matCkeditorBalloon]',\n  providers: [\n    { provide: MatFormFieldControl, useExisting: MatCkeditorBalloonDirective },\n  ]\n})\nexport class MatCkeditorBalloonDirective extends MatCkeditorDirective {\n\n  @Input()\n  set toolbar(show: boolean) {\n    if (this.editor && show !== this.toolbarOpen) {\n      const balloon = this.editor.editorInstance.plugins.get('BalloonToolbar');\n      if (show) {\n        this.showToolbar(balloon);\n      } else {\n        balloon.hide();\n        this.toolbarOpen = false;\n      }\n    }\n  }\n  private toolbarOpen: boolean;\n\n  ngOnInit() {\n    super.ngOnInit();\n    this.editor.ready.subscribe(editor => {\n      const balloon = editor.plugins.get('BalloonToolbar');\n      balloon.stopListening(editor.model.document.selection, 'change:range');\n      balloon.stopListening(balloon, '_selectionChangeDebounced');\n    });\n    this.editor.focus.subscribe(() => {\n      if (this.toolbarOpen) {\n        const balloon = this.editor.editorInstance.plugins.get('BalloonToolbar');\n        this.showToolbar(balloon);\n      }\n    });\n  }\n\n  private showToolbar(balloon) {\n    if (!balloon._balloon.hasView(balloon.toolbarView)) {\n      balloon.listenTo(this.editor.editorInstance.ui, 'update', () => {\n        balloon._balloon.updatePosition(balloon._getBalloonPositionData());\n      });\n      balloon._balloon.add({\n        view: balloon.toolbarView,\n        position: balloon._getBalloonPositionData(),\n        balloonClassName: 'ck-toolbar-container'\n      });\n      this.toolbarOpen = true;\n    }\n  }\n\n}\n","import { Directive, Renderer2, ElementRef, AfterContentInit } from '@angular/core';\n\n@Directive({\n  selector: '[formFieldSizer]'\n})\nexport class FormFieldSizerDirective implements AfterContentInit {\n\n  constructor(\n    private readonly renderer: Renderer2,\n    private readonly elementRef: ElementRef,\n  ) { }\n\n  ngAfterContentInit(): void {\n    this.updateSize();\n  }\n\n  updateSize() {\n    const infix = this.getElement('mat-form-field-infix');\n    this.renderer.removeStyle(infix, 'min-height');\n\n    setTimeout(() => {\n      const wrapper = this.getElement('mat-form-field-wrapper');\n      const offset = this.elementRef.nativeElement.offsetHeight -\n        wrapper.offsetHeight -\n        parseFloat(getComputedStyle(wrapper).marginTop) -\n        parseFloat(getComputedStyle(wrapper).marginBottom) +\n        parseFloat(getComputedStyle(infix).height);\n\n      this.renderer.setStyle(infix, 'min-height', `${offset}px`);\n    });\n  }\n\n  private getElement(name: string): HTMLElement {\n    return this.elementRef.nativeElement.getElementsByClassName(name).item(0);\n  }\n\n}\n","import { NgModule } from '@angular/core';\n\nimport { MatContenteditableDirective } from './mat-contenteditable.directive';\nimport { MatCkeditorDirective } from './mat-ckeditor.directive';\nimport { MatCkeditorBalloonDirective } from './mat-ckeditor-balloon.directive';\nimport { FormFieldSizerDirective } from './form-field-sizer.directive';\n\n@NgModule({\n  imports: [\n  ],\n  declarations: [ MatContenteditableDirective, MatCkeditorDirective, MatCkeditorBalloonDirective, FormFieldSizerDirective ],\n  exports: [ MatContenteditableDirective, MatCkeditorDirective, MatCkeditorBalloonDirective, FormFieldSizerDirective ],\n})\nexport class MatContenteditableModule { }\n","import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';\n\nfunction getText(html: string) {\n  if (html) {\n    const element = document.createElement('span');\n    element.innerHTML = html;\n    return element.textContent.replace(/\\s/g, '');\n  }\n  return '';\n}\n\n/**\n * @description\n * Provides a set of built-in validators that can be used by form controls.\n *\n * A validator is a function that processes a `FormControl` or collection of\n * controls and returns an error map or null. A null map means that validation has passed.\n *\n * @see [Form Validation](/guide/form-validation)\n *\n * @publicApi\n */\nexport class HtmlValidators {\n\n  /**\n   * @description\n   * Validator that requires the control have a non-empty value.\n   *\n   * @usageNotes\n   *\n   * ### Validate that the field is non-empty\n   *\n   * ```typescript\n   * const control = new FormControl('', Validators.required);\n   *\n   * console.log(control.errors); // {required: true}\n   * ```\n   *\n   * @returns An error map with the `required` property\n   * if the validation check fails, otherwise `null`.\n   *\n   */\n  static required(control: AbstractControl): ValidationErrors | null {\n    const text = getText(control.value);\n    return text ? null : { 'required': true };\n  }\n\n  /**\n   * @description\n   * Validator that requires the length of the control's value to be greater than or equal\n   * to the provided minimum length. This validator is also provided by default if you use the\n   * the HTML5 `minlength` attribute.\n   *\n   * @usageNotes\n   *\n   * ### Validate that the field has a minimum of 3 characters\n   *\n   * ```typescript\n   * const control = new FormControl('ng', Validators.minLength(3));\n   *\n   * console.log(control.errors); // {minlength: {requiredLength: 3, actualLength: 2}}\n   * ```\n   *\n   * ```html\n   * <input minlength=\"5\">\n   * ```\n   *\n   * @returns A validator function that returns an error map with the\n   * `minlength` if the validation check fails, otherwise `null`.\n   */\n  static minLength(minLength: number): ValidatorFn {\n    const fn = (control: AbstractControl): ValidationErrors | null => {\n      const text = getText(control.value);\n      if (text) {\n        return text.length < minLength ?\n          { 'minlength': { 'requiredLength': minLength, 'actualLength': text.length } } :\n          null;\n      }\n      return null;  // don't validate empty values to allow optional controls\n    };\n    return fn;\n  }\n\n  /**\n   * @description\n   * Validator that requires the length of the control's value to be less than or equal\n   * to the provided maximum length. This validator is also provided by default if you use the\n   * the HTML5 `maxlength` attribute.\n   *\n   * @usageNotes\n   *\n   * ### Validate that the field has maximum of 5 characters\n   *\n   * ```typescript\n   * const control = new FormControl('Angular', Validators.maxLength(5));\n   *\n   * console.log(control.errors); // {maxlength: {requiredLength: 5, actualLength: 7}}\n   * ```\n   *\n   * ```html\n   * <input maxlength=\"5\">\n   * ```\n   *\n   * @returns A validator function that returns an error map with the\n   * `maxlength` property if the validation check fails, otherwise `null`.\n   */\n  static maxLength(maxLength: number): ValidatorFn {\n    const fn = (control: AbstractControl): ValidationErrors | null => {\n      const text = getText(control.value);\n      return text.length > maxLength ?\n        { 'maxlength': { 'requiredLength': maxLength, 'actualLength': text.length } } :\n        null;\n    };\n    return fn;\n  }\n}\n"],"names":["MatFormFieldControl","ErrorStateMatcher"],"mappings":"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