@koobiq/components 16.0.0-beta.1

package/esm2022/textarea/textarea.component.mjs

@@ -0,0 +1,254 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, ElementRef, Inject, Input, Optional, Self, InjectionToken, NgZone } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { ErrorStateMatcher, mixinErrorState } from '@koobiq/components/core';
+import { KbqFormFieldControl } from '@koobiq/components/form-field';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@koobiq/components/core";
+export const KBQ_TEXTAREA_VALUE_ACCESSOR = new InjectionToken('KBQ_TEXTAREA_VALUE_ACCESSOR');
+let nextUniqueId = 0;
+/** @docs-private */
+export class KbqTextareaBase {
+    constructor(defaultErrorStateMatcher, parentForm, parentFormGroup, ngControl) {
+        this.defaultErrorStateMatcher = defaultErrorStateMatcher;
+        this.parentForm = parentForm;
+        this.parentFormGroup = parentFormGroup;
+        this.ngControl = ngControl;
+        /**
+         * Emits whenever the component state changes and should cause the parent
+         * form-field to update. Implemented as part of `KbqFormFieldControl`.
+         * @docs-private
+         */
+        this.stateChanges = new Subject();
+    }
+}
+/** @docs-private */
+export const KbqTextareaMixinBase = mixinErrorState(KbqTextareaBase);
+export class KbqTextarea extends KbqTextareaMixinBase {
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get disabled() {
+        if (this.ngControl && this.ngControl.disabled !== null) {
+            return this.ngControl.disabled;
+        }
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        if (this.focused) {
+            this.focused = false;
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value || this.uid;
+    }
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get required() {
+        return this._required;
+    }
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+    }
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get value() {
+        return this.valueAccessor.value;
+    }
+    set value(value) {
+        if (value !== this.value) {
+            this.valueAccessor.value = value;
+            this.stateChanges.next();
+        }
+    }
+    constructor(elementRef, ngControl, parentForm, parentFormGroup, defaultErrorStateMatcher, inputValueAccessor, ngZone) {
+        super(defaultErrorStateMatcher, parentForm, parentFormGroup, ngControl);
+        this.elementRef = elementRef;
+        this.ngZone = ngZone;
+        this.canGrow = true;
+        /**
+         * Implemented as part of KbqFormFieldControl.
+         * @docs-private
+         */
+        this.focused = false;
+        /**
+         * Implemented as part of KbqFormFieldControl.
+         * @docs-private
+         */
+        this.stateChanges = new Subject();
+        /**
+         * Implemented as part of KbqFormFieldControl.
+         * @docs-private
+         */
+        this.controlType = 'textarea';
+        this.uid = `kbq-textarea-${nextUniqueId++}`;
+        this._disabled = false;
+        this._required = false;
+        this.lineHeight = 0;
+        this.freeRowsHeight = 0;
+        this.minHeight = 0;
+        // If no input value accessor was explicitly specified, use the element as the textarea value
+        // accessor.
+        this.valueAccessor = inputValueAccessor || this.elementRef.nativeElement;
+        this.previousNativeValue = this.value;
+        // Force setter to be called in case id was not specified.
+        this.id = this.id;
+        this.growSubscription = this.stateChanges.subscribe(() => this.grow());
+    }
+    ngOnInit() {
+        setTimeout(() => this.grow(), 0);
+        this.lineHeight = parseInt(getComputedStyle(this.elementRef.nativeElement).lineHeight, 10);
+        const paddingTop = parseInt(getComputedStyle(this.elementRef.nativeElement).paddingTop, 10);
+        const paddingBottom = parseInt(getComputedStyle(this.elementRef.nativeElement).paddingBottom, 10);
+        // tslint:disable-next-line:no-magic-numbers
+        this.minHeight = this.lineHeight * 2 + paddingTop + paddingBottom;
+        this.freeRowsHeight = this.lineHeight;
+    }
+    ngOnChanges() {
+        this.stateChanges.next();
+    }
+    ngOnDestroy() {
+        this.stateChanges.complete();
+        this.growSubscription.unsubscribe();
+    }
+    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();
+        }
+        // We need to dirty-check the native element's value, because there are some cases where
+        // we won't be notified when it changes (e.g. the consumer isn't using forms or they're
+        // updating the value using `emitEvent: false`).
+        this.dirtyCheckNativeValue();
+    }
+    onBlur() {
+        this.focusChanged(false);
+        if (this.ngControl?.control) {
+            const control = this.ngControl.control;
+            control.updateValueAndValidity({ emitEvent: false });
+            control.statusChanges.emit(control.status);
+        }
+    }
+    /** Grow textarea height to avoid vertical scroll  */
+    grow() {
+        if (!this.canGrow) {
+            return;
+        }
+        this.ngZone.runOutsideAngular(() => {
+            const textarea = this.elementRef.nativeElement;
+            const outerHeight = parseInt(window.getComputedStyle(textarea).height, 10);
+            const diff = outerHeight - textarea.clientHeight;
+            textarea.style.minHeight = 0; // this line is important to height recalculation
+            const height = Math.max(this.minHeight, +textarea.scrollHeight + diff + this.freeRowsHeight);
+            textarea.style.minHeight = `${height}px`;
+        });
+    }
+    /** Focuses the textarea. */
+    focus() {
+        this.elementRef.nativeElement.focus();
+    }
+    /** Callback for the cases where the focused state of the textarea changes. */
+    focusChanged(isFocused) {
+        if (isFocused !== this.focused) {
+            this.focused = isFocused;
+            this.stateChanges.next();
+        }
+    }
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    get empty() {
+        return !this.elementRef.nativeElement.value && !this.isBadInput();
+    }
+    /**
+     * Implemented as part of KbqFormFieldControl.
+     * @docs-private
+     */
+    onContainerClick() {
+        this.focus();
+    }
+    /** Does some manual dirty checking on the native textarea `value` property. */
+    dirtyCheckNativeValue() {
+        const newValue = this.value;
+        if (this.previousNativeValue !== newValue) {
+            this.previousNativeValue = newValue;
+            this.stateChanges.next();
+        }
+    }
+    /** Checks whether the textarea is invalid based on the native validation. */
+    isBadInput() {
+        // The `validity` property won't be present on platform-server.
+        const validity = this.elementRef.nativeElement.validity;
+        return validity && validity.badInput;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqTextarea, deps: [{ token: i0.ElementRef }, { token: i1.NgControl, optional: true, self: true }, { token: i1.NgForm, optional: true }, { token: i1.FormGroupDirective, optional: true }, { token: i2.ErrorStateMatcher }, { token: KBQ_TEXTAREA_VALUE_ACCESSOR, optional: true, self: true }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: KbqTextarea, selector: "textarea[mcTextarea]", inputs: { canGrow: "canGrow", errorStateMatcher: "errorStateMatcher", disabled: "disabled", id: "id", placeholder: "placeholder", required: "required", value: "value" }, host: { listeners: { "blur": "onBlur()", "focus": "focusChanged(true)" }, properties: { "class.kbq-textarea-resizable": "!canGrow", "attr.id": "id", "attr.placeholder": "placeholder", "attr.aria-invalid": "errorState", "attr.disabled": "disabled || null", "attr.required": "required" }, classAttribute: "kbq-textarea kbq-scrollbar" }, providers: [{ provide: KbqFormFieldControl, useExisting: KbqTextarea }], exportAs: ["mcTextarea"], usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqTextarea, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'textarea[mcTextarea]',
+                    exportAs: 'mcTextarea',
+                    host: {
+                        class: 'kbq-textarea kbq-scrollbar',
+                        '[class.kbq-textarea-resizable]': '!canGrow',
+                        '[attr.id]': 'id',
+                        '[attr.placeholder]': 'placeholder',
+                        '[attr.aria-invalid]': 'errorState',
+                        '[attr.disabled]': 'disabled || null',
+                        '[attr.required]': 'required',
+                        '(blur)': 'onBlur()',
+                        '(focus)': 'focusChanged(true)'
+                    },
+                    providers: [{ provide: KbqFormFieldControl, useExisting: KbqTextarea }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: i1.NgForm, decorators: [{
+                    type: Optional
+                }] }, { type: i1.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i2.ErrorStateMatcher }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [KBQ_TEXTAREA_VALUE_ACCESSOR]
+                }] }, { type: i0.NgZone }]; }, propDecorators: { canGrow: [{
+                type: Input
+            }], errorStateMatcher: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"textarea.component.js","sourceRoot":"","sources":["../../../../packages/components/textarea/textarea.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport {\n    Directive,\n    DoCheck,\n    ElementRef,\n    Inject,\n    Input,\n    OnChanges,\n    OnDestroy,\n    Optional,\n    Self,\n    InjectionToken,\n    NgZone,\n    OnInit,\n    EventEmitter\n} from '@angular/core';\nimport {\n    FormGroupDirective,\n    NgControl,\n    NgForm\n} from '@angular/forms';\nimport {\n    CanUpdateErrorState,\n    CanUpdateErrorStateCtor,\n    ErrorStateMatcher,\n    mixinErrorState\n} from '@koobiq/components/core';\nimport { KbqFormFieldControl } from '@koobiq/components/form-field';\nimport { Subscription, Subject } from 'rxjs';\n\n\nexport const KBQ_TEXTAREA_VALUE_ACCESSOR = new InjectionToken<{ value: any }>('KBQ_TEXTAREA_VALUE_ACCESSOR');\n\nlet nextUniqueId = 0;\n\n\n/** @docs-private */\nexport class KbqTextareaBase {\n    /**\n     * Emits whenever the component state changes and should cause the parent\n     * form-field to update. Implemented as part of `KbqFormFieldControl`.\n     * @docs-private\n     */\n    readonly stateChanges = new Subject<void>();\n\n    constructor(\n        public defaultErrorStateMatcher: ErrorStateMatcher,\n        public parentForm: NgForm,\n        public parentFormGroup: FormGroupDirective,\n        public ngControl: NgControl\n    ) {}\n}\n\n/** @docs-private */\nexport const KbqTextareaMixinBase: CanUpdateErrorStateCtor & typeof KbqTextareaBase = mixinErrorState(KbqTextareaBase);\n\n@Directive({\n    selector: 'textarea[mcTextarea]',\n    exportAs: 'mcTextarea',\n    host: {\n        class: 'kbq-textarea kbq-scrollbar',\n        '[class.kbq-textarea-resizable]': '!canGrow',\n\n        '[attr.id]': 'id',\n        '[attr.placeholder]': 'placeholder',\n        '[attr.aria-invalid]': 'errorState',\n        '[attr.disabled]': 'disabled || null',\n        '[attr.required]': 'required',\n\n        '(blur)': 'onBlur()',\n        '(focus)': 'focusChanged(true)'\n    },\n    providers: [{ provide: KbqFormFieldControl, useExisting: KbqTextarea }]\n})\nexport class KbqTextarea extends KbqTextareaMixinBase implements KbqFormFieldControl<any>, OnInit, OnChanges,\n    OnDestroy, DoCheck, CanUpdateErrorState {\n\n    @Input() canGrow: boolean = true;\n\n    /** An object used to control when error messages are shown. */\n    @Input() errorStateMatcher: ErrorStateMatcher;\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    focused: boolean = false;\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    readonly stateChanges: Subject<void> = new Subject<void>();\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    controlType: string = 'textarea';\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get disabled(): boolean {\n        if (this.ngControl && this.ngControl.disabled !== null) {\n            return this.ngControl.disabled;\n        }\n\n        return this._disabled;\n    }\n\n    set disabled(value: boolean) {\n        this._disabled = coerceBooleanProperty(value);\n\n        if (this.focused) {\n            this.focused = false;\n            this.stateChanges.next();\n        }\n    }\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get id(): string {\n        return this._id;\n    }\n\n    set id(value: string) {\n        this._id = value || this.uid;\n    }\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    @Input() placeholder: string;\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get required(): boolean {\n        return this._required;\n    }\n\n    set required(value: boolean) {\n        this._required = coerceBooleanProperty(value);\n    }\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get value(): string {\n        return this.valueAccessor.value;\n    }\n\n    set value(value: string) {\n        if (value !== this.value) {\n            this.valueAccessor.value = value;\n            this.stateChanges.next();\n        }\n    }\n\n    protected uid = `kbq-textarea-${nextUniqueId++}`;\n    protected previousNativeValue: any;\n    private _disabled = false;\n    private _id: string;\n    private _required = false;\n\n    private valueAccessor: { value: any };\n    private growSubscription: Subscription;\n\n    private lineHeight: number = 0;\n    private freeRowsHeight: number = 0;\n    private minHeight: number = 0;\n\n    constructor(\n        protected elementRef: ElementRef,\n        @Optional() @Self() ngControl: NgControl,\n        @Optional() parentForm: NgForm,\n        @Optional() parentFormGroup: FormGroupDirective,\n        defaultErrorStateMatcher: ErrorStateMatcher,\n        @Optional() @Self() @Inject(KBQ_TEXTAREA_VALUE_ACCESSOR) inputValueAccessor: any,\n        private ngZone: NgZone\n    ) {\n        super(defaultErrorStateMatcher, parentForm, parentFormGroup, ngControl);\n        // If no input value accessor was explicitly specified, use the element as the textarea value\n        // accessor.\n        this.valueAccessor = inputValueAccessor || this.elementRef.nativeElement;\n\n        this.previousNativeValue = this.value;\n\n        // Force setter to be called in case id was not specified.\n        this.id = this.id;\n\n        this.growSubscription = this.stateChanges.subscribe(() => this.grow());\n    }\n\n    ngOnInit() {\n        setTimeout(() => this.grow(), 0);\n        this.lineHeight = parseInt(getComputedStyle(this.elementRef.nativeElement).lineHeight!, 10);\n\n        const paddingTop = parseInt(getComputedStyle(this.elementRef.nativeElement).paddingTop!, 10);\n        const paddingBottom = parseInt(getComputedStyle(this.elementRef.nativeElement).paddingBottom!, 10);\n\n        // tslint:disable-next-line:no-magic-numbers\n        this.minHeight = this.lineHeight * 2 + paddingTop + paddingBottom;\n        this.freeRowsHeight = this.lineHeight;\n    }\n\n    ngOnChanges() {\n        this.stateChanges.next();\n    }\n\n    ngOnDestroy() {\n        this.stateChanges.complete();\n        this.growSubscription.unsubscribe();\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        // We need to dirty-check the native element's value, because there are some cases where\n        // we won't be notified when it changes (e.g. the consumer isn't using forms or they're\n        // updating the value using `emitEvent: false`).\n        this.dirtyCheckNativeValue();\n    }\n\n    onBlur(): void {\n        this.focusChanged(false);\n\n        if (this.ngControl?.control) {\n            const control = this.ngControl.control;\n\n            control.updateValueAndValidity({ emitEvent: false });\n            (control.statusChanges as EventEmitter<string>).emit(control.status);\n        }\n    }\n\n    /** Grow textarea height to avoid vertical scroll  */\n    grow() {\n        if (!this.canGrow) { return; }\n\n        this.ngZone.runOutsideAngular(() => {\n            const textarea = this.elementRef.nativeElement;\n\n            const outerHeight = parseInt(window.getComputedStyle(textarea).height!, 10);\n            const diff = outerHeight - textarea.clientHeight;\n\n            textarea.style.minHeight = 0; // this line is important to height recalculation\n\n            const height = Math.max(this.minHeight, +textarea.scrollHeight + diff + this.freeRowsHeight);\n            textarea.style.minHeight = `${height}px`;\n        });\n    }\n\n    /** Focuses the textarea. */\n    focus(): void {\n        this.elementRef.nativeElement.focus();\n    }\n\n    /** Callback for the cases where the focused state of the textarea changes. */\n    focusChanged(isFocused: boolean) {\n        if (isFocused !== this.focused) {\n            this.focused = isFocused;\n            this.stateChanges.next();\n        }\n    }\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    get empty(): boolean {\n        return !this.elementRef.nativeElement.value && !this.isBadInput();\n    }\n\n    /**\n     * Implemented as part of KbqFormFieldControl.\n     * @docs-private\n     */\n    onContainerClick() {\n        this.focus();\n    }\n\n    /** Does some manual dirty checking on the native textarea `value` property. */\n    protected dirtyCheckNativeValue() {\n        const newValue = this.value;\n\n        if (this.previousNativeValue !== newValue) {\n            this.previousNativeValue = newValue;\n            this.stateChanges.next();\n        }\n    }\n\n    /** Checks whether the textarea is invalid based on the native validation. */\n    protected isBadInput(): boolean {\n        // The `validity` property won't be present on platform-server.\n        const validity = (this.elementRef.nativeElement as HTMLTextAreaElement).validity;\n\n        return validity && validity.badInput;\n    }\n\n}\n"]}

