@ardium-ui/ui 1.0.0

package/esm2022/lib/inputs/input-types.mjs

@@ -0,0 +1,6 @@
+export const CaseTransformerType = {
+    NoChange: 'nochange',
+    Uppercase: 'uppercase',
+    Lowercase: 'lowercase',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2lucHV0cy9pbnB1dC10eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRztJQUMvQixRQUFRLEVBQUUsVUFBVTtJQUNwQixTQUFTLEVBQUUsV0FBVztJQUN0QixTQUFTLEVBQUUsV0FBVztDQUNoQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IENhc2VUcmFuc2Zvcm1lclR5cGUgPSB7XG4gICAgTm9DaGFuZ2U6ICdub2NoYW5nZScsXG4gICAgVXBwZXJjYXNlOiAndXBwZXJjYXNlJyxcbiAgICBMb3dlcmNhc2U6ICdsb3dlcmNhc2UnLFxufSBhcyBjb25zdDtcbmV4cG9ydCB0eXBlIENhc2VUcmFuc2Zvcm1lclR5cGUgPSAodHlwZW9mIENhc2VUcmFuc2Zvcm1lclR5cGUpW2tleW9mIHR5cGVvZiBDYXNlVHJhbnNmb3JtZXJUeXBlXTtcbiJdfQ==

package/esm2022/lib/inputs/input-utils.mjs

@@ -0,0 +1,205 @@
+import { isAnyString, isNull, isNumber } from 'simple-bool';
+import { ArdTransformer, RegExpTransformer } from './input-transformers';
+export class SimpleInputModel {
+    constructor(inputEl, hostComp) {
+        this.inputEl = inputEl;
+        this._value = null;
+        this._hostComp = hostComp;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+    }
+    get stringValue() {
+        return this._value ?? '';
+    }
+    set stringValue(v) {
+        this._value = v || null;
+    }
+    writeValue(v) {
+        if (!isAnyString(v) && !isNull(v)) {
+            //warn when using non-string/non-null value
+            console.warn(new Error(`Trying to set simple-input's value to ${typeof v}, expected string.`));
+            //normalize the value
+            v = v?.toString?.() ?? String(v);
+        }
+        return this._writeValue(v);
+    }
+    _writeValue(v) {
+        //constraints
+        v = this._applyLengthTransformer(v);
+        //update view
+        let oldVal = this.value;
+        this.value = v;
+        this._updateInputElement();
+        return oldVal !== v;
+    }
+    rewriteValueAfterHostUpdate() {
+        this._writeValue(this._value);
+    }
+    clear() {
+        this._value = null;
+        this._updateInputElement();
+    }
+    _updateInputElement() {
+        this.inputEl.value = this.stringValue;
+    }
+    get caretPos() {
+        return this.inputEl.selectionEnd ?? this.stringValue.length;
+    }
+    set caretPos(pos) {
+        this.inputEl.setSelectionRange(pos, pos);
+    }
+    //* constraints
+    _applyLengthTransformer(v) {
+        //exit if max length not specified
+        if (this._hostComp.maxLength == undefined)
+            return v;
+        //exit if not value
+        //exit if value length is less than specified max length
+        if (!v || v.length <= this._hostComp.maxLength)
+            return v;
+        //cut the excess off
+        v = v.substring(0, this._hostComp.maxLength);
+        this.caretPos = this._hostComp.maxLength;
+        return v;
+    }
+}
+export class InputModel extends SimpleInputModel {
+    constructor(inputEl, hostComp) {
+        super(inputEl, hostComp);
+    }
+    _writeValue(v) {
+        //transformers
+        if (v) {
+            let prev = this.stringValue;
+            v = this._applyAllowOrDenylistTransformer(v, prev);
+            prev = this.stringValue;
+            v = this._applyLengthTransformer(v);
+        }
+        let oldVal = this.value;
+        //update view
+        this.value = v;
+        this._updateInputElement();
+        return oldVal !== v;
+    }
+    setSelection(from, to) {
+        to = to ?? this.value?.length ?? Infinity;
+        this.inputEl.setSelectionRange(from, to);
+    }
+    //* constraints
+    _applyAllowOrDenylistTransformer(v, prev) {
+        if (!this._hostComp.charlist || !v)
+            return v;
+        let { text, caretPos } = new RegExpTransformer(this._hostComp.charlist).apply(v, prev, this.caretPos);
+        this.caretPos = caretPos;
+        return text;
+    }
+}
+export class NumberInputModel {
+    constructor(inputEl, hostComp) {
+        this.inputEl = inputEl;
+        //! value setters/getters
+        this._value = null;
+        this._hostComp = hostComp;
+    }
+    get value() {
+        return this._value;
+    }
+    set value(v) {
+        this._value = v;
+    }
+    //value as string
+    get stringValue() {
+        return this._value ?? '';
+    }
+    set stringValue(v) {
+        this._value = v || null;
+    }
+    //value as number
+    get numberValue() {
+        return (this._value == null && null) || Number(this._value);
+    }
+    set numberValue(v) {
+        this._value = v == null ? null : v.toString();
+    }
+    //! write value handlers
+    writeValue(v) {
+        if (!isNumber(v) && !isAnyString(v) && !isNull(v)) {
+            //warn when using non-string/non-null value
+            console.warn(new Error(`Trying to set simple-input's value to ${typeof v}, expected string, number, or null.`));
+            //normalize the value
+            v = v?.toString?.() ?? String(v);
+        }
+        v = String(v);
+        return this._writeValue(v);
+    }
+    _writeValue(v) {
+        //constraints
+        if (v) {
+            v = this._removeDecimalPlaces(v);
+            v = this._applyNumberConstraint(v);
+            v = this._applyMinMaxConstraints(v);
+        }
+        //update view
+        let oldVal = this.value;
+        this.value = v;
+        this._updateInputElement();
+        return oldVal !== v;
+    }
+    rewriteValueAfterHostUpdate() {
+        this._writeValue(this._value);
+    }
+    //! input element methods
+    _updateInputElement() {
+        this.inputEl.value = this.stringValue;
+    }
+    get caretPos() {
+        return this.inputEl.selectionEnd ?? this.stringValue.length;
+    }
+    set caretPos(pos) {
+        this.inputEl.setSelectionRange(pos, pos);
+    }
+    //! constraints
+    _removeDecimalPlaces(v) {
+        if (!v)
+            return '';
+        if (this._hostComp.allowFloat)
+            return v;
+        if (v.match(/[.,].+/)) {
+            const num = Number(v);
+            if (!isNaN(num))
+                v = Math.round(num).toString();
+        }
+        return v;
+    }
+    _applyNumberConstraint(v) {
+        if (!v)
+            return '';
+        if (this._hostComp.allowFloat) {
+            const { text, caretPos } = ArdTransformer.Float(v, this.stringValue, this.caretPos);
+            this.caretPos = caretPos;
+            return text;
+        }
+        const { text, caretPos } = ArdTransformer.Integer(v, this.stringValue, this.caretPos);
+        this.caretPos = caretPos;
+        return text;
+    }
+    _applyMinMaxConstraints(v) {
+        if (!v)
+            return '';
+        const numericValue = Number(v);
+        if (numericValue > this._hostComp.max)
+            return this._hostComp.max.toString();
+        if (numericValue < this._hostComp.min)
+            return this._hostComp.min.toString();
+        return v;
+    }
+}
+export function escapeAndCreateRegex(str, flags, negated = true) {
+    str = str.replace(/([\]]+)/g, '\\$1');
+    return new RegExp(`[${negated ? '^' : ''}${str}]`, flags);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-utils.js","sourceRoot":"","sources":["../../../../../projects/ui/src/lib/inputs/input-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { isAnyString, isNull, isNumber } from 'simple-bool';\nimport { ArdTransformer, RegExpTransformer } from './input-transformers';\n\nexport interface SimpleInputModelHost {\n    maxLength?: number;\n}\nexport class SimpleInputModel {\n    protected _hostComp!: SimpleInputModelHost;\n    constructor(\n        protected inputEl: HTMLInputElement,\n        hostComp: SimpleInputModelHost\n    ) {\n        this._hostComp = hostComp;\n    }\n\n    protected _value: string | null = null;\n    get value(): string | null {\n        return this._value;\n    }\n    set value(v: string | null) {\n        this._value = v;\n    }\n    get stringValue(): string {\n        return this._value ?? '';\n    }\n    set stringValue(v: string) {\n        this._value = v || null;\n    }\n\n    writeValue(v: any): boolean {\n        if (!isAnyString(v) && !isNull(v)) {\n            //warn when using non-string/non-null value\n            console.warn(new Error(`Trying to set simple-input's value to ${typeof v}, expected string.`));\n            //normalize the value\n            v = v?.toString?.() ?? String(v);\n        }\n        return this._writeValue(v);\n    }\n    protected _writeValue(v: string | null): boolean {\n        //constraints\n        v = this._applyLengthTransformer(v);\n        //update view\n        let oldVal = this.value;\n        this.value = v;\n        this._updateInputElement();\n        return oldVal !== v;\n    }\n    rewriteValueAfterHostUpdate(): void {\n        this._writeValue(this._value);\n    }\n    clear(): void {\n        this._value = null;\n        this._updateInputElement();\n    }\n\n    _updateInputElement() {\n        this.inputEl.value = this.stringValue;\n    }\n    get caretPos(): number {\n        return this.inputEl.selectionEnd ?? this.stringValue.length;\n    }\n    set caretPos(pos: number) {\n        this.inputEl.setSelectionRange(pos, pos);\n    }\n    //* constraints\n    protected _applyLengthTransformer(v: string | null): string | null {\n        //exit if max length not specified\n        if (this._hostComp.maxLength == undefined) return v;\n        //exit if not value\n        //exit if value length is less than specified max length\n        if (!v || v.length <= this._hostComp.maxLength) return v;\n        //cut the excess off\n        v = v.substring(0, this._hostComp.maxLength);\n        this.caretPos = this._hostComp.maxLength;\n        return v;\n    }\n}\nexport interface InputModelHost extends SimpleInputModelHost {\n    charlist?: RegExp;\n}\nexport class InputModel extends SimpleInputModel {\n    protected override _hostComp!: InputModelHost;\n    constructor(inputEl: HTMLInputElement, hostComp: InputModelHost) {\n        super(inputEl, hostComp);\n    }\n    protected override _writeValue(v: string | null): boolean {\n        //transformers\n        if (v) {\n            let prev = this.stringValue;\n            v = this._applyAllowOrDenylistTransformer(v, prev);\n            prev = this.stringValue;\n            v = this._applyLengthTransformer(v);\n        }\n        let oldVal = this.value;\n        //update view\n        this.value = v;\n        this._updateInputElement();\n        return oldVal !== v;\n    }\n\n    setSelection(from: number | null, to: number | null): void;\n    setSelection(from: number | null, to?: number | null): void {\n        to = to ?? this.value?.length ?? Infinity;\n        this.inputEl.setSelectionRange(from, to);\n    }\n    //* constraints\n    protected _applyAllowOrDenylistTransformer(v: string, prev: string): string {\n        if (!this._hostComp.charlist || !v) return v;\n        let { text, caretPos } = new RegExpTransformer(this._hostComp.charlist).apply(v, prev, this.caretPos);\n        this.caretPos = caretPos;\n        return text;\n    }\n}\n\nexport interface NumberInputModelHost {\n    max: number;\n    min: number;\n    allowFloat: boolean;\n}\nexport class NumberInputModel {\n    protected _hostComp!: NumberInputModelHost;\n    constructor(\n        protected inputEl: HTMLInputElement,\n        hostComp: NumberInputModelHost\n    ) {\n        this._hostComp = hostComp;\n    }\n\n    //! value setters/getters\n    protected _value: string | null = null;\n    get value(): string | null {\n        return this._value;\n    }\n    set value(v: string | null) {\n        this._value = v;\n    }\n    //value as string\n    get stringValue(): string {\n        return this._value ?? '';\n    }\n    set stringValue(v: string) {\n        this._value = v || null;\n    }\n    //value as number\n    get numberValue(): number | null {\n        return (this._value == null && null) || Number(this._value);\n    }\n    set numberValue(v: number | null) {\n        this._value = v == null ? null : v.toString();\n    }\n\n    //! write value handlers\n    writeValue(v: any): boolean {\n        if (!isNumber(v) && !isAnyString(v) && !isNull(v)) {\n            //warn when using non-string/non-null value\n            console.warn(new Error(`Trying to set simple-input's value to ${typeof v}, expected string, number, or null.`));\n            //normalize the value\n            v = v?.toString?.() ?? String(v);\n        }\n        v = String(v);\n        return this._writeValue(v);\n    }\n    protected _writeValue(v: string | null): boolean {\n        //constraints\n        if (v) {\n            v = this._removeDecimalPlaces(v);\n            v = this._applyNumberConstraint(v);\n            v = this._applyMinMaxConstraints(v);\n        }\n        //update view\n        let oldVal = this.value;\n        this.value = v;\n        this._updateInputElement();\n        return oldVal !== v;\n    }\n    rewriteValueAfterHostUpdate(): void {\n        this._writeValue(this._value);\n    }\n\n    //! input element methods\n    _updateInputElement() {\n        this.inputEl.value = this.stringValue;\n    }\n    get caretPos(): number {\n        return this.inputEl.selectionEnd ?? this.stringValue.length;\n    }\n    set caretPos(pos: number) {\n        this.inputEl.setSelectionRange(pos, pos);\n    }\n\n    //! constraints\n    private _removeDecimalPlaces(v: string): string {\n        if (!v) return '';\n        if (this._hostComp.allowFloat) return v;\n\n        if (v.match(/[.,].+/)) {\n            const num = Number(v);\n            if (!isNaN(num)) v = Math.round(num).toString();\n        }\n        return v;\n    }\n    private _applyNumberConstraint(v: string): string {\n        if (!v) return '';\n\n        if (this._hostComp.allowFloat) {\n            const { text, caretPos } = ArdTransformer.Float(v, this.stringValue, this.caretPos);\n            this.caretPos = caretPos;\n            return text;\n        }\n        const { text, caretPos } = ArdTransformer.Integer(v, this.stringValue, this.caretPos);\n        this.caretPos = caretPos;\n        return text;\n    }\n    private _applyMinMaxConstraints(v: string): string {\n        if (!v) return '';\n\n        const numericValue = Number(v);\n        if (numericValue > this._hostComp.max) return this._hostComp.max.toString();\n        if (numericValue < this._hostComp.min) return this._hostComp.min.toString();\n        return v;\n    }\n}\n\nexport function escapeAndCreateRegex(str: string, flags?: string, negated: boolean = true): RegExp {\n    str = str.replace(/([\\]]+)/g, '\\\\$1');\n    return new RegExp(`[${negated ? '^' : ''}${str}]`, flags);\n}\n"]}

package/esm2022/lib/inputs/number-input/number-input.component.mjs

@@ -0,0 +1,289 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, Input, Output, ViewChild, ViewEncapsulation, ContentChild, TemplateRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { coerceBooleanProperty, coerceNumberProperty } from '@ardium-ui/devkit';
+import { ButtonVariant, ButtonAppearance } from '../../buttons/general-button.types';
+import { OneAxisAlignment } from '../../types/alignment.types';
+import { FormElementAppearance, FormElementVariant } from '../../types/theming.types';
+import { _NgModelComponentBase } from '../../_internal/ngmodel-component';
+import { NumberInputModel } from '../input-utils';
+import { isDefined, isFloat } from 'simple-bool';
+import { ArdNumberInputPlaceholderTemplateDirective } from './number-input.directives';
+import { roundToPrecision } from 'more-rounding';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ardium-ui/devkit";
+import * as i3 from "../../buttons/button/button.component";
+export class ArdiumNumberInputComponent extends _NgModelComponentBase {
+    constructor() {
+        super(...arguments);
+        //! placeholder
+        this.placeholder = '';
+        //! appearance
+        this.appearance = FormElementAppearance.Outlined;
+        this.variant = FormElementVariant.Rounded;
+        this.alignText = OneAxisAlignment.Middle;
+        this._compact = false;
+        //! other inputs
+        this.inputAttrs = {};
+        //! value two-way binding
+        this._valueBeforeInit = '0';
+        this.valueChange = new EventEmitter();
+        //* event emitters
+        this.inputEvent = new EventEmitter();
+        this.changeEvent = new EventEmitter();
+        this.clearEvent = new EventEmitter();
+        this.quickChangeEvent = new EventEmitter();
+        //! min/max and number type
+        this._min = 0;
+        this._max = 999;
+        this._allowFloat = undefined;
+        //! incerement/decrement buttons
+        this._allowQuickChange = true;
+        this._stepSize = 1;
+    }
+    ngOnInit() {
+        this.inputModel = new NumberInputModel(this.textInputEl.nativeElement, this);
+        this._setInputAttributes();
+        //set the value
+        if (this._valueBeforeInit) {
+            this.writeValue(this._valueBeforeInit);
+            delete this._valueBeforeInit;
+        }
+    }
+    get shouldDisplayPlaceholder() {
+        return Boolean(this.placeholder) && !this.inputModel.stringValue;
+    }
+    get compact() {
+        return this._compact;
+    }
+    set compact(v) {
+        this._compact = coerceBooleanProperty(v);
+    }
+    get ngClasses() {
+        return [
+            `ard-appearance-${this.appearance}`,
+            `ard-variant-${this.variant}`,
+            `ard-text-align-${this.alignText}`,
+            `ard-quick-change-${this.allowQuickChange}`,
+            this.compact ? 'ard-compact' : '',
+        ].join(' ');
+    }
+    get buttonVariant() {
+        if (this.variant == FormElementVariant.Rounded)
+            return ButtonVariant.Rounded;
+        if (this.variant == FormElementVariant.Pill)
+            return ButtonVariant.Pill;
+        if (this.variant == FormElementVariant.Sharp)
+            return ButtonVariant.Sharp;
+        return ButtonVariant.Rounded;
+    }
+    get buttonAppearance() {
+        if (this.appearance == FormElementAppearance.Outlined && this.variant != FormElementVariant.Pill)
+            return ButtonAppearance.Outlined;
+        return ButtonAppearance.Transparent;
+    }
+    //! control value accessor's write value implementation
+    writeValue(v) {
+        this.inputModel.writeValue(v);
+    }
+    set value(v) {
+        if (typeof v == 'number')
+            v = v.toString();
+        if (!this.inputModel) {
+            this._valueBeforeInit = v;
+            return;
+        }
+        this.writeValue(v);
+    }
+    get min() {
+        return this._min;
+    }
+    set min(v) {
+        this._min = coerceNumberProperty(v);
+    }
+    get max() {
+        return this._max;
+    }
+    set max(v) {
+        this._max = coerceNumberProperty(v);
+    }
+    get allowFloat() {
+        return this._allowFloat ?? isFloat(this._stepSize);
+    }
+    set allowFloat(v) {
+        this._allowFloat = coerceBooleanProperty(v);
+    }
+    get allowQuickChange() {
+        return this._allowQuickChange;
+    }
+    set allowQuickChange(v) {
+        this._allowQuickChange = coerceBooleanProperty(v);
+    }
+    get stepSize() {
+        return this._stepSize;
+    }
+    set stepSize(v) {
+        this._stepSize = coerceNumberProperty(v);
+    }
+    onQuickChangeButtonClick(direction, event) {
+        let num = this.inputModel.numberValue;
+        if (!num)
+            num = 0;
+        if (direction == 1 && num >= this.max)
+            return;
+        if (direction == -1 && num <= this.min)
+            return;
+        if (event)
+            event.stopPropagation();
+        const newValue = num + this.stepSize * direction;
+        //round to 9 decimal places to avoid floating point arithmetic errors
+        //9 is an arbitrary number that just works well. ¯\_(ツ)_/¯
+        const newValuePrecise = roundToPrecision(newValue, 9);
+        this.writeValue(newValuePrecise);
+        this.quickChangeEvent.next({ direction, value: newValuePrecise });
+        this._emitChange();
+        this._checkButtonAvailability();
+    }
+    _checkButtonAvailability() {
+        if (!this.canDecrement() || !this.canIncrement())
+            this.focus();
+    }
+    canIncrement() {
+        const num = this.inputModel.numberValue;
+        return !isDefined(num) || num < this.max;
+    }
+    canDecrement() {
+        const num = this.inputModel.numberValue;
+        return !isDefined(num) || num > this.min;
+    }
+    //! event handlers
+    onInput(newVal) {
+        let valueHasChanged = this.inputModel.writeValue(newVal);
+        if (!valueHasChanged)
+            return;
+        this._emitInput();
+    }
+    _emitInput() {
+        this.inputEvent.emit(this.inputModel.numberValue);
+        this._emitChange();
+    }
+    //focus, blur, change
+    onFocusMaster(event) {
+        this.onFocus(event);
+    }
+    onBlurMaster(event) {
+        this.onBlur(event);
+    }
+    //change
+    onChange(event) {
+        event.stopPropagation();
+        this._emitChange();
+    }
+    _emitChange() {
+        const v = this.inputModel.numberValue;
+        this._onChangeRegistered?.(v);
+        this.changeEvent.emit(v);
+        this.valueChange.emit(this.inputModel.numberValue);
+    }
+    //smart focus
+    onMouseup(event) {
+        const selection = window.getSelection();
+        if (selection && selection.type === 'Range')
+            return;
+        this.focus();
+    }
+    // copy
+    onCopy(event) {
+        if (this.value &&
+            //does the selection cover the entire input
+            ((this.textInputEl.nativeElement.selectionStart == 0 &&
+                this.textInputEl.nativeElement.selectionEnd == this.textInputEl.nativeElement.value.length) ||
+                //or is zero-wide
+                this.textInputEl.nativeElement.selectionStart == this.textInputEl.nativeElement.selectionEnd)) {
+            event.clipboardData?.setData('text/plain', String(this.value));
+            event.preventDefault();
+        }
+    }
+    //! helpers
+    _setInputAttributes() {
+        const input = this.textInputEl.nativeElement;
+        const attributes = {
+            type: 'text',
+            autocorrect: 'off',
+            autocapitalize: 'off',
+            autocomplete: 'off',
+            tabindex: String(this.tabIndex),
+            ...this.inputAttrs,
+        };
+        for (const key of Object.keys(attributes)) {
+            input.setAttribute(key, String(attributes[key]));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumNumberInputComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.7", type: ArdiumNumberInputComponent, selector: "ard-number-input", inputs: { inputId: "inputId", placeholder: "placeholder", appearance: "appearance", variant: "variant", alignText: "alignText", compact: "compact", inputAttrs: "inputAttrs", value: "value", min: "min", max: "max", allowFloat: "allowFloat", allowQuickChange: "allowQuickChange", stepSize: "stepSize" }, outputs: { valueChange: "valueChange", inputEvent: "input", changeEvent: "change", clearEvent: "clear", quickChangeEvent: "quickChange" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => ArdiumNumberInputComponent),
+                multi: true,
+            },
+        ], queries: [{ propertyName: "placeholderTemplate", first: true, predicate: ArdNumberInputPlaceholderTemplateDirective, descendants: true, read: TemplateRef }], viewQueries: [{ propertyName: "textInputEl", first: true, predicate: ["textInput"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<div class=\"ard-number-input\"\r\n    [ngClass]=\"ngClasses\"\r\n    [class.ard-has-value]=\"value\"\r\n    (mousedown)=\"$event.preventDefault()\"\r\n    (mouseup)=\"onMouseup($event)\"\r\n>\r\n    <ard-button *ngIf=\"allowQuickChange\"\r\n        class=\"ard-quick-change-button decrement\"\r\n        [variant]=\"buttonVariant\"\r\n        [appearance]=\"buttonAppearance\"\r\n        color=\"none\"\r\n        [disabled]=\"!canDecrement()\"\r\n        [tabIndex]=\"!canDecrement() ? -1 : tabIndex\"\r\n        (click)=\"onQuickChangeButtonClick(-1, $event)\"\r\n        (ardHold)=\"onQuickChangeButtonClick(-1)\"\r\n        ardHoldSpaceKey\r\n    >-</ard-button>\r\n    <div class=\"ard-input-container\">\r\n        <ng-container *ngIf=\"shouldDisplayPlaceholder\">\r\n            <ng-template #defaultPlaceholderTemplate>\r\n                <div class=\"ard-placeholder\">{{ placeholder }}</div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"placeholderTemplate || defaultPlaceholderTemplate\"></ng-template>\r\n        </ng-container>\r\n\r\n        <input #textInput\r\n            #focusableElement\r\n            type=\"text\"\r\n            [attr.id]=\"inputId\"\r\n            [attr.tabindex]=\"tabIndex\"\r\n            [readonly]=\"readonly\"\r\n            [disabled]=\"disabled\"\r\n            (input)=\"onInput(textInput.value)\"\r\n            (focus)=\"onFocusMaster($event)\"\r\n            (blur)=\"onBlurMaster($event)\"\r\n            (change)=\"onChange($event)\"\r\n            (mousedown)=\"$event.stopPropagation()\"\r\n            (mouseup)=\"$event.stopPropagation()\"\r\n            (copy)=\"onCopy($event)\"\r\n        >\r\n    </div>\r\n    <ard-button *ngIf=\"allowQuickChange\"\r\n        class=\"ard-quick-change-button increment\"\r\n        [variant]=\"buttonVariant\"\r\n        [appearance]=\"buttonAppearance\"\r\n        color=\"none\"\r\n        [disabled]=\"!canIncrement()\"\r\n        [tabIndex]=\"!canIncrement() ? -1 : tabIndex\"\r\n        (click)=\"onQuickChangeButtonClick(1, $event)\"\r\n        (ardHold)=\"onQuickChangeButtonClick(1)\"\r\n        ardHoldSpaceKey\r\n    >+</ard-button>\r\n</div>", styles: [".ard-number-input{display:flex;max-width:100%}.ard-number-input .ard-input-container{position:relative}.ard-number-input .ard-placeholder{position:absolute;left:0;right:0;pointer-events:none}.ard-text-align-left input,.ard-text-align-left .ard-placeholder{text-align:left}.ard-text-align-middle input,.ard-text-align-middle .ard-placeholder{text-align:center}.ard-text-align-right input,.ard-text-align-right .ard-placeholder{text-align:right}.ard-quick-change-button{-webkit-user-select:none;user-select:none;height:100%}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i2.HoldDirective, selector: "[ardHold]", inputs: ["disabled", "readonly", "ardHoldDelay", "ardHoldRepeat", "ardHoldSpaceKey", "ardHoldEnterKey"], outputs: ["ardHold"] }, { kind: "component", type: i3.ArdiumButtonComponent, selector: "ard-button", inputs: ["variant", "alignIcon", "vertical", "icon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumNumberInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ard-number-input', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => ArdiumNumberInputComponent),
+                            multi: true,
+                        },
+                    ], template: "<div class=\"ard-number-input\"\r\n    [ngClass]=\"ngClasses\"\r\n    [class.ard-has-value]=\"value\"\r\n    (mousedown)=\"$event.preventDefault()\"\r\n    (mouseup)=\"onMouseup($event)\"\r\n>\r\n    <ard-button *ngIf=\"allowQuickChange\"\r\n        class=\"ard-quick-change-button decrement\"\r\n        [variant]=\"buttonVariant\"\r\n        [appearance]=\"buttonAppearance\"\r\n        color=\"none\"\r\n        [disabled]=\"!canDecrement()\"\r\n        [tabIndex]=\"!canDecrement() ? -1 : tabIndex\"\r\n        (click)=\"onQuickChangeButtonClick(-1, $event)\"\r\n        (ardHold)=\"onQuickChangeButtonClick(-1)\"\r\n        ardHoldSpaceKey\r\n    >-</ard-button>\r\n    <div class=\"ard-input-container\">\r\n        <ng-container *ngIf=\"shouldDisplayPlaceholder\">\r\n            <ng-template #defaultPlaceholderTemplate>\r\n                <div class=\"ard-placeholder\">{{ placeholder }}</div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"placeholderTemplate || defaultPlaceholderTemplate\"></ng-template>\r\n        </ng-container>\r\n\r\n        <input #textInput\r\n            #focusableElement\r\n            type=\"text\"\r\n            [attr.id]=\"inputId\"\r\n            [attr.tabindex]=\"tabIndex\"\r\n            [readonly]=\"readonly\"\r\n            [disabled]=\"disabled\"\r\n            (input)=\"onInput(textInput.value)\"\r\n            (focus)=\"onFocusMaster($event)\"\r\n            (blur)=\"onBlurMaster($event)\"\r\n            (change)=\"onChange($event)\"\r\n            (mousedown)=\"$event.stopPropagation()\"\r\n            (mouseup)=\"$event.stopPropagation()\"\r\n            (copy)=\"onCopy($event)\"\r\n        >\r\n    </div>\r\n    <ard-button *ngIf=\"allowQuickChange\"\r\n        class=\"ard-quick-change-button increment\"\r\n        [variant]=\"buttonVariant\"\r\n        [appearance]=\"buttonAppearance\"\r\n        color=\"none\"\r\n        [disabled]=\"!canIncrement()\"\r\n        [tabIndex]=\"!canIncrement() ? -1 : tabIndex\"\r\n        (click)=\"onQuickChangeButtonClick(1, $event)\"\r\n        (ardHold)=\"onQuickChangeButtonClick(1)\"\r\n        ardHoldSpaceKey\r\n    >+</ard-button>\r\n</div>", styles: [".ard-number-input{display:flex;max-width:100%}.ard-number-input .ard-input-container{position:relative}.ard-number-input .ard-placeholder{position:absolute;left:0;right:0;pointer-events:none}.ard-text-align-left input,.ard-text-align-left .ard-placeholder{text-align:left}.ard-text-align-middle input,.ard-text-align-middle .ard-placeholder{text-align:center}.ard-text-align-right input,.ard-text-align-right .ard-placeholder{text-align:right}.ard-quick-change-button{-webkit-user-select:none;user-select:none;height:100%}\n"] }]
+        }], propDecorators: { textInputEl: [{
+                type: ViewChild,
+                args: ['textInput', { static: true }]
+            }], inputId: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], placeholderTemplate: [{
+                type: ContentChild,
+                args: [ArdNumberInputPlaceholderTemplateDirective, {
+                        read: TemplateRef,
+                    }]
+            }], appearance: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], alignText: [{
+                type: Input
+            }], compact: [{
+                type: Input
+            }], inputAttrs: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], inputEvent: [{
+                type: Output,
+                args: ['input']
+            }], changeEvent: [{
+                type: Output,
+                args: ['change']
+            }], clearEvent: [{
+                type: Output,
+                args: ['clear']
+            }], quickChangeEvent: [{
+                type: Output,
+                args: ['quickChange']
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], allowFloat: [{
+                type: Input
+            }], allowQuickChange: [{
+                type: Input
+            }], stepSize: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"number-input.component.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/inputs/number-input/number-input.component.ts","../../../../../../projects/ui/src/lib/inputs/number-input/number-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectionStrategy,\n    Component,\n    ElementRef,\n    EventEmitter,\n    forwardRef,\n    Input,\n    OnInit,\n    Output,\n    ViewChild,\n    ViewEncapsulation,\n    ContentChild,\n    TemplateRef,\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { coerceBooleanProperty, coerceNumberProperty } from '@ardium-ui/devkit';\nimport { ButtonVariant, ButtonAppearance } from '../../buttons/general-button.types';\nimport { OneAxisAlignment } from '../../types/alignment.types';\nimport { FormElementAppearance, FormElementVariant } from '../../types/theming.types';\nimport { _NgModelComponentBase } from '../../_internal/ngmodel-component';\nimport { NumberInputModel, NumberInputModelHost } from '../input-utils';\nimport { isDefined, isFloat } from 'simple-bool';\nimport { ArdNumberInputPlaceholderTemplateDirective } from './number-input.directives';\nimport { roundToPrecision } from 'more-rounding';\n\n@Component({\n    selector: 'ard-number-input',\n    templateUrl: './number-input.component.html',\n    styleUrls: ['./number-input.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => ArdiumNumberInputComponent),\n            multi: true,\n        },\n    ],\n})\nexport class ArdiumNumberInputComponent extends _NgModelComponentBase implements ControlValueAccessor, NumberInputModelHost, OnInit {\n    //! input view\n    @ViewChild('textInput', { static: true })\n    textInputEl!: ElementRef<HTMLInputElement>;\n    protected inputModel!: NumberInputModel;\n    ngOnInit(): void {\n        this.inputModel = new NumberInputModel(this.textInputEl.nativeElement, this);\n        this._setInputAttributes();\n        //set the value\n        if (this._valueBeforeInit) {\n            this.writeValue(this._valueBeforeInit);\n            delete this._valueBeforeInit;\n        }\n    }\n\n    @Input() inputId?: string;\n\n    //! placeholder\n    @Input() placeholder: string = '';\n\n    @ContentChild(ArdNumberInputPlaceholderTemplateDirective, {\n        read: TemplateRef,\n    })\n    placeholderTemplate?: TemplateRef<any>;\n\n    get shouldDisplayPlaceholder(): boolean {\n        return Boolean(this.placeholder) && !this.inputModel.stringValue;\n    }\n\n    //! appearance\n    @Input() appearance: FormElementAppearance = FormElementAppearance.Outlined;\n    @Input() variant: FormElementVariant = FormElementVariant.Rounded;\n    @Input() alignText: OneAxisAlignment = OneAxisAlignment.Middle;\n\n    private _compact: boolean = false;\n    @Input()\n    get compact(): boolean {\n        return this._compact;\n    }\n    set compact(v: any) {\n        this._compact = coerceBooleanProperty(v);\n    }\n\n    get ngClasses(): string {\n        return [\n            `ard-appearance-${this.appearance}`,\n            `ard-variant-${this.variant}`,\n            `ard-text-align-${this.alignText}`,\n            `ard-quick-change-${this.allowQuickChange}`,\n            this.compact ? 'ard-compact' : '',\n        ].join(' ');\n    }\n\n    get buttonVariant(): ButtonVariant {\n        if (this.variant == FormElementVariant.Rounded) return ButtonVariant.Rounded;\n        if (this.variant == FormElementVariant.Pill) return ButtonVariant.Pill;\n        if (this.variant == FormElementVariant.Sharp) return ButtonVariant.Sharp;\n        return ButtonVariant.Rounded;\n    }\n    get buttonAppearance(): ButtonAppearance {\n        if (this.appearance == FormElementAppearance.Outlined && this.variant != FormElementVariant.Pill) return ButtonAppearance.Outlined;\n        return ButtonAppearance.Transparent;\n    }\n\n    //! other inputs\n    @Input() inputAttrs: { [key: string]: any } = {};\n\n    //! control value accessor's write value implementation\n    writeValue(v: any) {\n        this.inputModel.writeValue(v);\n    }\n\n    //! value two-way binding\n    protected _valueBeforeInit?: string | null = '0';\n    @Input()\n    set value(v: string | number | null) {\n        if (typeof v == 'number') v = v.toString();\n        if (!this.inputModel) {\n            this._valueBeforeInit = v;\n            return;\n        }\n        this.writeValue(v);\n    }\n    @Output() valueChange = new EventEmitter<number | null>();\n\n    //* event emitters\n    @Output('input') inputEvent = new EventEmitter<number | null>();\n    @Output('change') changeEvent = new EventEmitter<number | null>();\n    @Output('clear') clearEvent = new EventEmitter<MouseEvent>();\n    @Output('quickChange') quickChangeEvent = new EventEmitter<{\n        direction: 1 | -1;\n        value: number;\n    }>();\n\n    //! min/max and number type\n    private _min: number = 0;\n    @Input()\n    get min(): number {\n        return this._min;\n    }\n    set min(v: any) {\n        this._min = coerceNumberProperty(v);\n    }\n\n    private _max: number = 999;\n    @Input()\n    get max(): number {\n        return this._max;\n    }\n    set max(v: any) {\n        this._max = coerceNumberProperty(v);\n    }\n\n    private _allowFloat?: boolean = undefined;\n    @Input()\n    get allowFloat(): boolean {\n        return this._allowFloat ?? isFloat(this._stepSize);\n    }\n    set allowFloat(v: any) {\n        this._allowFloat = coerceBooleanProperty(v);\n    }\n\n    //! incerement/decrement buttons\n    private _allowQuickChange: boolean = true;\n    @Input()\n    get allowQuickChange(): boolean {\n        return this._allowQuickChange;\n    }\n    set allowQuickChange(v: any) {\n        this._allowQuickChange = coerceBooleanProperty(v);\n    }\n\n    private _stepSize: number = 1;\n    @Input()\n    get stepSize(): number {\n        return this._stepSize;\n    }\n    set stepSize(v: any) {\n        this._stepSize = coerceNumberProperty(v);\n    }\n\n    onQuickChangeButtonClick(direction: 1 | -1, event?: MouseEvent): void {\n        let num = this.inputModel.numberValue;\n        if (!num) num = 0;\n\n        if (direction == 1 && num >= this.max) return;\n        if (direction == -1 && num <= this.min) return;\n\n        if (event) event.stopPropagation();\n\n        const newValue = num + this.stepSize * direction;\n        //round to 9 decimal places to avoid floating point arithmetic errors\n        //9 is an arbitrary number that just works well. ¯\\_(ツ)_/¯\n        const newValuePrecise = roundToPrecision(newValue, 9);\n\n        this.writeValue(newValuePrecise);\n        this.quickChangeEvent.next({ direction, value: newValuePrecise });\n        this._emitChange();\n\n        this._checkButtonAvailability();\n    }\n    private _checkButtonAvailability(): void {\n        if (!this.canDecrement() || !this.canIncrement()) this.focus();\n    }\n\n    canIncrement(): boolean {\n        const num = this.inputModel.numberValue;\n        return !isDefined(num) || num < this.max;\n    }\n    canDecrement(): boolean {\n        const num = this.inputModel.numberValue;\n        return !isDefined(num) || num > this.min;\n    }\n\n    //! event handlers\n    onInput(newVal: string): void {\n        let valueHasChanged = this.inputModel.writeValue(newVal);\n        if (!valueHasChanged) return;\n        this._emitInput();\n    }\n    protected _emitInput(): void {\n        this.inputEvent.emit(this.inputModel.numberValue);\n        this._emitChange();\n    }\n\n    //focus, blur, change\n    onFocusMaster(event: FocusEvent): void {\n        this.onFocus(event);\n    }\n    onBlurMaster(event: FocusEvent): void {\n        this.onBlur(event);\n    }\n    //change\n    onChange(event: Event): void {\n        event.stopPropagation();\n        this._emitChange();\n    }\n    protected _emitChange(): void {\n        const v = this.inputModel.numberValue;\n        this._onChangeRegistered?.(v);\n        this.changeEvent.emit(v);\n        this.valueChange.emit(this.inputModel.numberValue);\n    }\n\n    //smart focus\n    onMouseup(event: MouseEvent): void {\n        const selection = window.getSelection();\n        if (selection && selection.type === 'Range') return;\n\n        this.focus();\n    }\n\n    // copy\n    onCopy(event: ClipboardEvent): void {\n        if (\n            this.value &&\n            //does the selection cover the entire input\n            ((this.textInputEl.nativeElement.selectionStart == 0 &&\n                this.textInputEl.nativeElement.selectionEnd == this.textInputEl.nativeElement.value.length) ||\n                //or is zero-wide\n                this.textInputEl.nativeElement.selectionStart == this.textInputEl.nativeElement.selectionEnd)\n        ) {\n            event.clipboardData?.setData('text/plain', String(this.value));\n            event.preventDefault();\n        }\n    }\n\n    //! helpers\n    protected _setInputAttributes() {\n        const input = this.textInputEl.nativeElement;\n        const attributes: { [key: string]: string } = {\n            type: 'text',\n            autocorrect: 'off',\n            autocapitalize: 'off',\n            autocomplete: 'off',\n            tabindex: String(this.tabIndex),\n            ...this.inputAttrs,\n        };\n\n        for (const key of Object.keys(attributes)) {\n            input.setAttribute(key, String(attributes[key]));\n        }\n    }\n}\n","<div class=\"ard-number-input\"\r\n    [ngClass]=\"ngClasses\"\r\n    [class.ard-has-value]=\"value\"\r\n    (mousedown)=\"$event.preventDefault()\"\r\n    (mouseup)=\"onMouseup($event)\"\r\n>\r\n    <ard-button *ngIf=\"allowQuickChange\"\r\n        class=\"ard-quick-change-button decrement\"\r\n        [variant]=\"buttonVariant\"\r\n        [appearance]=\"buttonAppearance\"\r\n        color=\"none\"\r\n        [disabled]=\"!canDecrement()\"\r\n        [tabIndex]=\"!canDecrement() ? -1 : tabIndex\"\r\n        (click)=\"onQuickChangeButtonClick(-1, $event)\"\r\n        (ardHold)=\"onQuickChangeButtonClick(-1)\"\r\n        ardHoldSpaceKey\r\n    >-</ard-button>\r\n    <div class=\"ard-input-container\">\r\n        <ng-container *ngIf=\"shouldDisplayPlaceholder\">\r\n            <ng-template #defaultPlaceholderTemplate>\r\n                <div class=\"ard-placeholder\">{{ placeholder }}</div>\r\n            </ng-template>\r\n\r\n            <ng-template [ngTemplateOutlet]=\"placeholderTemplate || defaultPlaceholderTemplate\"></ng-template>\r\n        </ng-container>\r\n\r\n        <input #textInput\r\n            #focusableElement\r\n            type=\"text\"\r\n            [attr.id]=\"inputId\"\r\n            [attr.tabindex]=\"tabIndex\"\r\n            [readonly]=\"readonly\"\r\n            [disabled]=\"disabled\"\r\n            (input)=\"onInput(textInput.value)\"\r\n            (focus)=\"onFocusMaster($event)\"\r\n            (blur)=\"onBlurMaster($event)\"\r\n            (change)=\"onChange($event)\"\r\n            (mousedown)=\"$event.stopPropagation()\"\r\n            (mouseup)=\"$event.stopPropagation()\"\r\n            (copy)=\"onCopy($event)\"\r\n        >\r\n    </div>\r\n    <ard-button *ngIf=\"allowQuickChange\"\r\n        class=\"ard-quick-change-button increment\"\r\n        [variant]=\"buttonVariant\"\r\n        [appearance]=\"buttonAppearance\"\r\n        color=\"none\"\r\n        [disabled]=\"!canIncrement()\"\r\n        [tabIndex]=\"!canIncrement() ? -1 : tabIndex\"\r\n        (click)=\"onQuickChangeButtonClick(1, $event)\"\r\n        (ardHold)=\"onQuickChangeButtonClick(1)\"\r\n        ardHoldSpaceKey\r\n    >+</ard-button>\r\n</div>"]}

