@apipass/inputs 0.2.1-alpha.1 → 0.2.1-alpha.10

package/esm2015/ace-editor/component.js

@@ -0,0 +1,204 @@
+/* tslint:disable */
+import { Component, ElementRef, EventEmitter, forwardRef, Input, NgZone, Output } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import 'brace';
+import 'brace/theme/monokai';
+import * as i0 from "@angular/core";
+export class AceEditorComponent {
+    constructor(elementRef, zone) {
+        this.zone = zone;
+        this.textChanged = new EventEmitter();
+        this.textChange = new EventEmitter();
+        this.style = {};
+        // @ts-ignore
+        this._options = {};
+        // @ts-ignore
+        this._theme = 'monokai';
+        // @ts-ignore
+        this._mode = 'html';
+        // @ts-ignore
+        this._autoUpdateContent = true;
+        // @ts-ignore
+        this._durationBeforeCallback = 0;
+        // @ts-ignore
+        this._text = '';
+        this._onChange = (_) => {
+        };
+        this._onTouched = () => {
+        };
+        const el = elementRef.nativeElement;
+        this.zone.runOutsideAngular(() => {
+            this._editor = ace['edit'](el);
+        });
+        this._editor.$blockScrolling = Infinity;
+    }
+    ngOnInit() {
+        this.init();
+        this.initEvents();
+    }
+    ngOnDestroy() {
+        this._editor.destroy();
+    }
+    init() {
+        this.setOptions(this._options || {});
+        this.setTheme(this._theme);
+        this.setMode(this._mode);
+        this.setReadOnly(this._readOnly);
+    }
+    initEvents() {
+        this._editor.on('change', () => this.updateText());
+        this._editor.on('paste', () => this.updateText());
+    }
+    updateText() {
+        const newVal = this._editor.getValue();
+        if (newVal === this.oldText) {
+            return;
+        }
+        if (!this._durationBeforeCallback) {
+            this._text = newVal;
+            this.zone.run(() => {
+                this.textChange.emit(newVal);
+                this.textChanged.emit(newVal);
+            });
+            this._onChange(newVal);
+        }
+        else {
+            if (this.timeoutSaving) {
+                clearTimeout(this.timeoutSaving);
+            }
+            this.timeoutSaving = setTimeout(() => {
+                this._text = newVal;
+                this.zone.run(() => {
+                    this.textChange.emit(newVal);
+                    this.textChanged.emit(newVal);
+                });
+                this.timeoutSaving = null;
+            }, this._durationBeforeCallback);
+        }
+        this.oldText = newVal;
+    }
+    set options(options) {
+        this.setOptions(options);
+    }
+    setOptions(options) {
+        this._options = options;
+        this._editor.setOptions(options || {});
+    }
+    set readOnly(readOnly) {
+        this.setReadOnly(readOnly);
+    }
+    setReadOnly(readOnly) {
+        this._readOnly = readOnly;
+        this._editor.setReadOnly(readOnly);
+    }
+    set theme(theme) {
+        this.setTheme(theme);
+    }
+    setTheme(theme) {
+        this._theme = theme;
+        this._editor.setTheme(`ace/theme/${theme}`);
+    }
+    set mode(mode) {
+        this.setMode(mode);
+    }
+    setMode(mode) {
+        this._mode = mode;
+        if (typeof this._mode === 'object') {
+            this._editor.getSession().setMode(this._mode);
+        }
+        else {
+            this._editor.getSession().setMode(`ace/mode/${this._mode}`);
+        }
+    }
+    // @ts-ignore
+    get value() {
+        return this.text;
+    }
+    // @ts-ignore
+    set value(value) {
+        this.setText(value);
+    }
+    writeValue(value) {
+        this.setText(value);
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    get text() {
+        return this._text;
+    }
+    set text(text) {
+        this.setText(text);
+    }
+    setText(text) {
+        if (text === null || text === undefined) {
+            text = '';
+        }
+        if (this._text !== text && this._autoUpdateContent) {
+            this._text = text;
+            this._editor.setValue(text);
+            this._onChange(text);
+            this._editor.clearSelection();
+        }
+    }
+    set autoUpdateContent(status) {
+        this.setAutoUpdateContent(status);
+    }
+    setAutoUpdateContent(status) {
+        this._autoUpdateContent = status;
+    }
+    set durationBeforeCallback(num) {
+        this.setDurationBeforeCallback(num);
+    }
+    setDurationBeforeCallback(num) {
+        this._durationBeforeCallback = num;
+    }
+    getEditor() {
+        return this._editor;
+    }
+}
+AceEditorComponent.ɵfac = function AceEditorComponent_Factory(t) { return new (t || AceEditorComponent)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+AceEditorComponent.ɵcmp = i0.ɵɵdefineComponent({ type: AceEditorComponent, selectors: [["ace-editor"]], inputs: { style: "style", options: "options", readOnly: "readOnly", theme: "theme", mode: "mode", value: "value", text: "text", autoUpdateContent: "autoUpdateContent", durationBeforeCallback: "durationBeforeCallback" }, outputs: { textChanged: "textChanged", textChange: "textChange" }, features: [i0.ɵɵProvidersFeature([{
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => AceEditorComponent),
+                multi: true
+            }])], decls: 0, vars: 0, template: function AceEditorComponent_Template(rf, ctx) { }, styles: ["[_nghost-%COMP%] { display:block;width:100%; }"] });
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(AceEditorComponent, [{
+        type: Component,
+        args: [{
+                selector: 'ace-editor',
+                template: '',
+                styles: [':host { display:block;width:100%; }'],
+                providers: [{
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => AceEditorComponent),
+                        multi: true
+                    }]
+            }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }]; }, { textChanged: [{
+            type: Output
+        }], textChange: [{
+            type: Output
+        }], style: [{
+            type: Input
+        }], options: [{
+            type: Input
+        }], readOnly: [{
+            type: Input
+        }], theme: [{
+            type: Input
+        }], mode: [{
+            type: Input
+        }], value: [{
+            type: Input
+        }], text: [{
+            type: Input
+        }], autoUpdateContent: [{
+            type: Input
+        }], durationBeforeCallback: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../projects/inputs/src/ace-editor/component.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n\nimport {Component, ElementRef, EventEmitter, forwardRef, Input, NgZone, OnDestroy, OnInit, Output} from '@angular/core';\nimport {ControlValueAccessor, NG_VALUE_ACCESSOR} from '@angular/forms';\nimport 'brace';\nimport 'brace/theme/monokai';\n\ndeclare var ace: any;\n\n@Component({\n  selector: 'ace-editor',\n  template: '',\n  styles: [':host { display:block;width:100%; }'],\n  providers: [{\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => AceEditorComponent),\n    multi: true\n  }]\n})\nexport class AceEditorComponent implements ControlValueAccessor, OnInit, OnDestroy {\n  @Output() textChanged = new EventEmitter();\n  @Output() textChange = new EventEmitter();\n  @Input() style: any = {};\n\n  // @ts-ignore\n  _options: any = {};\n\n  // @ts-ignore\n  _readOnly: false;\n\n  // @ts-ignore\n  _theme = 'monokai';\n\n  // @ts-ignore\n  _mode = 'html';\n\n  // @ts-ignore\n  _autoUpdateContent = true;\n\n  // @ts-ignore\n  _editor: any;\n\n  // @ts-ignore\n  _durationBeforeCallback = 0;\n\n  // @ts-ignore\n  _text = '';\n\n  oldText: any;\n  timeoutSaving: any;\n\n  constructor(elementRef: ElementRef, private zone: NgZone) {\n    const el = elementRef.nativeElement;\n    this.zone.runOutsideAngular(() => {\n      this._editor = ace['edit'](el);\n    });\n    this._editor.$blockScrolling = Infinity;\n  }\n\n  ngOnInit(): void {\n    this.init();\n    this.initEvents();\n  }\n\n  ngOnDestroy(): void {\n    this._editor.destroy();\n  }\n\n  init(): void {\n    this.setOptions(this._options || {});\n    this.setTheme(this._theme);\n    this.setMode(this._mode);\n    this.setReadOnly(this._readOnly);\n  }\n\n  initEvents(): void {\n    this._editor.on('change', () => this.updateText());\n    this._editor.on('paste', () => this.updateText());\n  }\n\n  updateText(): void {\n    const newVal = this._editor.getValue();\n    if (newVal === this.oldText) {\n      return;\n    }\n    if (!this._durationBeforeCallback) {\n      this._text = newVal;\n      this.zone.run(() => {\n        this.textChange.emit(newVal);\n        this.textChanged.emit(newVal);\n      });\n      this._onChange(newVal);\n    } else {\n      if (this.timeoutSaving) {\n        clearTimeout(this.timeoutSaving);\n      }\n\n      this.timeoutSaving = setTimeout(() => {\n        this._text = newVal;\n        this.zone.run(() => {\n          this.textChange.emit(newVal);\n          this.textChanged.emit(newVal);\n        });\n        this.timeoutSaving = null;\n      }, this._durationBeforeCallback);\n    }\n    this.oldText = newVal;\n  }\n\n  @Input() set options(options: any) {\n    this.setOptions(options);\n  }\n\n  setOptions(options: any): void {\n    this._options = options;\n    this._editor.setOptions(options || {});\n  }\n\n  @Input() set readOnly(readOnly: any) {\n    this.setReadOnly(readOnly);\n  }\n\n  setReadOnly(readOnly: any): void {\n    this._readOnly = readOnly;\n    this._editor.setReadOnly(readOnly);\n  }\n\n  @Input() set theme(theme: any) {\n    this.setTheme(theme);\n  }\n\n  setTheme(theme: any): void {\n    this._theme = theme;\n    this._editor.setTheme(`ace/theme/${theme}`);\n  }\n\n  @Input() set mode(mode: any) {\n    this.setMode(mode);\n  }\n\n  setMode(mode: any): void {\n    this._mode = mode;\n    if (typeof this._mode === 'object') {\n      this._editor.getSession().setMode(this._mode);\n    } else {\n      this._editor.getSession().setMode(`ace/mode/${this._mode}`);\n    }\n  }\n\n  // @ts-ignore\n  get value() {\n    return this.text;\n  }\n\n  // @ts-ignore\n  @Input()\n  set value(value: string) {\n    this.setText(value);\n  }\n\n  writeValue(value: any): void {\n    this.setText(value);\n  }\n\n  private _onChange = (_: any): void => {\n  }\n\n  registerOnChange(fn: any): void {\n    this._onChange = fn;\n  }\n\n  private _onTouched = (): void => {\n  }\n\n  registerOnTouched(fn: any): void {\n    this._onTouched = fn;\n  }\n\n  get text() {\n    return this._text;\n  }\n\n  @Input()\n  set text(text: string) {\n    this.setText(text);\n  }\n\n  setText(text: any): void {\n    if (text === null || text === undefined) {\n      text = '';\n    }\n    if (this._text !== text && this._autoUpdateContent) {\n      this._text = text;\n      this._editor.setValue(text);\n      this._onChange(text);\n      this._editor.clearSelection();\n    }\n  }\n\n  @Input() set autoUpdateContent(status: any) {\n    this.setAutoUpdateContent(status);\n  }\n\n  setAutoUpdateContent(status: any): void {\n    this._autoUpdateContent = status;\n  }\n\n  @Input() set durationBeforeCallback(num: number) {\n    this.setDurationBeforeCallback(num);\n  }\n\n  setDurationBeforeCallback(num: number): void {\n    this._durationBeforeCallback = num;\n  }\n\n  getEditor(): any {\n    return this._editor;\n  }\n\n}\n"]}

package/esm2015/ace-editor/directive.js

@@ -0,0 +1,150 @@
+/* tslint:disable */
+import { Directive, ElementRef, EventEmitter, Input, NgZone, Output } from '@angular/core';
+import 'brace';
+import 'brace/theme/monokai';
+import * as i0 from "@angular/core";
+export class AceEditorDirective {
+    constructor(elementRef, zone) {
+        this.zone = zone;
+        this.textChanged = new EventEmitter();
+        this.textChange = new EventEmitter();
+        this._options = {};
+        this._readOnly = false;
+        this._theme = 'monokai';
+        this._mode = 'html';
+        this._autoUpdateContent = true;
+        this._durationBeforeCallback = 0;
+        this._text = '';
+        const el = elementRef.nativeElement;
+        this.zone.runOutsideAngular(() => {
+            this.editor = ace['edit'](el);
+        });
+        this.editor.$blockScrolling = Infinity;
+    }
+    ngOnInit() {
+        this.init();
+        this.initEvents();
+    }
+    ngOnDestroy() {
+        this.editor.destroy();
+    }
+    init() {
+        this.editor.setOptions(this._options || {});
+        this.editor.setTheme(`ace/theme/${this._theme}`);
+        this.setMode(this._mode);
+        this.editor.setReadOnly(this._readOnly);
+    }
+    initEvents() {
+        this.editor.on('change', () => this.updateText());
+        this.editor.on('paste', () => this.updateText());
+    }
+    updateText() {
+        const newVal = this.editor.getValue();
+        if (newVal === this.oldText) {
+            return;
+        }
+        if (!this._durationBeforeCallback) {
+            this._text = newVal;
+            this.zone.run(() => {
+                this.textChange.emit(newVal);
+                this.textChanged.emit(newVal);
+            });
+        }
+        else {
+            if (this.timeoutSaving != null) {
+                clearTimeout(this.timeoutSaving);
+            }
+            this.timeoutSaving = setTimeout(() => {
+                this._text = newVal;
+                this.zone.run(() => {
+                    this.textChange.emit(newVal);
+                    this.textChanged.emit(newVal);
+                });
+                this.timeoutSaving = null;
+            }, this._durationBeforeCallback);
+        }
+        this.oldText = newVal;
+    }
+    set options(options) {
+        this._options = options;
+        this.editor.setOptions(options || {});
+    }
+    set readOnly(readOnly) {
+        this._readOnly = readOnly;
+        this.editor.setReadOnly(readOnly);
+    }
+    set theme(theme) {
+        this._theme = theme;
+        this.editor.setTheme(`ace/theme/${theme}`);
+    }
+    set mode(mode) {
+        this.setMode(mode);
+    }
+    setMode(mode) {
+        this._mode = mode;
+        if (typeof this._mode === 'object') {
+            this.editor.getSession().setMode(this._mode);
+        }
+        else {
+            this.editor.getSession().setMode(`ace/mode/${this._mode}`);
+        }
+    }
+    // @ts-ignore
+    get text() {
+        return this._text;
+    }
+    set text(text) {
+        this.setText(text);
+    }
+    setText(text) {
+        if (this._text !== text) {
+            if (text === null || text === undefined) {
+                text = '';
+            }
+            if (this._autoUpdateContent) {
+                this._text = text;
+                this.editor.setValue(text);
+                this.editor.clearSelection();
+            }
+        }
+    }
+    set autoUpdateContent(status) {
+        this._autoUpdateContent = status;
+    }
+    set durationBeforeCallback(num) {
+        this.setDurationBeforeCallback(num);
+    }
+    setDurationBeforeCallback(num) {
+        this._durationBeforeCallback = num;
+    }
+    get aceEditor() {
+        return this.editor;
+    }
+}
+AceEditorDirective.ɵfac = function AceEditorDirective_Factory(t) { return new (t || AceEditorDirective)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.NgZone)); };
+AceEditorDirective.ɵdir = i0.ɵɵdefineDirective({ type: AceEditorDirective, selectors: [["", "ace-editor", ""]], inputs: { options: "options", readOnly: "readOnly", theme: "theme", mode: "mode", text: "text", autoUpdateContent: "autoUpdateContent", durationBeforeCallback: "durationBeforeCallback" }, outputs: { textChanged: "textChanged", textChange: "textChange" } });
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(AceEditorDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[ace-editor]'
+            }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }]; }, { textChanged: [{
+            type: Output
+        }], textChange: [{
+            type: Output
+        }], options: [{
+            type: Input
+        }], readOnly: [{
+            type: Input
+        }], theme: [{
+            type: Input
+        }], mode: [{
+            type: Input
+        }], text: [{
+            type: Input
+        }], autoUpdateContent: [{
+            type: Input
+        }], durationBeforeCallback: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"directive.js","sourceRoot":"","sources":["../../../../projects/inputs/src/ace-editor/directive.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n\nimport {Directive, ElementRef, EventEmitter, Input, NgZone, OnDestroy, OnInit, Output} from '@angular/core';\nimport 'brace';\nimport 'brace/theme/monokai';\n\ndeclare var ace: any;\n\n@Directive({\n  selector: '[ace-editor]'\n})\nexport class AceEditorDirective implements OnInit, OnDestroy {\n  @Output() textChanged = new EventEmitter();\n  @Output() textChange = new EventEmitter();\n  _options: any = {};\n  _readOnly = false;\n  _theme = 'monokai';\n  _mode = 'html';\n  _autoUpdateContent = true;\n  _durationBeforeCallback = 0;\n  _text = '';\n  editor: any;\n  oldText: any;\n  timeoutSaving: any;\n\n  constructor(elementRef: ElementRef, private zone: NgZone) {\n    const el = elementRef.nativeElement;\n    this.zone.runOutsideAngular(() => {\n      this.editor = ace['edit'](el);\n    });\n    this.editor.$blockScrolling = Infinity;\n  }\n\n  ngOnInit(): void {\n    this.init();\n    this.initEvents();\n  }\n\n  ngOnDestroy(): void {\n    this.editor.destroy();\n  }\n\n  init(): void {\n    this.editor.setOptions(this._options || {});\n    this.editor.setTheme(`ace/theme/${this._theme}`);\n    this.setMode(this._mode);\n    this.editor.setReadOnly(this._readOnly);\n  }\n\n  initEvents(): void {\n    this.editor.on('change', () => this.updateText());\n    this.editor.on('paste', () => this.updateText());\n  }\n\n  updateText(): void {\n    const newVal = this.editor.getValue();\n    if (newVal === this.oldText) {\n      return;\n    }\n    if (!this._durationBeforeCallback) {\n      this._text = newVal;\n      this.zone.run(() => {\n        this.textChange.emit(newVal);\n        this.textChanged.emit(newVal);\n      });\n    } else {\n      if (this.timeoutSaving != null) {\n        clearTimeout(this.timeoutSaving);\n      }\n\n      this.timeoutSaving = setTimeout(() => {\n        this._text = newVal;\n        this.zone.run(() => {\n          this.textChange.emit(newVal);\n          this.textChanged.emit(newVal);\n        });\n        this.timeoutSaving = null;\n      }, this._durationBeforeCallback);\n    }\n    this.oldText = newVal;\n  }\n\n  @Input() set options(options: any) {\n    this._options = options;\n    this.editor.setOptions(options || {});\n  }\n\n  @Input() set readOnly(readOnly: any) {\n    this._readOnly = readOnly;\n    this.editor.setReadOnly(readOnly);\n  }\n\n  @Input() set theme(theme: any) {\n    this._theme = theme;\n    this.editor.setTheme(`ace/theme/${theme}`);\n  }\n\n  @Input() set mode(mode: any) {\n    this.setMode(mode);\n  }\n\n  setMode(mode: any): void {\n    this._mode = mode;\n    if (typeof this._mode === 'object') {\n      this.editor.getSession().setMode(this._mode);\n    } else {\n      this.editor.getSession().setMode(`ace/mode/${this._mode}`);\n    }\n  }\n\n  // @ts-ignore\n  @Input()\n  get text() {\n    return this._text;\n  }\n\n  set text(text: string) {\n    this.setText(text);\n  }\n\n  setText(text: any): void {\n    if (this._text !== text) {\n      if (text === null || text === undefined) {\n        text = '';\n      }\n\n      if (this._autoUpdateContent) {\n        this._text = text;\n        this.editor.setValue(text);\n        this.editor.clearSelection();\n      }\n    }\n  }\n\n  @Input() set autoUpdateContent(status: any) {\n    this._autoUpdateContent = status;\n  }\n\n  @Input() set durationBeforeCallback(num: number) {\n    this.setDurationBeforeCallback(num);\n  }\n\n  setDurationBeforeCallback(num: number): void {\n    this._durationBeforeCallback = num;\n  }\n\n  get aceEditor(): any {\n    return this.editor;\n  }\n}\n"]}