package/esm2022/textarea/textarea.module.mjs

@@ -0,0 +1,21 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { KbqCommonModule } from '@koobiq/components/core';
+import { KbqTextarea } from './textarea.component';
+import * as i0 from "@angular/core";
+export class KbqTextareaModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqTextareaModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.5", ngImport: i0, type: KbqTextareaModule, declarations: [KbqTextarea], imports: [CommonModule, A11yModule, KbqCommonModule, FormsModule], exports: [KbqTextarea] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqTextareaModule, imports: [CommonModule, A11yModule, KbqCommonModule, FormsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: KbqTextareaModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, A11yModule, KbqCommonModule, FormsModule],
+                    exports: [KbqTextarea],
+                    declarations: [KbqTextarea]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dGFyZWEubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcG9uZW50cy90ZXh0YXJlYS90ZXh0YXJlYS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFMUQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFDOztBQVFuRCxNQUFNLE9BQU8saUJBQWlCO2lJQUFqQixpQkFBaUI7a0lBQWpCLGlCQUFpQixpQkFGWCxXQUFXLGFBRmhCLFlBQVksRUFBRSxVQUFVLEVBQUUsZUFBZSxFQUFFLFdBQVcsYUFDdEQsV0FBVztrSUFHWixpQkFBaUIsWUFKaEIsWUFBWSxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsV0FBVzs7MkZBSXZELGlCQUFpQjtrQkFMN0IsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsVUFBVSxFQUFFLGVBQWUsRUFBRSxXQUFXLENBQUM7b0JBQ2pFLE9BQU8sRUFBRSxDQUFDLFdBQVcsQ0FBQztvQkFDdEIsWUFBWSxFQUFFLENBQUMsV0FBVyxDQUFDO2lCQUM5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEExMXlNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jZGsvYTExeSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgS2JxQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGtvb2JpcS9jb21wb25lbnRzL2NvcmUnO1xuXG5pbXBvcnQgeyBLYnFUZXh0YXJlYSB9IGZyb20gJy4vdGV4dGFyZWEuY29tcG9uZW50JztcblxuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIEExMXlNb2R1bGUsIEticUNvbW1vbk1vZHVsZSwgRm9ybXNNb2R1bGVdLFxuICAgIGV4cG9ydHM6IFtLYnFUZXh0YXJlYV0sXG4gICAgZGVjbGFyYXRpb25zOiBbS2JxVGV4dGFyZWFdXG59KVxuZXhwb3J0IGNsYXNzIEticVRleHRhcmVhTW9kdWxlIHt9XG4iXX0=

