@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16342534841

package/esm2022/lib/form/components/widgets/number/number.widget.mjs

@@ -0,0 +1,71 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable @angular-eslint/component-selector, @angular-eslint/no-input-rename */
+import { NgIf } from '@angular/common';
+import { Component, ViewEncapsulation } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { TranslatePipe } from '@ngx-translate/core';
+import { DecimalNumberPipe } from '../../../../pipes';
+import { FormService } from '../../../services/form.service';
+import { ErrorWidgetComponent } from '../error/error.component';
+import { WidgetComponent } from '../widget.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/form.service";
+import * as i2 from "../../../../pipes";
+import * as i3 from "@angular/material/form-field";
+import * as i4 from "@angular/material/input";
+import * as i5 from "@angular/forms";
+export class NumberWidgetComponent extends WidgetComponent {
+    constructor(formService, decimalNumberPipe) {
+        super(formService);
+        this.formService = formService;
+        this.decimalNumberPipe = decimalNumberPipe;
+    }
+    ngOnInit() {
+        if (this.field.readOnly) {
+            this.displayValue = this.decimalNumberPipe.transform(this.field.value);
+        }
+        else {
+            this.displayValue = this.field.value;
+        }
+    }
+    onNumberChange(value) {
+        if (value === null || value === undefined || value === '') {
+            this.field.value = null;
+        }
+        this.onFieldChanged(this.field);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NumberWidgetComponent, deps: [{ token: i1.FormService }, { token: i2.DecimalNumberPipe }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: NumberWidgetComponent, isStandalone: true, selector: "number-widget", host: { listeners: { "click": "event($event)", "blur": "event($event)", "change": "event($event)", "focus": "event($event)", "focusin": "event($event)", "focusout": "event($event)", "input": "event($event)", "invalid": "event($event)", "select": "event($event)" } }, providers: [DecimalNumberPipe], usesInheritance: true, ngImport: i0, template: "<div class=\"adf-textfield adf-number-widget {{ field.className }}\"\n     [class.adf-invalid]=\"!field.isValid && isTouched()\"\n     [class.adf-readonly]=\"field.readOnly\"\n     [class.adf-left-label-input-container]=\"field.leftLabels\">\n    <div *ngIf=\"field.leftLabels\">\n        <label class=\"adf-label adf-left-label\"\n               [attr.for]=\"field.id\">\n            {{ field.name | translate }}<span class=\"adf-asterisk\" [style.visibility]=\"isRequired() ? 'visible' : 'hidden'\">*</span>\n        </label>\n    </div>\n    <div class=\"adf-number-widget-container\">\n        <mat-form-field class=\"adf-form-field-input\" [floatLabel]=\"field.placeholder ? 'always' : null\">\n            @if( (field.name || this.field?.required) && !field.leftLabels) {\n            <mat-label class=\"adf-label\" [attr.for]=\"field.id\">\n                {{ field.name | translate }}\n            </mat-label>\n            }\n            <input matInput\n                   class=\"adf-input\"\n                   type=\"text\"\n                   pattern=\"-?[0-9]*(\\.[0-9]+)?\"\n                   [id]=\"field.id\"\n                   [required]=\"field.required\"\n                   [value]=\"displayValue\"\n                   [(ngModel)]=\"field.value\"\n                   (ngModelChange)=\"onNumberChange($event)\"\n                   [disabled]=\"field.readOnly\"\n                   [placeholder]=\"field.placeholder\"\n                   [title]=\"field.tooltip\"\n                   (blur)=\"markAsTouched()\">\n        </mat-form-field>\n        <div class=\"adf-error-messages-container\">\n            <error-widget [error]=\"field.validationSummary\" />\n            <error-widget\n                *ngIf=\"isInvalidFieldRequired() && isTouched()\"\n                required=\"{{ 'FORM.FIELD.REQUIRED' | translate }}\"\n            />\n        </div>\n    </div>\n</div>\n", styles: [".adf-number-widget{width:100%}.adf-number-widget-container{display:flex;align-items:flex-start;flex-direction:column}.adf-number-widget .adf-label{top:20px}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i4.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i5.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i5.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i5.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i5.PatternValidator, selector: "[pattern][formControlName],[pattern][formControl],[pattern][ngModel]", inputs: ["pattern"] }, { kind: "directive", type: i5.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: ErrorWidgetComponent, selector: "error-widget", inputs: ["error", "required"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: NumberWidgetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'number-widget', standalone: true, host: {
+                        '(click)': 'event($event)',
+                        '(blur)': 'event($event)',
+                        '(change)': 'event($event)',
+                        '(focus)': 'event($event)',
+                        '(focusin)': 'event($event)',
+                        '(focusout)': 'event($event)',
+                        '(input)': 'event($event)',
+                        '(invalid)': 'event($event)',
+                        '(select)': 'event($event)'
+                    }, imports: [NgIf, TranslatePipe, MatFormFieldModule, MatInputModule, FormsModule, ErrorWidgetComponent], providers: [DecimalNumberPipe], encapsulation: ViewEncapsulation.None, template: "<div class=\"adf-textfield adf-number-widget {{ field.className }}\"\n     [class.adf-invalid]=\"!field.isValid && isTouched()\"\n     [class.adf-readonly]=\"field.readOnly\"\n     [class.adf-left-label-input-container]=\"field.leftLabels\">\n    <div *ngIf=\"field.leftLabels\">\n        <label class=\"adf-label adf-left-label\"\n               [attr.for]=\"field.id\">\n            {{ field.name | translate }}<span class=\"adf-asterisk\" [style.visibility]=\"isRequired() ? 'visible' : 'hidden'\">*</span>\n        </label>\n    </div>\n    <div class=\"adf-number-widget-container\">\n        <mat-form-field class=\"adf-form-field-input\" [floatLabel]=\"field.placeholder ? 'always' : null\">\n            @if( (field.name || this.field?.required) && !field.leftLabels) {\n            <mat-label class=\"adf-label\" [attr.for]=\"field.id\">\n                {{ field.name | translate }}\n            </mat-label>\n            }\n            <input matInput\n                   class=\"adf-input\"\n                   type=\"text\"\n                   pattern=\"-?[0-9]*(\\.[0-9]+)?\"\n                   [id]=\"field.id\"\n                   [required]=\"field.required\"\n                   [value]=\"displayValue\"\n                   [(ngModel)]=\"field.value\"\n                   (ngModelChange)=\"onNumberChange($event)\"\n                   [disabled]=\"field.readOnly\"\n                   [placeholder]=\"field.placeholder\"\n                   [title]=\"field.tooltip\"\n                   (blur)=\"markAsTouched()\">\n        </mat-form-field>\n        <div class=\"adf-error-messages-container\">\n            <error-widget [error]=\"field.validationSummary\" />\n            <error-widget\n                *ngIf=\"isInvalidFieldRequired() && isTouched()\"\n                required=\"{{ 'FORM.FIELD.REQUIRED' | translate }}\"\n            />\n        </div>\n    </div>\n</div>\n", styles: [".adf-number-widget{width:100%}.adf-number-widget-container{display:flex;align-items:flex-start;flex-direction:column}.adf-number-widget .adf-label{top:20px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormService }, { type: i2.DecimalNumberPipe }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"number.widget.js","sourceRoot":"","sources":["../../../../../../../../../lib/core/src/lib/form/components/widgets/number/number.widget.ts","../../../../../../../../../lib/core/src/lib/form/components/widgets/number/number.widget.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,wFAAwF;AAExF,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,SAAS,EAAU,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;;;;;;;AAsBtD,MAAM,OAAO,qBAAsB,SAAQ,eAAe;IAGtD,YAAmB,WAAwB,EAAU,iBAAoC;QACrF,KAAK,CAAC,WAAW,CAAC,CAAC;QADJ,gBAAW,GAAX,WAAW,CAAa;QAAU,sBAAiB,GAAjB,iBAAiB,CAAmB;IAEzF,CAAC;IAED,QAAQ;QACJ,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC3E,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;QACzC,CAAC;IACL,CAAC;IAES,cAAc,CAAC,KAAa;QAClC,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE,EAAE,CAAC;YACxD,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;+GArBQ,qBAAqB;mGAArB,qBAAqB,uUAHnB,CAAC,iBAAiB,CAAC,iDC/ClC,42DAwCA,wNDMc,IAAI,wFAAE,aAAa,iDAAE,kBAAkB,0SAAE,cAAc,0WAAE,WAAW,q+BAAE,oBAAoB;;4FAI3F,qBAAqB;kBApBjC,SAAS;+BACI,eAAe,cACb,IAAI,QAGV;wBACF,SAAS,EAAE,eAAe;wBAC1B,QAAQ,EAAE,eAAe;wBACzB,UAAU,EAAE,eAAe;wBAC3B,SAAS,EAAE,eAAe;wBAC1B,WAAW,EAAE,eAAe;wBAC5B,YAAY,EAAE,eAAe;wBAC7B,SAAS,EAAE,eAAe;wBAC1B,WAAW,EAAE,eAAe;wBAC5B,UAAU,EAAE,eAAe;qBAC9B,WACQ,CAAC,IAAI,EAAE,aAAa,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,oBAAoB,CAAC,aAC1F,CAAC,iBAAiB,CAAC,iBACf,iBAAiB,CAAC,IAAI","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable @angular-eslint/component-selector, @angular-eslint/no-input-rename */\n\nimport { NgIf } from '@angular/common';\nimport { Component, OnInit, ViewEncapsulation } from '@angular/core';\nimport { FormsModule } from '@angular/forms';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatInputModule } from '@angular/material/input';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { DecimalNumberPipe } from '../../../../pipes';\nimport { FormService } from '../../../services/form.service';\nimport { ErrorWidgetComponent } from '../error/error.component';\nimport { WidgetComponent } from '../widget.component';\n\n@Component({\n    selector: 'number-widget',\n    standalone: true,\n    templateUrl: './number.widget.html',\n    styleUrls: ['./number.widget.scss'],\n    host: {\n        '(click)': 'event($event)',\n        '(blur)': 'event($event)',\n        '(change)': 'event($event)',\n        '(focus)': 'event($event)',\n        '(focusin)': 'event($event)',\n        '(focusout)': 'event($event)',\n        '(input)': 'event($event)',\n        '(invalid)': 'event($event)',\n        '(select)': 'event($event)'\n    },\n    imports: [NgIf, TranslatePipe, MatFormFieldModule, MatInputModule, FormsModule, ErrorWidgetComponent],\n    providers: [DecimalNumberPipe],\n    encapsulation: ViewEncapsulation.None\n})\nexport class NumberWidgetComponent extends WidgetComponent implements OnInit {\n    displayValue: number;\n\n    constructor(public formService: FormService, private decimalNumberPipe: DecimalNumberPipe) {\n        super(formService);\n    }\n\n    ngOnInit() {\n        if (this.field.readOnly) {\n            this.displayValue = this.decimalNumberPipe.transform(this.field.value);\n        } else {\n            this.displayValue = this.field.value;\n        }\n    }\n\n    protected onNumberChange(value: string) {\n        if (value === null || value === undefined || value === '') {\n            this.field.value = null;\n        }\n\n        this.onFieldChanged(this.field);\n    }\n}\n","<div class=\"adf-textfield adf-number-widget {{ field.className }}\"\n     [class.adf-invalid]=\"!field.isValid && isTouched()\"\n     [class.adf-readonly]=\"field.readOnly\"\n     [class.adf-left-label-input-container]=\"field.leftLabels\">\n    <div *ngIf=\"field.leftLabels\">\n        <label class=\"adf-label adf-left-label\"\n               [attr.for]=\"field.id\">\n            {{ field.name | translate }}<span class=\"adf-asterisk\" [style.visibility]=\"isRequired() ? 'visible' : 'hidden'\">*</span>\n        </label>\n    </div>\n    <div class=\"adf-number-widget-container\">\n        <mat-form-field class=\"adf-form-field-input\" [floatLabel]=\"field.placeholder ? 'always' : null\">\n            @if( (field.name || this.field?.required) && !field.leftLabels) {\n            <mat-label class=\"adf-label\" [attr.for]=\"field.id\">\n                {{ field.name | translate }}\n            </mat-label>\n            }\n            <input matInput\n                   class=\"adf-input\"\n                   type=\"text\"\n                   pattern=\"-?[0-9]*(\\.[0-9]+)?\"\n                   [id]=\"field.id\"\n                   [required]=\"field.required\"\n                   [value]=\"displayValue\"\n                   [(ngModel)]=\"field.value\"\n                   (ngModelChange)=\"onNumberChange($event)\"\n                   [disabled]=\"field.readOnly\"\n                   [placeholder]=\"field.placeholder\"\n                   [title]=\"field.tooltip\"\n                   (blur)=\"markAsTouched()\">\n        </mat-form-field>\n        <div class=\"adf-error-messages-container\">\n            <error-widget [error]=\"field.validationSummary\" />\n            <error-widget\n                *ngIf=\"isInvalidFieldRequired() && isTouched()\"\n                required=\"{{ 'FORM.FIELD.REQUIRED' | translate }}\"\n            />\n        </div>\n    </div>\n</div>\n"]}

package/esm2022/lib/form/components/widgets/reactive-widget.interface.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhY3RpdmUtd2lkZ2V0LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvZm9ybS9jb21wb25lbnRzL3dpZGdldHMvcmVhY3RpdmUtd2lkZ2V0LmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUciLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IEZvcm1TZXJ2aWNlIH0gZnJvbSAnLi4vLi4vc2VydmljZXMvZm9ybS5zZXJ2aWNlJztcblxuZXhwb3J0IGludGVyZmFjZSBSZWFjdGl2ZUZvcm1XaWRnZXQge1xuICAgIHVwZGF0ZVJlYWN0aXZlRm9ybUNvbnRyb2woKTogdm9pZDtcbiAgICBmb3JtU2VydmljZTogRm9ybVNlcnZpY2U7XG59XG4iXX0=

package/esm2022/lib/form/components/widgets/text/text-mask.component.mjs

@@ -0,0 +1,215 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable @angular-eslint/component-selector, @typescript-eslint/no-use-before-define, @angular-eslint/no-input-rename */
+import { Directive, ElementRef, forwardRef, HostListener, Input, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+export const CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => InputMaskDirective),
+    multi: true
+};
+/**
+ * Directive selectors without adf- prefix will be deprecated on 3.0.0
+ */
+export class InputMaskDirective {
+    constructor(el, render) {
+        this.el = el;
+        this.render = render;
+        this.translationMask = {
+            '0': { pattern: /\d/ },
+            '9': { pattern: /\d/, optional: true },
+            '#': { pattern: /\d/, recursive: true },
+            A: { pattern: /[a-zA-Z0-9]/ },
+            S: { pattern: /[a-zA-Z]/ }
+        };
+        this.byPassKeys = [9, 16, 17, 18, 36, 37, 38, 39, 40, 91];
+        this.invalidCharacters = [];
+        this._onChange = (_) => { };
+        this._onTouched = () => { };
+    }
+    onTextInput(event) {
+        if (this.inputMask?.mask) {
+            this.maskValue(this.el.nativeElement.value, this.el.nativeElement.selectionStart, this.inputMask.mask, this.inputMask.isReversed, event.keyCode);
+        }
+        else {
+            this._onChange(this.el.nativeElement.value);
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['inputMask']?.currentValue['mask']) {
+            this.inputMask = changes['inputMask'].currentValue;
+        }
+    }
+    writeValue(value) {
+        this.el.nativeElement.value = value;
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    maskValue(actualValue, startCaret, maskToApply, isMaskReversed, keyCode) {
+        if (this.byPassKeys.indexOf(keyCode) === -1) {
+            const value = this.getMasked(false, actualValue, maskToApply, isMaskReversed);
+            const calculatedCaret = this.calculateCaretPosition(startCaret, actualValue, keyCode);
+            this.render.setAttribute(this.el.nativeElement, 'value', value);
+            this.el.nativeElement.value = value;
+            this.setValue(value);
+            this._onChange(value);
+            this.setCaretPosition(calculatedCaret);
+        }
+    }
+    setCaretPosition(caretPosition) {
+        this.el.nativeElement.moveStart = caretPosition;
+        this.el.nativeElement.moveEnd = caretPosition;
+    }
+    calculateCaretPosition(caretPosition, newValue, keyCode) {
+        const newValueLength = newValue.length;
+        const oldValue = this.getValue() || '';
+        const oldValueLength = oldValue.length;
+        if (keyCode === 8 && oldValue !== newValue) {
+            caretPosition = caretPosition - (newValue.slice(0, caretPosition).length - oldValue.slice(0, caretPosition).length);
+        }
+        else if (oldValue !== newValue) {
+            if (caretPosition >= oldValueLength) {
+                caretPosition = newValueLength;
+            }
+            else {
+                caretPosition = caretPosition + (newValue.slice(0, caretPosition).length - oldValue.slice(0, caretPosition).length);
+            }
+        }
+        return caretPosition;
+    }
+    getMasked(skipMaskChars, val, mask, isReversed = false) {
+        const buf = [];
+        const value = val;
+        let maskIndex = 0;
+        const maskLen = mask.length;
+        let valueIndex = 0;
+        const valueLength = value.length;
+        let offset = 1;
+        let addMethod = 'push';
+        let resetPos = -1;
+        let lastMaskChar;
+        let lastUntranslatedMaskChar;
+        let check;
+        if (isReversed) {
+            addMethod = 'unshift';
+            offset = -1;
+            lastMaskChar = 0;
+            maskIndex = maskLen - 1;
+            valueIndex = valueLength - 1;
+        }
+        else {
+            lastMaskChar = maskLen - 1;
+        }
+        check = this.isToCheck(isReversed, maskIndex, maskLen, valueIndex, valueLength);
+        while (check) {
+            const maskDigit = mask.charAt(maskIndex);
+            const valDigit = value.charAt(valueIndex);
+            const translation = this.translationMask[maskDigit];
+            if (translation) {
+                if (valDigit.match(translation.pattern)) {
+                    buf[addMethod](valDigit);
+                    if (translation.recursive) {
+                        if (resetPos === -1) {
+                            resetPos = maskIndex;
+                        }
+                        else if (maskIndex === lastMaskChar) {
+                            maskIndex = resetPos - offset;
+                        }
+                        if (lastMaskChar === resetPos) {
+                            maskIndex -= offset;
+                        }
+                    }
+                    maskIndex += offset;
+                }
+                else if (valDigit === lastUntranslatedMaskChar) {
+                    lastUntranslatedMaskChar = undefined;
+                }
+                else if (translation.optional) {
+                    maskIndex += offset;
+                    valueIndex -= offset;
+                }
+                else {
+                    this.invalidCharacters.push({
+                        index: valueIndex,
+                        digit: valDigit,
+                        translated: translation.pattern
+                    });
+                }
+                valueIndex += offset;
+            }
+            else {
+                if (!skipMaskChars) {
+                    buf[addMethod](maskDigit);
+                }
+                if (valDigit === maskDigit) {
+                    valueIndex += offset;
+                }
+                else {
+                    lastUntranslatedMaskChar = maskDigit;
+                }
+                maskIndex += offset;
+            }
+            check = this.isToCheck(isReversed, maskIndex, maskLen, valueIndex, valueLength);
+        }
+        const lastMaskCharDigit = mask.charAt(lastMaskChar);
+        if (maskLen === valueLength + 1 && !this.translationMask[lastMaskCharDigit]) {
+            buf.push(lastMaskCharDigit);
+        }
+        return buf.join('');
+    }
+    isToCheck(isReversed, maskIndex, maskLen, valueIndex, valueLength) {
+        let check = false;
+        if (isReversed) {
+            check = maskIndex > -1 && valueIndex > -1;
+        }
+        else {
+            check = maskIndex < maskLen && valueIndex < valueLength;
+        }
+        return check;
+    }
+    setValue(value) {
+        this.value = value;
+    }
+    getValue() {
+        return this.value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: InputMaskDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: InputMaskDirective, isStandalone: true, selector: "[adf-text-mask], [textMask]", inputs: { inputMask: ["textMask", "inputMask"] }, host: { listeners: { "input": "onTextInput($event)", "keyup": "onTextInput($event)" } }, providers: [CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: InputMaskDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[adf-text-mask], [textMask]',
+                    standalone: true,
+                    providers: [CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR]
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { inputMask: [{
+                type: Input,
+                args: ['textMask']
+            }], onTextInput: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['keyup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text-mask.component.js","sourceRoot":"","sources":["../../../../../../../../../lib/core/src/lib/form/components/widgets/text/text-mask.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable @angular-eslint/component-selector, @typescript-eslint/no-use-before-define, @angular-eslint/no-input-rename */\n\nimport { Directive, ElementRef, forwardRef, HostListener, Input, OnChanges, Renderer2, SimpleChanges } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nexport const CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR: any = {\n    provide: NG_VALUE_ACCESSOR,\n    useExisting: forwardRef(() => InputMaskDirective),\n    multi: true\n};\n\n/**\n * Directive selectors without adf- prefix will be deprecated on 3.0.0\n */\n@Directive({\n    selector: '[adf-text-mask], [textMask]',\n    standalone: true,\n    providers: [CUSTOM_INPUT_CONTROL_VALUE_ACCESSOR]\n})\nexport class InputMaskDirective implements OnChanges, ControlValueAccessor {\n    /** Object defining mask and \"reversed\" status. */\n    @Input('textMask') inputMask: {\n        mask: string;\n        isReversed: boolean;\n    };\n\n    private translationMask = {\n        '0': { pattern: /\\d/ },\n        '9': { pattern: /\\d/, optional: true },\n        '#': { pattern: /\\d/, recursive: true },\n        A: { pattern: /[a-zA-Z0-9]/ },\n        S: { pattern: /[a-zA-Z]/ }\n    };\n\n    private byPassKeys = [9, 16, 17, 18, 36, 37, 38, 39, 40, 91];\n    private value;\n    private invalidCharacters = [];\n\n    constructor(private el: ElementRef, private render: Renderer2) {}\n\n    _onChange = (_: any) => {};\n\n    _onTouched = () => {};\n\n    @HostListener('input', ['$event'])\n    @HostListener('keyup', ['$event'])\n    onTextInput(event: KeyboardEvent) {\n        if (this.inputMask?.mask) {\n            this.maskValue(\n                this.el.nativeElement.value,\n                this.el.nativeElement.selectionStart,\n                this.inputMask.mask,\n                this.inputMask.isReversed,\n                event.keyCode\n            );\n        } else {\n            this._onChange(this.el.nativeElement.value);\n        }\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['inputMask']?.currentValue['mask']) {\n            this.inputMask = changes['inputMask'].currentValue;\n        }\n    }\n\n    writeValue(value: any) {\n        this.el.nativeElement.value = value;\n    }\n\n    registerOnChange(fn: any) {\n        this._onChange = fn;\n    }\n\n    registerOnTouched(fn: () => any): void {\n        this._onTouched = fn;\n    }\n\n    private maskValue(actualValue: string, startCaret: number, maskToApply: string, isMaskReversed: boolean, keyCode: number) {\n        if (this.byPassKeys.indexOf(keyCode) === -1) {\n            const value = this.getMasked(false, actualValue, maskToApply, isMaskReversed);\n            const calculatedCaret = this.calculateCaretPosition(startCaret, actualValue, keyCode);\n            this.render.setAttribute(this.el.nativeElement, 'value', value);\n            this.el.nativeElement.value = value;\n            this.setValue(value);\n            this._onChange(value);\n            this.setCaretPosition(calculatedCaret);\n        }\n    }\n\n    private setCaretPosition(caretPosition: number) {\n        this.el.nativeElement.moveStart = caretPosition;\n        this.el.nativeElement.moveEnd = caretPosition;\n    }\n\n    calculateCaretPosition(caretPosition: number, newValue: string, keyCode: number): number {\n        const newValueLength = newValue.length;\n        const oldValue = this.getValue() || '';\n        const oldValueLength = oldValue.length;\n\n        if (keyCode === 8 && oldValue !== newValue) {\n            caretPosition = caretPosition - (newValue.slice(0, caretPosition).length - oldValue.slice(0, caretPosition).length);\n        } else if (oldValue !== newValue) {\n            if (caretPosition >= oldValueLength) {\n                caretPosition = newValueLength;\n            } else {\n                caretPosition = caretPosition + (newValue.slice(0, caretPosition).length - oldValue.slice(0, caretPosition).length);\n            }\n        }\n        return caretPosition;\n    }\n\n    getMasked(skipMaskChars: boolean, val: string, mask: string, isReversed = false) {\n        const buf = [];\n        const value = val;\n        let maskIndex = 0;\n        const maskLen = mask.length;\n        let valueIndex = 0;\n        const valueLength = value.length;\n        let offset = 1;\n        let addMethod = 'push';\n        let resetPos = -1;\n        let lastMaskChar: number;\n        let lastUntranslatedMaskChar: string;\n        let check: boolean;\n\n        if (isReversed) {\n            addMethod = 'unshift';\n            offset = -1;\n            lastMaskChar = 0;\n            maskIndex = maskLen - 1;\n            valueIndex = valueLength - 1;\n        } else {\n            lastMaskChar = maskLen - 1;\n        }\n        check = this.isToCheck(isReversed, maskIndex, maskLen, valueIndex, valueLength);\n        while (check) {\n            const maskDigit = mask.charAt(maskIndex);\n            const valDigit = value.charAt(valueIndex);\n            const translation = this.translationMask[maskDigit];\n\n            if (translation) {\n                if (valDigit.match(translation.pattern)) {\n                    buf[addMethod](valDigit);\n                    if (translation.recursive) {\n                        if (resetPos === -1) {\n                            resetPos = maskIndex;\n                        } else if (maskIndex === lastMaskChar) {\n                            maskIndex = resetPos - offset;\n                        }\n                        if (lastMaskChar === resetPos) {\n                            maskIndex -= offset;\n                        }\n                    }\n                    maskIndex += offset;\n                } else if (valDigit === lastUntranslatedMaskChar) {\n                    lastUntranslatedMaskChar = undefined;\n                } else if (translation.optional) {\n                    maskIndex += offset;\n                    valueIndex -= offset;\n                } else {\n                    this.invalidCharacters.push({\n                        index: valueIndex,\n                        digit: valDigit,\n                        translated: translation.pattern\n                    });\n                }\n                valueIndex += offset;\n            } else {\n                if (!skipMaskChars) {\n                    buf[addMethod](maskDigit);\n                }\n                if (valDigit === maskDigit) {\n                    valueIndex += offset;\n                } else {\n                    lastUntranslatedMaskChar = maskDigit;\n                }\n                maskIndex += offset;\n            }\n            check = this.isToCheck(isReversed, maskIndex, maskLen, valueIndex, valueLength);\n        }\n\n        const lastMaskCharDigit = mask.charAt(lastMaskChar);\n        if (maskLen === valueLength + 1 && !this.translationMask[lastMaskCharDigit]) {\n            buf.push(lastMaskCharDigit);\n        }\n\n        return buf.join('');\n    }\n\n    private isToCheck(isReversed: boolean, maskIndex: number, maskLen: number, valueIndex: number, valueLength: number): boolean {\n        let check = false;\n        if (isReversed) {\n            check = maskIndex > -1 && valueIndex > -1;\n        } else {\n            check = maskIndex < maskLen && valueIndex < valueLength;\n        }\n        return check;\n    }\n\n    private setValue(value) {\n        this.value = value;\n    }\n\n    private getValue() {\n        return this.value;\n    }\n}\n"]}

package/esm2022/lib/form/components/widgets/text/text.widget.mjs

@@ -0,0 +1,65 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable @angular-eslint/component-selector */
+import { NgIf } from '@angular/common';
+import { Component, ViewEncapsulation } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { TranslatePipe } from '@ngx-translate/core';
+import { FormService } from '../../../services/form.service';
+import { ErrorWidgetComponent } from '../error/error.component';
+import { WidgetComponent } from '../widget.component';
+import { InputMaskDirective } from './text-mask.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/form.service";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/input";
+import * as i4 from "@angular/forms";
+export class TextWidgetComponent extends WidgetComponent {
+    constructor(formService) {
+        super(formService);
+        this.formService = formService;
+    }
+    ngOnInit() {
+        if (this.field.params) {
+            this.mask = this.field.params['inputMask'];
+            this.placeholder =
+                this.field.params['inputMask'] && this.field.params['inputMaskPlaceholder']
+                    ? this.field.params['inputMaskPlaceholder']
+                    : this.field.placeholder;
+            this.isMaskReversed = this.field.params['inputMaskReversed'] ? this.field.params['inputMaskReversed'] : false;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TextWidgetComponent, deps: [{ token: i1.FormService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: TextWidgetComponent, isStandalone: true, selector: "text-widget", host: { listeners: { "click": "event($event)", "blur": "event($event)", "change": "event($event)", "focus": "event($event)", "focusin": "event($event)", "focusout": "event($event)", "input": "event($event)", "invalid": "event($event)", "select": "event($event)" } }, usesInheritance: true, ngImport: i0, template: "<div class=\"adf-textfield adf-text-widget {{ field.className }}\"\n     [class.adf-invalid]=\"!field.isValid && isTouched()\"\n     [class.adf-readonly]=\"field.readOnly\"\n     [class.adf-left-label-input-container]=\"field.leftLabels\">\n    <div *ngIf=\"field.leftLabels\">\n        <label class=\"adf-label adf-left-label\" [attr.for]=\"field.id\">\n            {{ field.name | translate }}<span class=\"adf-asterisk\" [style.visibility]=\"isRequired() ? 'visible' : 'hidden'\">*</span>\n        </label>\n    </div>\n    <div class=\"adf-text-widget-container\">\n        <mat-form-field class=\"adf-form-field-input\" [floatLabel]=\"placeholder ? 'always' : null\">\n            @if ( (field.name || this.field?.required) && !field.leftLabels) { <mat-label class=\"adf-label\" [attr.for]=\"field.id\">\n                {{ field.name | translate }}\n            </mat-label>\n        }\n            <input matInput\n                   class=\"adf-input\"\n                   type=\"text\"\n                   [id]=\"field.id\"\n                   [required]=\"field.required\"\n                   [value]=\"field.value\"\n                   [(ngModel)]=\"field.value\"\n                   (ngModelChange)=\"onFieldChanged(field)\"\n                   [disabled]=\"field.readOnly || readOnly\"\n                   [textMask]=\"{mask: mask, isReversed: isMaskReversed}\"\n                   [placeholder]=\"placeholder\"\n                   [title]=\"field.tooltip\"\n                   (blur)=\"markAsTouched()\">\n        </mat-form-field>\n        <div class=\"adf-error-messages-container\">\n            <error-widget [error]=\"field.validationSummary\" />\n            <error-widget *ngIf=\"isInvalidFieldRequired() && isTouched()\"\n            required=\"{{ 'FORM.FIELD.REQUIRED' | translate }}\" />\n        </div>\n    </div>\n</div>\n", styles: [".adf-text-widget{width:100%}.adf-text-widget .mat-mdc-floating-label{top:20px}.adf-text-widget-container{display:flex;align-items:flex-start;flex-direction:column}\n"], dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i2.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i2.MatLabel, selector: "mat-label" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i3.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: ErrorWidgetComponent, selector: "error-widget", inputs: ["error", "required"] }, { kind: "directive", type: InputMaskDirective, selector: "[adf-text-mask], [textMask]", inputs: ["textMask"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TextWidgetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'text-widget', standalone: true, host: {
+                        '(click)': 'event($event)',
+                        '(blur)': 'event($event)',
+                        '(change)': 'event($event)',
+                        '(focus)': 'event($event)',
+                        '(focusin)': 'event($event)',
+                        '(focusout)': 'event($event)',
+                        '(input)': 'event($event)',
+                        '(invalid)': 'event($event)',
+                        '(select)': 'event($event)'
+                    }, imports: [NgIf, TranslatePipe, MatFormFieldModule, MatInputModule, FormsModule, ErrorWidgetComponent, InputMaskDirective], encapsulation: ViewEncapsulation.None, template: "<div class=\"adf-textfield adf-text-widget {{ field.className }}\"\n     [class.adf-invalid]=\"!field.isValid && isTouched()\"\n     [class.adf-readonly]=\"field.readOnly\"\n     [class.adf-left-label-input-container]=\"field.leftLabels\">\n    <div *ngIf=\"field.leftLabels\">\n        <label class=\"adf-label adf-left-label\" [attr.for]=\"field.id\">\n            {{ field.name | translate }}<span class=\"adf-asterisk\" [style.visibility]=\"isRequired() ? 'visible' : 'hidden'\">*</span>\n        </label>\n    </div>\n    <div class=\"adf-text-widget-container\">\n        <mat-form-field class=\"adf-form-field-input\" [floatLabel]=\"placeholder ? 'always' : null\">\n            @if ( (field.name || this.field?.required) && !field.leftLabels) { <mat-label class=\"adf-label\" [attr.for]=\"field.id\">\n                {{ field.name | translate }}\n            </mat-label>\n        }\n            <input matInput\n                   class=\"adf-input\"\n                   type=\"text\"\n                   [id]=\"field.id\"\n                   [required]=\"field.required\"\n                   [value]=\"field.value\"\n                   [(ngModel)]=\"field.value\"\n                   (ngModelChange)=\"onFieldChanged(field)\"\n                   [disabled]=\"field.readOnly || readOnly\"\n                   [textMask]=\"{mask: mask, isReversed: isMaskReversed}\"\n                   [placeholder]=\"placeholder\"\n                   [title]=\"field.tooltip\"\n                   (blur)=\"markAsTouched()\">\n        </mat-form-field>\n        <div class=\"adf-error-messages-container\">\n            <error-widget [error]=\"field.validationSummary\" />\n            <error-widget *ngIf=\"isInvalidFieldRequired() && isTouched()\"\n            required=\"{{ 'FORM.FIELD.REQUIRED' | translate }}\" />\n        </div>\n    </div>\n</div>\n", styles: [".adf-text-widget{width:100%}.adf-text-widget .mat-mdc-floating-label{top:20px}.adf-text-widget-container{display:flex;align-items:flex-start;flex-direction:column}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"text.widget.js","sourceRoot":"","sources":["../../../../../../../../../lib/core/src/lib/form/components/widgets/text/text.widget.ts","../../../../../../../../../lib/core/src/lib/form/components/widgets/text/text.widget.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,uDAAuD;AAEvD,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,SAAS,EAAU,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;;;;;;AAqB3D,MAAM,OAAO,mBAAoB,SAAQ,eAAe;IAKpD,YAAmB,WAAwB;QACvC,KAAK,CAAC,WAAW,CAAC,CAAC;QADJ,gBAAW,GAAX,WAAW,CAAa;IAE3C,CAAC;IAED,QAAQ;QACJ,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YACpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;YAC3C,IAAI,CAAC,WAAW;gBACZ,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,sBAAsB,CAAC;oBACvE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,sBAAsB,CAAC;oBAC3C,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC;YACjC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QAClH,CAAC;IACL,CAAC;+GAlBQ,mBAAmB;mGAAnB,mBAAmB,yWCjDhC,2zDAoCA,+NDUc,IAAI,wFAAE,aAAa,iDAAE,kBAAkB,0SAAE,cAAc,0WAAE,WAAW,40BAAE,oBAAoB,wFAAE,kBAAkB;;4FAG/G,mBAAmB;kBAnB/B,SAAS;+BACI,aAAa,cACX,IAAI,QAGV;wBACF,SAAS,EAAE,eAAe;wBAC1B,QAAQ,EAAE,eAAe;wBACzB,UAAU,EAAE,eAAe;wBAC3B,SAAS,EAAE,eAAe;wBAC1B,WAAW,EAAE,eAAe;wBAC5B,YAAY,EAAE,eAAe;wBAC7B,SAAS,EAAE,eAAe;wBAC1B,WAAW,EAAE,eAAe;wBAC5B,UAAU,EAAE,eAAe;qBAC9B,WACQ,CAAC,IAAI,EAAE,aAAa,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,oBAAoB,EAAE,kBAAkB,CAAC,iBAC1G,iBAAiB,CAAC,IAAI","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable @angular-eslint/component-selector */\n\nimport { NgIf } from '@angular/common';\nimport { Component, OnInit, ViewEncapsulation } from '@angular/core';\nimport { FormsModule } from '@angular/forms';\nimport { MatFormFieldModule } from '@angular/material/form-field';\nimport { MatInputModule } from '@angular/material/input';\nimport { TranslatePipe } from '@ngx-translate/core';\nimport { FormService } from '../../../services/form.service';\nimport { ErrorWidgetComponent } from '../error/error.component';\nimport { WidgetComponent } from '../widget.component';\nimport { InputMaskDirective } from './text-mask.component';\n\n@Component({\n    selector: 'text-widget',\n    standalone: true,\n    templateUrl: './text.widget.html',\n    styleUrls: ['./text.widget.scss'],\n    host: {\n        '(click)': 'event($event)',\n        '(blur)': 'event($event)',\n        '(change)': 'event($event)',\n        '(focus)': 'event($event)',\n        '(focusin)': 'event($event)',\n        '(focusout)': 'event($event)',\n        '(input)': 'event($event)',\n        '(invalid)': 'event($event)',\n        '(select)': 'event($event)'\n    },\n    imports: [NgIf, TranslatePipe, MatFormFieldModule, MatInputModule, FormsModule, ErrorWidgetComponent, InputMaskDirective],\n    encapsulation: ViewEncapsulation.None\n})\nexport class TextWidgetComponent extends WidgetComponent implements OnInit {\n    mask: string;\n    placeholder: string;\n    isMaskReversed: boolean;\n\n    constructor(public formService: FormService) {\n        super(formService);\n    }\n\n    ngOnInit() {\n        if (this.field.params) {\n            this.mask = this.field.params['inputMask'];\n            this.placeholder =\n                this.field.params['inputMask'] && this.field.params['inputMaskPlaceholder']\n                    ? this.field.params['inputMaskPlaceholder']\n                    : this.field.placeholder;\n            this.isMaskReversed = this.field.params['inputMaskReversed'] ? this.field.params['inputMaskReversed'] : false;\n        }\n    }\n}\n","<div class=\"adf-textfield adf-text-widget {{ field.className }}\"\n     [class.adf-invalid]=\"!field.isValid && isTouched()\"\n     [class.adf-readonly]=\"field.readOnly\"\n     [class.adf-left-label-input-container]=\"field.leftLabels\">\n    <div *ngIf=\"field.leftLabels\">\n        <label class=\"adf-label adf-left-label\" [attr.for]=\"field.id\">\n            {{ field.name | translate }}<span class=\"adf-asterisk\" [style.visibility]=\"isRequired() ? 'visible' : 'hidden'\">*</span>\n        </label>\n    </div>\n    <div class=\"adf-text-widget-container\">\n        <mat-form-field class=\"adf-form-field-input\" [floatLabel]=\"placeholder ? 'always' : null\">\n            @if ( (field.name || this.field?.required) && !field.leftLabels) { <mat-label class=\"adf-label\" [attr.for]=\"field.id\">\n                {{ field.name | translate }}\n            </mat-label>\n        }\n            <input matInput\n                   class=\"adf-input\"\n                   type=\"text\"\n                   [id]=\"field.id\"\n                   [required]=\"field.required\"\n                   [value]=\"field.value\"\n                   [(ngModel)]=\"field.value\"\n                   (ngModelChange)=\"onFieldChanged(field)\"\n                   [disabled]=\"field.readOnly || readOnly\"\n                   [textMask]=\"{mask: mask, isReversed: isMaskReversed}\"\n                   [placeholder]=\"placeholder\"\n                   [title]=\"field.tooltip\"\n                   (blur)=\"markAsTouched()\">\n        </mat-form-field>\n        <div class=\"adf-error-messages-container\">\n            <error-widget [error]=\"field.validationSummary\" />\n            <error-widget *ngIf=\"isInvalidFieldRequired() && isTouched()\"\n            required=\"{{ 'FORM.FIELD.REQUIRED' | translate }}\" />\n        </div>\n    </div>\n</div>\n"]}

package/esm2022/lib/form/components/widgets/unknown/unknown.widget.mjs

@@ -0,0 +1,63 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable @angular-eslint/component-selector */
+import { Component, ViewEncapsulation } from '@angular/core';
+import { MatIconModule } from '@angular/material/icon';
+import { MatListModule } from '@angular/material/list';
+import { FormService } from '../../../services/form.service';
+import { WidgetComponent } from '../widget.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/form.service";
+import * as i2 from "@angular/material/list";
+import * as i3 from "@angular/material/icon";
+export class UnknownWidgetComponent extends WidgetComponent {
+    constructor(formService) {
+        super(formService);
+        this.formService = formService;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UnknownWidgetComponent, deps: [{ token: i1.FormService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: UnknownWidgetComponent, isStandalone: true, selector: "unknown-widget", host: { listeners: { "click": "event($event)", "blur": "event($event)", "change": "event($event)", "focus": "event($event)", "focusin": "event($event)", "focusout": "event($event)", "input": "event($event)", "invalid": "event($event)", "select": "event($event)" } }, usesInheritance: true, ngImport: i0, template: `
+        <mat-list class="adf-unknown-widget">
+            <mat-list-item>
+                <mat-icon class="mat-24">error_outline</mat-icon>
+                <span class="adf-unknown-text">Unknown type: {{ field.type }}</span>
+            </mat-list-item>
+        </mat-list>
+    `, isInline: true, styles: [".adf-unknown-text{margin-left:10px;color:red}.adf-unknown-widget{margin:42px}\n"], dependencies: [{ kind: "ngmodule", type: MatListModule }, { kind: "component", type: i2.MatList, selector: "mat-list", exportAs: ["matList"] }, { kind: "component", type: i2.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["activated"], exportAs: ["matListItem"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UnknownWidgetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'unknown-widget', standalone: true, template: `
+        <mat-list class="adf-unknown-widget">
+            <mat-list-item>
+                <mat-icon class="mat-24">error_outline</mat-icon>
+                <span class="adf-unknown-text">Unknown type: {{ field.type }}</span>
+            </mat-list-item>
+        </mat-list>
+    `, host: {
+                        '(click)': 'event($event)',
+                        '(blur)': 'event($event)',
+                        '(change)': 'event($event)',
+                        '(focus)': 'event($event)',
+                        '(focusin)': 'event($event)',
+                        '(focusout)': 'event($event)',
+                        '(input)': 'event($event)',
+                        '(invalid)': 'event($event)',
+                        '(select)': 'event($event)'
+                    }, imports: [MatListModule, MatIconModule], encapsulation: ViewEncapsulation.None, styles: [".adf-unknown-text{margin-left:10px;color:red}.adf-unknown-widget{margin:42px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.FormService }] });
+//# sourceMappingURL=data:application/json;base64,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