package/esm2022/lib/inputs/number-input/number-input.directives.mjs

@@ -0,0 +1,14 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ArdNumberInputPlaceholderTemplateDirective {
+    constructor(template) {
+        this.template = template;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdNumberInputPlaceholderTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.7", type: ArdNumberInputPlaceholderTemplateDirective, selector: "ard-number-input > ng-template[ard-placeholder-tmp]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdNumberInputPlaceholderTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: 'ard-number-input > ng-template[ard-placeholder-tmp]' }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVtYmVyLWlucHV0LmRpcmVjdGl2ZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2lucHV0cy9udW1iZXItaW5wdXQvbnVtYmVyLWlucHV0LmRpcmVjdGl2ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBZSxNQUFNLGVBQWUsQ0FBQzs7QUFHdkQsTUFBTSxPQUFPLDBDQUEwQztJQUNuRCxZQUFtQixRQUFnQztRQUFoQyxhQUFRLEdBQVIsUUFBUSxDQUF3QjtJQUFHLENBQUM7OEdBRDlDLDBDQUEwQztrR0FBMUMsMENBQTBDOzsyRkFBMUMsMENBQTBDO2tCQUR0RCxTQUFTO21CQUFDLEVBQUUsUUFBUSxFQUFFLHFEQUFxRCxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHsgc2VsZWN0b3I6ICdhcmQtbnVtYmVyLWlucHV0ID4gbmctdGVtcGxhdGVbYXJkLXBsYWNlaG9sZGVyLXRtcF0nIH0pXG5leHBvcnQgY2xhc3MgQXJkTnVtYmVySW5wdXRQbGFjZWhvbGRlclRlbXBsYXRlRGlyZWN0aXZlIHtcbiAgICBjb25zdHJ1Y3RvcihwdWJsaWMgdGVtcGxhdGU6IFRlbXBsYXRlUmVmPHVuZGVmaW5lZD4pIHt9XG59XG4iXX0=

package/esm2022/lib/inputs/number-input/number-input.module.mjs

@@ -0,0 +1,21 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ArdiumHoldEventModule } from '@ardium-ui/devkit';
+import { ArdiumButtonModule } from '../../buttons/button/button.module';
+import { ArdiumNumberInputComponent } from './number-input.component';
+import { ArdNumberInputPlaceholderTemplateDirective } from './number-input.directives';
+import * as i0 from "@angular/core";
+export class ArdiumNumberInputModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumNumberInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.7", ngImport: i0, type: ArdiumNumberInputModule, declarations: [ArdiumNumberInputComponent, ArdNumberInputPlaceholderTemplateDirective], imports: [CommonModule, ArdiumHoldEventModule, ArdiumButtonModule], exports: [ArdiumNumberInputComponent, ArdNumberInputPlaceholderTemplateDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumNumberInputModule, imports: [CommonModule, ArdiumHoldEventModule, ArdiumButtonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumNumberInputModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ArdiumNumberInputComponent, ArdNumberInputPlaceholderTemplateDirective],
+                    imports: [CommonModule, ArdiumHoldEventModule, ArdiumButtonModule],
+                    exports: [ArdiumNumberInputComponent, ArdNumberInputPlaceholderTemplateDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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