package/esm2022/timepicker/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21wb25lbnRzL3RpbWVwaWNrZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/timepicker/koobiq-components-timepicker.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia29vYmlxLWNvbXBvbmVudHMtdGltZXBpY2tlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBvbmVudHMvdGltZXBpY2tlci9rb29iaXEtY29tcG9uZW50cy10aW1lcGlja2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/timepicker/public-api.mjs

@@ -0,0 +1,4 @@
+export * from './timepicker.module';
+export * from './timepicker.constants';
+export * from './timepicker.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBvbmVudHMvdGltZXBpY2tlci9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90aW1lcGlja2VyLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3RpbWVwaWNrZXIuY29uc3RhbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vdGltZXBpY2tlci5kaXJlY3RpdmUnO1xuIl19

package/esm2022/timepicker/timepicker.constants.mjs

@@ -0,0 +1,25 @@
+// tslint:disable:naming-convention
+export var TimeParts;
+(function (TimeParts) {
+    TimeParts[TimeParts["hours"] = 0] = "hours";
+    TimeParts[TimeParts["minutes"] = 1] = "minutes";
+    TimeParts[TimeParts["seconds"] = 2] = "seconds";
+})(TimeParts || (TimeParts = {}));
+export var TimeFormats;
+(function (TimeFormats) {
+    TimeFormats["HHmmss"] = "HH:mm:ss";
+    TimeFormats["HHmm"] = "HH:mm";
+})(TimeFormats || (TimeFormats = {}));
+export const TIMEFORMAT_PLACEHOLDERS = {
+    [TimeFormats.HHmmss]: 'чч:мм:сс',
+    [TimeFormats.HHmm]: 'чч:мм'
+};
+export const DEFAULT_TIME_FORMAT = TimeFormats.HHmm;
+export const HOURS_MINUTES_SECONDS_REGEXP = /^([0-1][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?$/;
+export const HOURS_MINUTES_REGEXP = /^([0-1][0-9]|2[0-3]):?([0-5][0-9])?$/;
+export const HOURS_ONLY_REGEXP = /^([0-1][0-9]|2[0-3]):?$/;
+export const AM_PM_FORMAT_REGEXP = /^([0-1]?[0-9]):([0-5]?[0-9]) ([ap][m]?$)/i;
+export const SECONDS_PER_MINUTE = 59;
+export const MINUTES_PER_HOUR = 59;
+export const HOURS_PER_DAY = 23;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXBpY2tlci5jb25zdGFudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21wb25lbnRzL3RpbWVwaWNrZXIvdGltZXBpY2tlci5jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsbUNBQW1DO0FBQ25DLE1BQU0sQ0FBTixJQUFZLFNBSVg7QUFKRCxXQUFZLFNBQVM7SUFDakIsMkNBQUssQ0FBQTtJQUNMLCtDQUFPLENBQUE7SUFDUCwrQ0FBTyxDQUFBO0FBQ1gsQ0FBQyxFQUpXLFNBQVMsS0FBVCxTQUFTLFFBSXBCO0FBRUQsTUFBTSxDQUFOLElBQVksV0FHWDtBQUhELFdBQVksV0FBVztJQUNuQixrQ0FBbUIsQ0FBQTtJQUNuQiw2QkFBYyxDQUFBO0FBQ2xCLENBQUMsRUFIVyxXQUFXLEtBQVgsV0FBVyxRQUd0QjtBQUVELE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFxQztJQUNyRSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsRUFBRSxVQUFVO0lBQ2hDLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU87Q0FDOUIsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFnQixXQUFXLENBQUMsSUFBSSxDQUFDO0FBRWpFLE1BQU0sQ0FBQyxNQUFNLDRCQUE0QixHQUFHLG9EQUFvRCxDQUFDO0FBQ2pHLE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFHLHNDQUFzQyxDQUFDO0FBQzNFLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLHlCQUF5QixDQUFDO0FBQzNELE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLDJDQUEyQyxDQUFDO0FBRS9FLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFXLEVBQUUsQ0FBQztBQUM3QyxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBVyxFQUFFLENBQUM7QUFDM0MsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFXLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIHRzbGludDpkaXNhYmxlOm5hbWluZy1jb252ZW50aW9uXG5leHBvcnQgZW51bSBUaW1lUGFydHMge1xuICAgIGhvdXJzLFxuICAgIG1pbnV0ZXMsXG4gICAgc2Vjb25kc1xufVxuXG5leHBvcnQgZW51bSBUaW1lRm9ybWF0cyB7XG4gICAgSEhtbXNzID0gJ0hIOm1tOnNzJyxcbiAgICBISG1tID0gJ0hIOm1tJ1xufVxuXG5leHBvcnQgY29uc3QgVElNRUZPUk1BVF9QTEFDRUhPTERFUlM6IHsgW3RpbWVGb3JtYXQ6IHN0cmluZ106IHN0cmluZyB9ID0ge1xuICAgIFtUaW1lRm9ybWF0cy5ISG1tc3NdOiAn0YfRhzrQvNC8OtGB0YEnLFxuICAgIFtUaW1lRm9ybWF0cy5ISG1tXTogJ9GH0Yc60LzQvCdcbn07XG5cbmV4cG9ydCBjb25zdCBERUZBVUxUX1RJTUVfRk9STUFUOiBUaW1lRm9ybWF0cyA9IFRpbWVGb3JtYXRzLkhIbW07XG5cbmV4cG9ydCBjb25zdCBIT1VSU19NSU5VVEVTX1NFQ09ORFNfUkVHRVhQID0gL14oWzAtMV1bMC05XXwyWzAtM10pOj8oWzAtNV1bMC05XSk6PyhbMC01XVswLTldKT8kLztcbmV4cG9ydCBjb25zdCBIT1VSU19NSU5VVEVTX1JFR0VYUCA9IC9eKFswLTFdWzAtOV18MlswLTNdKTo/KFswLTVdWzAtOV0pPyQvO1xuZXhwb3J0IGNvbnN0IEhPVVJTX09OTFlfUkVHRVhQID0gL14oWzAtMV1bMC05XXwyWzAtM10pOj8kLztcbmV4cG9ydCBjb25zdCBBTV9QTV9GT1JNQVRfUkVHRVhQID0gL14oWzAtMV0/WzAtOV0pOihbMC01XT9bMC05XSkgKFthcF1bbV0/JCkvaTtcblxuZXhwb3J0IGNvbnN0IFNFQ09ORFNfUEVSX01JTlVURTogbnVtYmVyID0gNTk7XG5leHBvcnQgY29uc3QgTUlOVVRFU19QRVJfSE9VUjogbnVtYmVyID0gNTk7XG5leHBvcnQgY29uc3QgSE9VUlNfUEVSX0RBWTogbnVtYmVyID0gMjM7XG4iXX0=