ng-zorro-antd-yj
Version:
An enterprise-class UI components based on Ant Design and Angular
301 lines • 27.2 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Platform } from '@angular/cdk/platform';
import { Directive, ElementRef, Input, NgZone } from '@angular/core';
import { fromEvent, Subject } from 'rxjs';
import { auditTime, takeUntil } from 'rxjs/operators';
/**
* @record
*/
export function AutoSizeType() { }
if (false) {
/** @type {?|undefined} */
AutoSizeType.prototype.minRows;
/** @type {?|undefined} */
AutoSizeType.prototype.maxRows;
}
/**
* @param {?} value
* @return {?}
*/
export function isAutoSizeType(value) {
return typeof value !== 'string' && typeof value !== 'boolean' && (!!value.maxRows || !!value.minRows);
}
export class NzAutosizeDirective {
/**
* @param {?} elementRef
* @param {?} ngZone
* @param {?} platform
*/
constructor(elementRef, ngZone, platform) {
this.elementRef = elementRef;
this.ngZone = ngZone;
this.platform = platform;
this.autosize = false;
this.el = this.elementRef.nativeElement;
this.destroy$ = new Subject();
this.inputGap = 10;
}
/**
* @param {?} value
* @return {?}
*/
set nzAutosize(value) {
if (typeof value === 'string') {
this.autosize = true;
}
else if (isAutoSizeType(value)) {
this.autosize = value;
this.minRows = value.minRows;
this.maxRows = value.maxRows;
this.setMaxHeight();
this.setMinHeight();
}
}
/**
* @return {?}
*/
get nzAutosize() {
return this.autosize;
}
/**
* @param {?=} force
* @return {?}
*/
resizeToFitContent(force = false) {
this.cacheTextareaLineHeight();
// If we haven't determined the line-height yet, we know we're still hidden and there's no point
// in checking the height of the textarea.
if (!this.cachedLineHeight) {
return;
}
/** @type {?} */
const textarea = (/** @type {?} */ (this.el));
/** @type {?} */
const value = textarea.value;
// Only resize if the value or minRows have changed since these calculations can be expensive.
if (!force && this.minRows === this.previousMinRows && value === this.previousValue) {
return;
}
/** @type {?} */
const placeholderText = textarea.placeholder;
// Reset the textarea height to auto in order to shrink back to its default size.
// Also temporarily force overflow:hidden, so scroll bars do not interfere with calculations.
// Long placeholders that are wider than the textarea width may lead to a bigger scrollHeight
// value. To ensure that the scrollHeight is not bigger than the content, the placeholders
// need to be removed temporarily.
textarea.classList.add('cdk-textarea-autosize-measuring');
textarea.placeholder = '';
/** @type {?} */
const height = Math.round((textarea.scrollHeight - this.inputGap) / this.cachedLineHeight) * this.cachedLineHeight +
this.inputGap;
// Use the scrollHeight to know how large the textarea *would* be if fit its entire value.
textarea.style.height = `${height}px`;
textarea.classList.remove('cdk-textarea-autosize-measuring');
textarea.placeholder = placeholderText;
// On Firefox resizing the textarea will prevent it from scrolling to the caret position.
// We need to re-set the selection in order for it to scroll to the proper position.
if (typeof requestAnimationFrame !== 'undefined') {
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
() => requestAnimationFrame((/**
* @return {?}
*/
() => {
const { selectionStart, selectionEnd } = textarea;
// IE will throw an "Unspecified error" if we try to set the selection range after the
// element has been removed from the DOM. Assert that the directive hasn't been destroyed
// between the time we requested the animation frame and when it was executed.
// Also note that we have to assert that the textarea is focused before we set the
// selection range. Setting the selection range on a non-focused textarea will cause
// it to receive focus on IE and Edge.
if (!this.destroy$.isStopped && document.activeElement === textarea) {
textarea.setSelectionRange(selectionStart, selectionEnd);
}
}))));
}
this.previousValue = value;
this.previousMinRows = this.minRows;
}
/**
* @private
* @return {?}
*/
cacheTextareaLineHeight() {
if (this.cachedLineHeight >= 0 || !this.el.parentNode) {
return;
}
// Use a clone element because we have to override some styles.
/** @type {?} */
const textareaClone = (/** @type {?} */ (this.el.cloneNode(false)));
textareaClone.rows = 1;
// Use `position: absolute` so that this doesn't cause a browser layout and use
// `visibility: hidden` so that nothing is rendered. Clear any other styles that
// would affect the height.
textareaClone.style.position = 'absolute';
textareaClone.style.visibility = 'hidden';
textareaClone.style.border = 'none';
textareaClone.style.padding = '0';
textareaClone.style.height = '';
textareaClone.style.minHeight = '';
textareaClone.style.maxHeight = '';
// In Firefox it happens that textarea elements are always bigger than the specified amount
// of rows. This is because Firefox tries to add extra space for the horizontal scrollbar.
// As a workaround that removes the extra space for the scrollbar, we can just set overflow
// to hidden. This ensures that there is no invalid calculation of the line height.
// See Firefox bug report: https://bugzilla.mozilla.org/show_bug.cgi?id=33654
textareaClone.style.overflow = 'hidden';
(/** @type {?} */ (this.el.parentNode)).appendChild(textareaClone);
this.cachedLineHeight = textareaClone.clientHeight - this.inputGap - 1;
(/** @type {?} */ (this.el.parentNode)).removeChild(textareaClone);
// Min and max heights have to be re-calculated if the cached line height changes
this.setMinHeight();
this.setMaxHeight();
}
/**
* @return {?}
*/
setMinHeight() {
/** @type {?} */
const minHeight = this.minRows && this.cachedLineHeight ? `${this.minRows * this.cachedLineHeight + this.inputGap}px` : null;
if (minHeight) {
this.el.style.minHeight = minHeight;
}
}
/**
* @return {?}
*/
setMaxHeight() {
/** @type {?} */
const maxHeight = this.maxRows && this.cachedLineHeight ? `${this.maxRows * this.cachedLineHeight + this.inputGap}px` : null;
if (maxHeight) {
this.el.style.maxHeight = maxHeight;
}
}
/**
* @return {?}
*/
noopInputHandler() {
// no-op handler that ensures we're running change detection on input events.
}
/**
* @return {?}
*/
ngAfterViewInit() {
if (this.nzAutosize && this.platform.isBrowser) {
this.resizeToFitContent();
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
() => {
fromEvent(window, 'resize')
.pipe(auditTime(16), takeUntil(this.destroy$))
.subscribe((/**
* @return {?}
*/
() => this.resizeToFitContent(true)));
}));
}
}
/**
* @return {?}
*/
ngOnDestroy() {
this.destroy$.next();
this.destroy$.complete();
}
/**
* @return {?}
*/
ngDoCheck() {
if (this.nzAutosize && this.platform.isBrowser) {
this.resizeToFitContent();
}
}
}
NzAutosizeDirective.decorators = [
{ type: Directive, args: [{
selector: 'textarea[nzAutosize]',
host: {
// Textarea elements that have the directive applied should have a single row by default.
// Browsers normally show two rows by default and therefore this limits the minRows binding.
rows: '1',
'(input)': 'noopInputHandler()'
}
},] }
];
/** @nocollapse */
NzAutosizeDirective.ctorParameters = () => [
{ type: ElementRef },
{ type: NgZone },
{ type: Platform }
];
NzAutosizeDirective.propDecorators = {
nzAutosize: [{ type: Input }]
};
if (false) {
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.autosize;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.el;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.cachedLineHeight;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.previousValue;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.previousMinRows;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.minRows;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.maxRows;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.destroy$;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.inputGap;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.elementRef;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.ngZone;
/**
* @type {?}
* @private
*/
NzAutosizeDirective.prototype.platform;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nz-autosize.directive.js","sourceRoot":"ng://ng-zorro-antd-yj/","sources":["input/nz-autosize.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Platform } from '@angular/cdk/platform';\nimport { AfterViewInit, Directive, DoCheck, ElementRef, Input, NgZone, OnDestroy } from '@angular/core';\nimport { fromEvent, Subject } from 'rxjs';\nimport { auditTime, takeUntil } from 'rxjs/operators';\n\nexport interface AutoSizeType {\n  minRows?: number;\n  maxRows?: number;\n}\n\nexport function isAutoSizeType(value: string | boolean | AutoSizeType): value is AutoSizeType {\n  return typeof value !== 'string' && typeof value !== 'boolean' && (!!value.maxRows || !!value.minRows);\n}\n\n@Directive({\n  selector: 'textarea[nzAutosize]',\n  host: {\n    // Textarea elements that have the directive applied should have a single row by default.\n    // Browsers normally show two rows by default and therefore this limits the minRows binding.\n    rows: '1',\n    '(input)': 'noopInputHandler()'\n  }\n})\nexport class NzAutosizeDirective implements AfterViewInit, OnDestroy, DoCheck {\n  private autosize: boolean | AutoSizeType = false;\n  private el: HTMLTextAreaElement | HTMLInputElement = this.elementRef.nativeElement;\n  private cachedLineHeight: number;\n  private previousValue: string;\n  private previousMinRows: number | undefined;\n  private minRows: number | undefined;\n  private maxRows: number | undefined;\n  private destroy$ = new Subject();\n  private inputGap = 10;\n\n  @Input()\n  set nzAutosize(value: string | boolean | AutoSizeType) {\n    if (typeof value === 'string') {\n      this.autosize = true;\n    } else if (isAutoSizeType(value)) {\n      this.autosize = value;\n      this.minRows = value.minRows;\n      this.maxRows = value.maxRows;\n      this.setMaxHeight();\n      this.setMinHeight();\n    }\n  }\n\n  get nzAutosize(): string | boolean | AutoSizeType {\n    return this.autosize;\n  }\n\n  resizeToFitContent(force: boolean = false): void {\n    this.cacheTextareaLineHeight();\n\n    // If we haven't determined the line-height yet, we know we're still hidden and there's no point\n    // in checking the height of the textarea.\n    if (!this.cachedLineHeight) {\n      return;\n    }\n\n    const textarea = this.el as HTMLTextAreaElement;\n    const value = textarea.value;\n\n    // Only resize if the value or minRows have changed since these calculations can be expensive.\n    if (!force && this.minRows === this.previousMinRows && value === this.previousValue) {\n      return;\n    }\n    const placeholderText = textarea.placeholder;\n\n    // Reset the textarea height to auto in order to shrink back to its default size.\n    // Also temporarily force overflow:hidden, so scroll bars do not interfere with calculations.\n    // Long placeholders that are wider than the textarea width may lead to a bigger scrollHeight\n    // value. To ensure that the scrollHeight is not bigger than the content, the placeholders\n    // need to be removed temporarily.\n    textarea.classList.add('cdk-textarea-autosize-measuring');\n    textarea.placeholder = '';\n    const height =\n      Math.round((textarea.scrollHeight - this.inputGap) / this.cachedLineHeight) * this.cachedLineHeight +\n      this.inputGap;\n\n    // Use the scrollHeight to know how large the textarea *would* be if fit its entire value.\n    textarea.style.height = `${height}px`;\n    textarea.classList.remove('cdk-textarea-autosize-measuring');\n    textarea.placeholder = placeholderText;\n\n    // On Firefox resizing the textarea will prevent it from scrolling to the caret position.\n    // We need to re-set the selection in order for it to scroll to the proper position.\n    if (typeof requestAnimationFrame !== 'undefined') {\n      this.ngZone.runOutsideAngular(() =>\n        requestAnimationFrame(() => {\n          const { selectionStart, selectionEnd } = textarea;\n\n          // IE will throw an \"Unspecified error\" if we try to set the selection range after the\n          // element has been removed from the DOM. Assert that the directive hasn't been destroyed\n          // between the time we requested the animation frame and when it was executed.\n          // Also note that we have to assert that the textarea is focused before we set the\n          // selection range. Setting the selection range on a non-focused textarea will cause\n          // it to receive focus on IE and Edge.\n          if (!this.destroy$.isStopped && document.activeElement === textarea) {\n            textarea.setSelectionRange(selectionStart, selectionEnd);\n          }\n        })\n      );\n    }\n\n    this.previousValue = value;\n    this.previousMinRows = this.minRows;\n  }\n\n  private cacheTextareaLineHeight(): void {\n    if (this.cachedLineHeight >= 0 || !this.el.parentNode) {\n      return;\n    }\n\n    // Use a clone element because we have to override some styles.\n    const textareaClone = this.el.cloneNode(false) as HTMLTextAreaElement;\n    textareaClone.rows = 1;\n\n    // Use `position: absolute` so that this doesn't cause a browser layout and use\n    // `visibility: hidden` so that nothing is rendered. Clear any other styles that\n    // would affect the height.\n    textareaClone.style.position = 'absolute';\n    textareaClone.style.visibility = 'hidden';\n    textareaClone.style.border = 'none';\n    textareaClone.style.padding = '0';\n    textareaClone.style.height = '';\n    textareaClone.style.minHeight = '';\n    textareaClone.style.maxHeight = '';\n\n    // In Firefox it happens that textarea elements are always bigger than the specified amount\n    // of rows. This is because Firefox tries to add extra space for the horizontal scrollbar.\n    // As a workaround that removes the extra space for the scrollbar, we can just set overflow\n    // to hidden. This ensures that there is no invalid calculation of the line height.\n    // See Firefox bug report: https://bugzilla.mozilla.org/show_bug.cgi?id=33654\n    textareaClone.style.overflow = 'hidden';\n\n    this.el.parentNode!.appendChild(textareaClone);\n    this.cachedLineHeight = textareaClone.clientHeight - this.inputGap - 1;\n    this.el.parentNode!.removeChild(textareaClone);\n\n    // Min and max heights have to be re-calculated if the cached line height changes\n    this.setMinHeight();\n    this.setMaxHeight();\n  }\n\n  setMinHeight(): void {\n    const minHeight =\n      this.minRows && this.cachedLineHeight ? `${this.minRows * this.cachedLineHeight + this.inputGap}px` : null;\n\n    if (minHeight) {\n      this.el.style.minHeight = minHeight;\n    }\n  }\n\n  setMaxHeight(): void {\n    const maxHeight =\n      this.maxRows && this.cachedLineHeight ? `${this.maxRows * this.cachedLineHeight + this.inputGap}px` : null;\n\n    if (maxHeight) {\n      this.el.style.maxHeight = maxHeight;\n    }\n  }\n\n  noopInputHandler(): void {\n    // no-op handler that ensures we're running change detection on input events.\n  }\n\n  constructor(private elementRef: ElementRef, private ngZone: NgZone, private platform: Platform) {}\n\n  ngAfterViewInit(): void {\n    if (this.nzAutosize && this.platform.isBrowser) {\n      this.resizeToFitContent();\n      this.ngZone.runOutsideAngular(() => {\n        fromEvent(window, 'resize')\n          .pipe(\n            auditTime(16),\n            takeUntil(this.destroy$)\n          )\n          .subscribe(() => this.resizeToFitContent(true));\n      });\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.destroy$.next();\n    this.destroy$.complete();\n  }\n\n  ngDoCheck(): void {\n    if (this.nzAutosize && this.platform.isBrowser) {\n      this.resizeToFitContent();\n    }\n  }\n}\n"]}