package/esm2015/input-boolean/input-boolean.component.js

@@ -0,0 +1,77 @@
+import { Component, forwardRef, Input, ViewEncapsulation } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { ValueAccessorBase } from '../value-acessor-base';
+import * as i0 from "@angular/core";
+import * as i1 from "@apipass/buttons";
+export class InputBooleanComponent extends ValueAccessorBase {
+    constructor() {
+        super(...arguments);
+        this.trueLabel = '';
+        this.trueIconPrefix = '';
+        this.trueIconSuffix = '';
+        this.falseLabel = '';
+        this.falseIconPrefix = '';
+        this.falseIconSuffix = '';
+        this.disabled = false;
+    }
+    trueClick() {
+        if (!this.disabled && !this.value) {
+            this.value = true;
+        }
+    }
+    falseClick() {
+        if (!this.disabled && this.value) {
+            this.value = false;
+        }
+    }
+}
+InputBooleanComponent.ɵfac = function InputBooleanComponent_Factory(t) { return ɵInputBooleanComponent_BaseFactory(t || InputBooleanComponent); };
+InputBooleanComponent.ɵcmp = i0.ɵɵdefineComponent({ type: InputBooleanComponent, selectors: [["input-boolean"]], inputs: { trueLabel: "trueLabel", trueIconPrefix: "trueIconPrefix", trueIconSuffix: "trueIconSuffix", falseLabel: "falseLabel", falseIconPrefix: "falseIconPrefix", falseIconSuffix: "falseIconSuffix", disabled: "disabled" }, features: [i0.ɵɵProvidersFeature([{
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => InputBooleanComponent),
+                multi: true
+            }]), i0.ɵɵInheritDefinitionFeature], decls: 3, vars: 10, consts: [[1, "input-boolean"], [1, "btn-true", 3, "selected", "label", "icon", "suffixIcon", "btnDisabled", "onClick"], [1, "btn-false", 3, "selected", "label", "icon", "suffixIcon", "btnDisabled", "onClick"]], template: function InputBooleanComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "div", 0);
+        i0.ɵɵelementStart(1, "primary-button", 1);
+        i0.ɵɵlistener("onClick", function InputBooleanComponent_Template_primary_button_onClick_1_listener() { return ctx.trueClick(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(2, "primary-button", 2);
+        i0.ɵɵlistener("onClick", function InputBooleanComponent_Template_primary_button_onClick_2_listener() { return ctx.falseClick(); });
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("selected", ctx.value === true)("label", ctx.trueLabel)("icon", ctx.trueIconPrefix)("suffixIcon", ctx.trueIconSuffix)("btnDisabled", ctx.disabled);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("selected", ctx.value === false || ctx.value === undefined)("label", ctx.falseLabel)("icon", ctx.falseIconPrefix)("suffixIcon", ctx.falseIconSuffix)("btnDisabled", ctx.disabled);
+    } }, directives: [i1.PrimaryButtonComponent], styles: [".input-boolean{display:flex;flex-wrap:wrap;width:100%}.input-boolean primary-button:first-child{margin-right:5px}.input-boolean primary-button button:not(.selected){background:#fff;border:1px solid var(--color-fonts-tertiary);color:var(--color-fonts-tertiary);cursor:pointer}.input-boolean primary-button button:not(.selected):hover{color:#fff}.input-boolean primary-button button:not(.selected).mat-button-disabled{color:var(--color-fonts-tertiary)!important;cursor:default!important;pointer-events:none!important}.input-boolean primary-button button.selected{cursor:default;pointer-events:none}.input-boolean primary-button button.selected,.input-boolean primary-button button.selected:hover{background:#fff;border:1px solid var(--color-primary);color:var(--color-primary)}.input-boolean primary-button button.selected.mat-button-disabled{background:var(--color-fonts-tertiary);color:#fff!important;cursor:default!important;pointer-events:none!important}"], encapsulation: 2 });
+const ɵInputBooleanComponent_BaseFactory = /*@__PURE__*/ i0.ɵɵgetInheritedFactory(InputBooleanComponent);
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(InputBooleanComponent, [{
+        type: Component,
+        args: [{
+                selector: 'input-boolean',
+                templateUrl: 'input-boolean.component.html',
+                styleUrls: ['input-boolean.component.scss'],
+                providers: [{
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => InputBooleanComponent),
+                        multi: true
+                    }],
+                encapsulation: ViewEncapsulation.None
+            }]
+    }], null, { trueLabel: [{
+            type: Input
+        }], trueIconPrefix: [{
+            type: Input
+        }], trueIconSuffix: [{
+            type: Input
+        }], falseLabel: [{
+            type: Input
+        }], falseIconPrefix: [{
+            type: Input
+        }], falseIconSuffix: [{
+            type: Input
+        }], disabled: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtYm9vbGVhbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9pbnB1dHMvc3JjL2lucHV0LWJvb2xlYW4vaW5wdXQtYm9vbGVhbi5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi9wcm9qZWN0cy9pbnB1dHMvc3JjL2lucHV0LWJvb2xlYW4vaW5wdXQtYm9vbGVhbi5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFnQixVQUFVLEVBQUUsS0FBSyxFQUFVLGlCQUFpQixFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3BHLE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBQ2pELE9BQU8sRUFBQyxpQkFBaUIsRUFBQyxNQUFNLHVCQUF1QixDQUFDOzs7QUFheEQsTUFBTSxPQUFPLHFCQUFzQixTQUFRLGlCQUEwQjtJQVhyRTs7UUFhVyxjQUFTLEdBQUcsRUFBRSxDQUFDO1FBQ2YsbUJBQWMsR0FBRyxFQUFFLENBQUM7UUFDcEIsbUJBQWMsR0FBRyxFQUFFLENBQUM7UUFDcEIsZUFBVSxHQUFHLEVBQUUsQ0FBQztRQUNoQixvQkFBZSxHQUFHLEVBQUUsQ0FBQztRQUNyQixvQkFBZSxHQUFHLEVBQUUsQ0FBQztRQUNyQixhQUFRLEdBQUcsS0FBSyxDQUFDO0tBYzNCO0lBWlEsU0FBUztRQUNkLElBQUksQ0FBQyxJQUFJLENBQUMsUUFBUSxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRTtZQUNqQyxJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQztTQUNuQjtJQUNILENBQUM7SUFFTSxVQUFVO1FBQ2YsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLElBQUksSUFBSSxDQUFDLEtBQUssRUFBRTtZQUNoQyxJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztTQUNwQjtJQUNILENBQUM7O3dIQXBCVSxxQkFBcUI7MERBQXJCLHFCQUFxQixtU0FQckIsQ0FBQztnQkFDVixPQUFPLEVBQUUsaUJBQWlCO2dCQUMxQixXQUFXLEVBQUUsVUFBVSxDQUFDLEdBQUcsRUFBRSxDQUFDLHFCQUFxQixDQUFDO2dCQUNwRCxLQUFLLEVBQUUsSUFBSTthQUNaLENBQUM7UUNaSiw4QkFFRTtRQUFBLHlDQU9pQjtRQURELDhHQUFXLGVBQVcsSUFBQztRQUN2QyxpQkFBaUI7UUFFakIseUNBT2lCO1FBREQsOEdBQVcsZ0JBQVksSUFBQztRQUN4QyxpQkFBaUI7UUFFbkIsaUJBQU07O1FBakJZLGVBQWdDO1FBQWhDLDZDQUFnQyx3QkFBQSw0QkFBQSxrQ0FBQSw2QkFBQTtRQVNoQyxlQUE2RDtRQUE3RCx5RUFBNkQseUJBQUEsNkJBQUEsbUNBQUEsNkJBQUE7O2tGREdsRSxxQkFBcUI7a0RBQXJCLHFCQUFxQjtjQVhqQyxTQUFTO2VBQUM7Z0JBQ1QsUUFBUSxFQUFFLGVBQWU7Z0JBQ3pCLFdBQVcsRUFBRSw4QkFBOEI7Z0JBQzNDLFNBQVMsRUFBRSxDQUFDLDhCQUE4QixDQUFDO2dCQUMzQyxTQUFTLEVBQUUsQ0FBQzt3QkFDVixPQUFPLEVBQUUsaUJBQWlCO3dCQUMxQixXQUFXLEVBQUUsVUFBVSxDQUFDLEdBQUcsRUFBRSxDQUFDLHFCQUFxQixDQUFDO3dCQUNwRCxLQUFLLEVBQUUsSUFBSTtxQkFDWixDQUFDO2dCQUNGLGFBQWEsRUFBRSxpQkFBaUIsQ0FBQyxJQUFJO2FBQ3RDO2dCQUdVLFNBQVM7a0JBQWpCLEtBQUs7WUFDRyxjQUFjO2tCQUF0QixLQUFLO1lBQ0csY0FBYztrQkFBdEIsS0FBSztZQUNHLFVBQVU7a0JBQWxCLEtBQUs7WUFDRyxlQUFlO2tCQUF2QixLQUFLO1lBQ0csZUFBZTtrQkFBdkIsS0FBSztZQUNHLFFBQVE7a0JBQWhCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0NvbXBvbmVudCwgRXZlbnRFbWl0dGVyLCBmb3J3YXJkUmVmLCBJbnB1dCwgT3V0cHV0LCBWaWV3RW5jYXBzdWxhdGlvbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge05HX1ZBTFVFX0FDQ0VTU09SfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQge1ZhbHVlQWNjZXNzb3JCYXNlfSBmcm9tICcuLi92YWx1ZS1hY2Vzc29yLWJhc2UnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdpbnB1dC1ib29sZWFuJyxcbiAgdGVtcGxhdGVVcmw6ICdpbnB1dC1ib29sZWFuLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbJ2lucHV0LWJvb2xlYW4uY29tcG9uZW50LnNjc3MnXSxcbiAgcHJvdmlkZXJzOiBbe1xuICAgIHByb3ZpZGU6IE5HX1ZBTFVFX0FDQ0VTU09SLFxuICAgIHVzZUV4aXN0aW5nOiBmb3J3YXJkUmVmKCgpID0+IElucHV0Qm9vbGVhbkNvbXBvbmVudCksXG4gICAgbXVsdGk6IHRydWVcbiAgfV0sXG4gIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmVcbn0pXG5leHBvcnQgY2xhc3MgSW5wdXRCb29sZWFuQ29tcG9uZW50IGV4dGVuZHMgVmFsdWVBY2Nlc3NvckJhc2U8Ym9vbGVhbj4ge1xuXG4gIEBJbnB1dCgpIHRydWVMYWJlbCA9ICcnO1xuICBASW5wdXQoKSB0cnVlSWNvblByZWZpeCA9ICcnO1xuICBASW5wdXQoKSB0cnVlSWNvblN1ZmZpeCA9ICcnO1xuICBASW5wdXQoKSBmYWxzZUxhYmVsID0gJyc7XG4gIEBJbnB1dCgpIGZhbHNlSWNvblByZWZpeCA9ICcnO1xuICBASW5wdXQoKSBmYWxzZUljb25TdWZmaXggPSAnJztcbiAgQElucHV0KCkgZGlzYWJsZWQgPSBmYWxzZTtcblxuICBwdWJsaWMgdHJ1ZUNsaWNrKCk6IHZvaWQge1xuICAgIGlmICghdGhpcy5kaXNhYmxlZCAmJiAhdGhpcy52YWx1ZSkge1xuICAgICAgdGhpcy52YWx1ZSA9IHRydWU7XG4gICAgfVxuICB9XG5cbiAgcHVibGljIGZhbHNlQ2xpY2soKTogdm9pZCB7XG4gICAgaWYgKCF0aGlzLmRpc2FibGVkICYmIHRoaXMudmFsdWUpIHtcbiAgICAgIHRoaXMudmFsdWUgPSBmYWxzZTtcbiAgICB9XG4gIH1cblxufVxuIiwiPGRpdiBjbGFzcz1cImlucHV0LWJvb2xlYW5cIj5cblxuICA8cHJpbWFyeS1idXR0b24gY2xhc3M9XCJidG4tdHJ1ZVwiXG4gICAgICAgICAgICAgICAgICBbc2VsZWN0ZWRdPVwidGhpcy52YWx1ZSA9PT0gdHJ1ZVwiXG4gICAgICAgICAgICAgICAgICBbbGFiZWxdPVwidHJ1ZUxhYmVsXCJcbiAgICAgICAgICAgICAgICAgIFtpY29uXT1cInRydWVJY29uUHJlZml4XCJcbiAgICAgICAgICAgICAgICAgIFtzdWZmaXhJY29uXT1cInRydWVJY29uU3VmZml4XCJcbiAgICAgICAgICAgICAgICAgIFtidG5EaXNhYmxlZF09XCJkaXNhYmxlZFwiXG4gICAgICAgICAgICAgICAgICAob25DbGljayk9XCJ0cnVlQ2xpY2soKVwiPlxuICA8L3ByaW1hcnktYnV0dG9uPlxuXG4gIDxwcmltYXJ5LWJ1dHRvbiBjbGFzcz1cImJ0bi1mYWxzZVwiXG4gICAgICAgICAgICAgICAgICBbc2VsZWN0ZWRdPVwidGhpcy52YWx1ZSA9PT0gZmFsc2UgfHwgdGhpcy52YWx1ZSA9PT0gdW5kZWZpbmVkXCJcbiAgICAgICAgICAgICAgICAgIFtsYWJlbF09XCJmYWxzZUxhYmVsXCJcbiAgICAgICAgICAgICAgICAgIFtpY29uXT1cImZhbHNlSWNvblByZWZpeFwiXG4gICAgICAgICAgICAgICAgICBbc3VmZml4SWNvbl09XCJmYWxzZUljb25TdWZmaXhcIlxuICAgICAgICAgICAgICAgICAgW2J0bkRpc2FibGVkXT1cImRpc2FibGVkXCJcbiAgICAgICAgICAgICAgICAgIChvbkNsaWNrKT1cImZhbHNlQ2xpY2soKVwiPlxuICA8L3ByaW1hcnktYnV0dG9uPlxuXG48L2Rpdj5cbiJdfQ==

package/esm2015/input-number/input-number.component.js

@@ -0,0 +1,118 @@
+import { Component, EventEmitter, forwardRef, Input, Output, ViewEncapsulation } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { ValueAccessorBase } from '../value-acessor-base';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/form-field";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/material/icon";
+function InputNumberComponent_mat_label_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "mat-label");
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(ctx_r0.label);
+} }
+function InputNumberComponent_mat_icon_2_Template(rf, ctx) { if (rf & 1) {
+    const _r4 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-icon", 5);
+    i0.ɵɵlistener("click", function InputNumberComponent_mat_icon_2_Template_mat_icon_click_0_listener() { i0.ɵɵrestoreView(_r4); const ctx_r3 = i0.ɵɵnextContext(); return ctx_r3.prefixClick(); });
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(ctx_r1.iconPrefix);
+} }
+function InputNumberComponent_mat_icon_4_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "mat-icon", 6);
+    i0.ɵɵlistener("click", function InputNumberComponent_mat_icon_4_Template_mat_icon_click_0_listener() { i0.ɵɵrestoreView(_r6); const ctx_r5 = i0.ɵɵnextContext(); return ctx_r5.suffixClick(); });
+    i0.ɵɵtext(1);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate(ctx_r2.iconSuffix);
+} }
+export class InputNumberComponent extends ValueAccessorBase {
+    constructor() {
+        super(...arguments);
+        this.label = '';
+        this.disabled = false;
+        this.iconSuffix = '';
+        this.iconPrefix = '';
+        this.autoComplete = 'on';
+        this.suffixIconClick = new EventEmitter();
+        this.prefixIconClick = new EventEmitter();
+    }
+    onKeyDown(event) {
+        if (event.which === 32) {
+            event.target.value += ' ';
+        }
+        event.stopPropagation();
+    }
+    prefixClick() {
+        this.prefixIconClick.emit(true);
+    }
+    suffixClick() {
+        this.suffixIconClick.emit(true);
+    }
+}
+InputNumberComponent.ɵfac = function InputNumberComponent_Factory(t) { return ɵInputNumberComponent_BaseFactory(t || InputNumberComponent); };
+InputNumberComponent.ɵcmp = i0.ɵɵdefineComponent({ type: InputNumberComponent, selectors: [["input-number"]], inputs: { label: "label", disabled: "disabled", iconSuffix: "iconSuffix", iconPrefix: "iconPrefix", autoComplete: "autoComplete" }, outputs: { suffixIconClick: "suffixIconClick", prefixIconClick: "prefixIconClick" }, features: [i0.ɵɵProvidersFeature([{
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => InputNumberComponent),
+                multi: true
+            }]), i0.ɵɵInheritDefinitionFeature], decls: 5, vars: 6, consts: [["appearance", "fill", 1, "apipass-input-text", "label-input"], [4, "ngIf"], ["class", "mat-icon-prefix", "matPrefix", "", 3, "click", 4, "ngIf"], ["matInput", "", "type", "number", 1, "input-text", 3, "ngModel", "disabled", "autocomplete", "ngModelChange"], ["class", "mat-icon-suffix", "matSuffix", "", 3, "click", 4, "ngIf"], ["matPrefix", "", 1, "mat-icon-prefix", 3, "click"], ["matSuffix", "", 1, "mat-icon-suffix", 3, "click"]], template: function InputNumberComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵelementStart(0, "mat-form-field", 0);
+        i0.ɵɵtemplate(1, InputNumberComponent_mat_label_1_Template, 2, 1, "mat-label", 1);
+        i0.ɵɵtemplate(2, InputNumberComponent_mat_icon_2_Template, 2, 1, "mat-icon", 2);
+        i0.ɵɵelementStart(3, "input", 3);
+        i0.ɵɵlistener("ngModelChange", function InputNumberComponent_Template_input_ngModelChange_3_listener($event) { return ctx.value = $event; });
+        i0.ɵɵelementEnd();
+        i0.ɵɵtemplate(4, InputNumberComponent_mat_icon_4_Template, 2, 1, "mat-icon", 4);
+        i0.ɵɵelementEnd();
+    } if (rf & 2) {
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.label);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.iconPrefix);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngModel", ctx.value)("disabled", ctx.disabled)("autocomplete", ctx.autoComplete);
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("ngIf", ctx.iconSuffix);
+    } }, directives: [i1.MatFormField, i2.NgIf, i3.MatInput, i4.NumberValueAccessor, i4.DefaultValueAccessor, i4.NgControlStatus, i4.NgModel, i1.MatLabel, i5.MatIcon, i1.MatPrefix, i1.MatSuffix], styles: [":root{--color-body-light:#fff;--color-fonts-tertiary:#777;--color-inputs-background:#fff;--color-inputs-border:#ddd;--color-primary:#222d57;--color-primary-active:#29376a;--color-primary-hover:#18203d;--color-red:red;--color-secondary:#d3d921;--color-secondary-active:#dce13f;--color-secondary-hover:#b3b81c;--color-tertiary:#efefef;--color-tertiary-active:#f1f1f1;--color-tertiary-hover:#cbcbcb;--color_components_light:#fff;--color_disabled:#e0e0e0;--color_graph_error:#eb5757;--color_graph_error_hover:#c91717;--color_graph_primary:#1643ef;--color_graph_primary_hover:#0a2692;--color_icon_remove:var(--color-red);--color_icon_success:#070;--limit-plan-color:#ff6c00}@font-face{font-display:swap;font-family:PT Sans;font-style:italic;font-weight:400;src:local(\"PT Sans Italic\"),local(\"PTSans-Italic\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizYRExUiTo99u79D0e0ysmIEDQ.woff2) format(\"woff2\");unicode-range:U+0460-052f,U+1c80-1c88,U+20b4,U+2de0-2dff,U+a640-a69f,U+fe2e-fe2f}@font-face{font-display:swap;font-family:PT Sans;font-style:italic;font-weight:400;src:local(\"PT Sans Italic\"),local(\"PTSans-Italic\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizYRExUiTo99u79D0e0w8mIEDQ.woff2) format(\"woff2\");unicode-range:U+0400-045f,U+0490-0491,U+04b0-04b1,U+2116}@font-face{font-display:swap;font-family:PT Sans;font-style:italic;font-weight:400;src:local(\"PT Sans Italic\"),local(\"PTSans-Italic\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizYRExUiTo99u79D0e0ycmIEDQ.woff2) format(\"woff2\");unicode-range:U+0100-024f,U+0259,U+1e??,U+2020,U+20a0-20ab,U+20ad-20cf,U+2113,U+2c60-2c7f,U+a720-a7ff}@font-face{font-display:swap;font-family:PT Sans;font-style:italic;font-weight:400;src:local(\"PT Sans Italic\"),local(\"PTSans-Italic\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizYRExUiTo99u79D0e0x8mI.woff2) format(\"woff2\");unicode-range:U+00??,U+0131,U+0152-0153,U+02bb-02bc,U+02c6,U+02da,U+02dc,U+2000-206f,U+2074,U+20ac,U+2122,U+2191,U+2193,U+2212,U+2215,U+feff,U+fffd}@font-face{font-display:swap;font-family:PT Sans;font-style:italic;font-weight:700;src:local(\"PT Sans Bold Italic\"),local(\"PTSans-BoldItalic\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizdRExUiTo99u79D0e8fOydIhUdwzM.woff2) format(\"woff2\");unicode-range:U+0460-052f,U+1c80-1c88,U+20b4,U+2de0-2dff,U+a640-a69f,U+fe2e-fe2f}@font-face{font-display:swap;font-family:PT Sans;font-style:italic;font-weight:700;src:local(\"PT Sans Bold Italic\"),local(\"PTSans-BoldItalic\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizdRExUiTo99u79D0e8fOydKxUdwzM.woff2) format(\"woff2\");unicode-range:U+0400-045f,U+0490-0491,U+04b0-04b1,U+2116}@font-face{font-display:swap;font-family:PT Sans;font-style:italic;font-weight:700;src:local(\"PT Sans Bold Italic\"),local(\"PTSans-BoldItalic\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizdRExUiTo99u79D0e8fOydIRUdwzM.woff2) format(\"woff2\");unicode-range:U+0100-024f,U+0259,U+1e??,U+2020,U+20a0-20ab,U+20ad-20cf,U+2113,U+2c60-2c7f,U+a720-a7ff}@font-face{font-display:swap;font-family:PT Sans;font-style:italic;font-weight:700;src:local(\"PT Sans Bold Italic\"),local(\"PTSans-BoldItalic\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizdRExUiTo99u79D0e8fOydLxUd.woff2) format(\"woff2\");unicode-range:U+00??,U+0131,U+0152-0153,U+02bb-02bc,U+02c6,U+02da,U+02dc,U+2000-206f,U+2074,U+20ac,U+2122,U+2191,U+2193,U+2212,U+2215,U+feff,U+fffd}@font-face{font-display:swap;font-family:PT Sans;font-style:normal;font-weight:400;src:local(\"PT Sans\"),local(\"PTSans-Regular\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizaRExUiTo99u79D0-ExdGM.woff2) format(\"woff2\");unicode-range:U+0460-052f,U+1c80-1c88,U+20b4,U+2de0-2dff,U+a640-a69f,U+fe2e-fe2f}@font-face{font-display:swap;font-family:PT Sans;font-style:normal;font-weight:400;src:local(\"PT Sans\"),local(\"PTSans-Regular\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizaRExUiTo99u79D0aExdGM.woff2) format(\"woff2\");unicode-range:U+0400-045f,U+0490-0491,U+04b0-04b1,U+2116}@font-face{font-display:swap;font-family:PT Sans;font-style:normal;font-weight:400;src:local(\"PT Sans\"),local(\"PTSans-Regular\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizaRExUiTo99u79D0yExdGM.woff2) format(\"woff2\");unicode-range:U+0100-024f,U+0259,U+1e??,U+2020,U+20a0-20ab,U+20ad-20cf,U+2113,U+2c60-2c7f,U+a720-a7ff}@font-face{font-display:swap;font-family:PT Sans;font-style:normal;font-weight:400;src:local(\"PT Sans\"),local(\"PTSans-Regular\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizaRExUiTo99u79D0KExQ.woff2) format(\"woff2\");unicode-range:U+00??,U+0131,U+0152-0153,U+02bb-02bc,U+02c6,U+02da,U+02dc,U+2000-206f,U+2074,U+20ac,U+2122,U+2191,U+2193,U+2212,U+2215,U+feff,U+fffd}@font-face{font-display:swap;font-family:PT Sans;font-style:normal;font-weight:700;src:local(\"PT Sans Bold\"),local(\"PTSans-Bold\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizfRExUiTo99u79B_mh0OOtLQ0Z.woff2) format(\"woff2\");unicode-range:U+0460-052f,U+1c80-1c88,U+20b4,U+2de0-2dff,U+a640-a69f,U+fe2e-fe2f}@font-face{font-display:swap;font-family:PT Sans;font-style:normal;font-weight:700;src:local(\"PT Sans Bold\"),local(\"PTSans-Bold\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizfRExUiTo99u79B_mh0OqtLQ0Z.woff2) format(\"woff2\");unicode-range:U+0400-045f,U+0490-0491,U+04b0-04b1,U+2116}@font-face{font-display:swap;font-family:PT Sans;font-style:normal;font-weight:700;src:local(\"PT Sans Bold\"),local(\"PTSans-Bold\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizfRExUiTo99u79B_mh0OCtLQ0Z.woff2) format(\"woff2\");unicode-range:U+0100-024f,U+0259,U+1e??,U+2020,U+20a0-20ab,U+20ad-20cf,U+2113,U+2c60-2c7f,U+a720-a7ff}@font-face{font-display:swap;font-family:PT Sans;font-style:normal;font-weight:700;src:local(\"PT Sans Bold\"),local(\"PTSans-Bold\"),url(https://fonts.gstatic.com/s/ptsans/v11/jizfRExUiTo99u79B_mh0O6tLQ.woff2) format(\"woff2\");unicode-range:U+00??,U+0131,U+0152-0153,U+02bb-02bc,U+02c6,U+02da,U+02dc,U+2000-206f,U+2074,U+20ac,U+2122,U+2191,U+2193,U+2212,U+2215,U+feff,U+fffd}.text-primary{color:var(--color-primary)!important}.text-secondary{color:var(--color-secondary)!important}.text-tertiary{color:var(--color-fonts-tertiary)!important}.text-weight-bold{font-weight:700!important}.text-weight-normal{font-weight:400!important}.mat-form-field-underline,.mat-input-underline{display:none}.mat-form-field-appearance-fill .mat-form-field-flex{align-items:center!important;background:var(--color-inputs-background)!important;border:1px solid var(--color-inputs-border)!important;border-radius:6px!important;display:flex!important}.mat-form-field-infix{align-items:center!important;border-top:none!important;padding:0!important}.mat-form-field-infix,.mat-select-arrow-wrapper{display:flex!important}.mat-icon-button{width:auto!important}.no-border .mat-form-field-flex{border:none!important}.no-border .mat-form-field-flex input{padding:1px}.mat-form-field-label-wrapper{top:-10px}.mat-form-field-should-float .mat-form-field-label-wrapper{font-size:14px}.placeholder-primary .mat-focused .mat-form-field-placeholder,.placeholder-primary .mat-form-field-label-wrapper,.placeholder-primary .mat-form-field-label-wrapper label,.placeholder-primary .mat-form-field-placeholder,.placeholder-primary ::ng-deep .mat-focused .mat-form-field-placeholder,.placeholder-primary ::ng-deep .mat-form-field-placeholder{color:var(--color-primary)!important}.placeholder-primary input ::placeholder{color:var(--color-primary)!important}.placeholder-bold .mat-focused .mat-form-field-placeholder,.placeholder-bold .mat-form-field-label-wrapper,.placeholder-bold .mat-form-field-label-wrapper label,.placeholder-bold .mat-form-field-placeholder,.placeholder-bold ::ng-deep .mat-focused .mat-form-field-placeholder,.placeholder-bold ::ng-deep .mat-form-field-placeholder{font-weight:700!important}.placeholder-bold input ::placeholder{font-weight:700!important}.apipass-input-text{width:100%}.apipass-input-text .mat-form-field-flex{padding:10px!important}.apipass-date-filter .mat-form-field-wrapper,.apipass-input-text .mat-form-field-wrapper,.apipass-search-input-text .mat-form-field-wrapper,.apipass-select .mat-form-field-wrapper,.custom-select-component .mat-form-field-wrapper{padding:0!important}.apipass-date-filter .mat-icon-button,.apipass-input-text .mat-icon-button,.apipass-search-input-text .mat-icon-button,.apipass-select .mat-icon-button,.custom-select-component .mat-icon-button{height:auto!important;width:auto!important}.apipass-date-filter.label-input .mat-form-field-label-wrapper,.apipass-input-text.label-input .mat-form-field-label-wrapper,.apipass-search-input-text.label-input .mat-form-field-label-wrapper,.apipass-select.label-input .mat-form-field-label-wrapper,.custom-select-component.label-input .mat-form-field-label-wrapper{padding-top:0;top:auto!important}.apipass-date-filter.label-input input,.apipass-input-text.label-input input,.apipass-search-input-text.label-input input,.apipass-select.label-input input,.custom-select-component.label-input input{padding-bottom:5px!important;padding-top:10px!important}.apipass-date-filter.mat-form-field-should-float .mat-form-field-label-wrapper,.apipass-input-text.mat-form-field-should-float .mat-form-field-label-wrapper,.apipass-search-input-text.mat-form-field-should-float .mat-form-field-label-wrapper,.apipass-select.mat-form-field-should-float .mat-form-field-label-wrapper,.custom-select-component.mat-form-field-should-float .mat-form-field-label-wrapper{margin-top:-10px!important;padding-top:0!important}.apipass-search-input-text{width:100%}.apipass-search-input-text.small-text{font-size:12px}.apipass-search-input-text .mat-form-field-flex{border-left:none!important;border-radius:0!important;border-right:none!important;border-top:none!important;padding:2px 5px 2px 2px!important}.apipass-search-input-text .search-icon{margin-top:-5px!important}.custom-select-component{width:100%}.custom-select-component .mat-form-field-flex{padding:1px 10px!important}.apipass-select{width:100%}.apipass-select .mat-form-field-flex{padding:10px 5px 10px 10px!important}.apipass-select.label-input .mat-form-field-infix{padding-bottom:7px!important;padding-top:7px!important}.apipass-date-filter{width:100%}.apipass-date-filter .mat-form-field-flex{padding:7px 10px!important}.apipass-date-filter .mat-form-field-suffix span{color:#777;cursor:pointer}.apipass-date-filter .mat-form-field-wrapper{padding-bottom:0!important}.apipass-input-text .mat-icon-suffix{margin-left:5px}.apipass-input-text .mat-icon-prefix{margin-right:5px}"], encapsulation: 2 });
+const ɵInputNumberComponent_BaseFactory = /*@__PURE__*/ i0.ɵɵgetInheritedFactory(InputNumberComponent);
+/*@__PURE__*/ (function () { i0.ɵsetClassMetadata(InputNumberComponent, [{
+        type: Component,
+        args: [{
+                selector: 'input-number',
+                templateUrl: 'input-number.component.html',
+                styleUrls: ['input-number.component.scss'],
+                providers: [{
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => InputNumberComponent),
+                        multi: true
+                    }],
+                encapsulation: ViewEncapsulation.None
+            }]
+    }], null, { label: [{
+            type: Input
+        }], disabled: [{
+            type: Input
+        }], iconSuffix: [{
+            type: Input
+        }], iconPrefix: [{
+            type: Input
+        }], autoComplete: [{
+            type: Input
+        }], suffixIconClick: [{
+            type: Output
+        }], prefixIconClick: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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