@wemake4u/form-player-se 1.0.5 → 1.0.7

package/esm2022/lib/directives/text.directive.mjs

@@ -0,0 +1,100 @@
+import { Directive, Host, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-sirio-lib";
+export class TextDirective {
+    sirioInput;
+    renderer;
+    textcase = '';
+    maxlength = null;
+    constructor(sirioInput, renderer) {
+        this.sirioInput = sirioInput;
+        this.renderer = renderer;
+        const registerOnChange = this.sirioInput.registerOnChange.bind(this.sirioInput);
+        const coerceValue = this.coerceValue.bind(this);
+        this.sirioInput.registerOnChange = function (fn) {
+            registerOnChange(function (value) {
+                fn(coerceValue(value));
+            });
+        };
+    }
+    ngAfterViewInit() {
+        this.configureTextCase();
+        this.configureMaxLength();
+    }
+    ngOnChanges(changes) {
+        if (changes["maxlength"]) {
+            this.configureMaxLength();
+        }
+    }
+    coerceValue(value) {
+        return this.applyMaxLength(this.applyCase(value));
+    }
+    applyCase(value) {
+        if (this.textcase === "uppercase") {
+            return value.toUpperCase();
+        }
+        else if (this.textcase === "lowercase") {
+            return value.toLowerCase();
+        }
+        else {
+            return value;
+        }
+    }
+    applyMaxLength(value) {
+        if (this.maxlength != null && value.length > this.maxlength) {
+            return value.slice(0, Math.max(0, this.maxlength));
+        }
+        else {
+            return value;
+        }
+    }
+    configureTextCase() {
+        const inputElement = this.sirioInput.sirioInput?.nativeElement;
+        if (inputElement && (this.textcase === 'uppercase' || this.textcase === 'lowercase')) {
+            this.renderer.setStyle(inputElement, 'text-transform', this.textcase);
+            inputElement.oninput = (event) => {
+                const input = event.target;
+                const value = input.value;
+                var newValue = this.coerceValue(value);
+                if (newValue != value) {
+                    this.replaceInputValue(input, newValue);
+                }
+            };
+        }
+    }
+    configureMaxLength() {
+        const inputElement = this.sirioInput.sirioInput?.nativeElement;
+        if (inputElement) {
+            if (this.maxlength == null) {
+                inputElement.removeAttribute('maxlength');
+            }
+            else {
+                inputElement.maxLength = this.maxlength;
+            }
+        }
+    }
+    replaceInputValue(input, value) {
+        const start = input.selectionStart || 0;
+        const end = input.selectionEnd || 0;
+        input.value = value;
+        setTimeout(() => {
+            input.setSelectionRange(start, end);
+        }, 0);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TextDirective, deps: [{ token: i1.SirioInputComponent, host: true }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TextDirective, isStandalone: true, selector: "[textcase], [maxlength]", inputs: { textcase: "textcase", maxlength: "maxlength" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TextDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[textcase], [maxlength]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.SirioInputComponent, decorators: [{
+                    type: Host
+                }] }, { type: i0.Renderer2 }], propDecorators: { textcase: [{
+                type: Input
+            }], maxlength: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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