imm-element-ui 0.0.1

package/esm2022/lib/form/form-field/field-utils.mjs

@@ -0,0 +1,227 @@
+import { tap } from 'rxjs';
+const _fieldUtils = {
+    props: (field) => {
+        let props = {};
+        switch (field.type) {
+            case 'inputtext':
+                props = field.inputTextProps;
+                break;
+            case 'inputnumber':
+                props = field.inputNumberProps;
+                break;
+            case 'select':
+                props = field.selectProps;
+                break;
+            case 'treeselect':
+                props = field.treeSelectProps;
+                break;
+            case 'datepicker':
+                props = field.datePickerProps;
+                break;
+            case 'autocomplete':
+                props = field.autoCompleteProps;
+                break;
+            case 'multiselect':
+                props = field.multiSelectProps;
+                break;
+            case 'radio':
+                props = field.radioProps;
+                break;
+            case 'textarea':
+                props = field.textAreaProps;
+                break;
+            case 'upload':
+                props = field.uploadProps;
+                break;
+            case 'image':
+                props = field.imageProps;
+                break;
+            case 'codemirror':
+                props = field.codeMirrorProps;
+                break;
+        }
+        return props;
+    },
+    label: (field, i18nService) => {
+        const i18nKey = _fieldUtils.props(field).i18nKey;
+        if (i18nKey) {
+            return i18nService.fanyi(i18nKey);
+        }
+        return _fieldUtils.props(field).label;
+    },
+    setModel(model, key, value) {
+        const keys = key.split('.');
+        if (keys.length == 1) {
+            model[key] = value;
+            return;
+        }
+        else {
+            const k = keys.shift();
+            if (model[k] == undefined) {
+                model[k] = {};
+            }
+            this.setModel(model[k], keys.join('.'), value);
+        }
+    },
+    getModel(model, key) {
+        const keys = key.split('.');
+        if (keys.length == 1) {
+            return model[key];
+        }
+        else {
+            const k = keys.shift();
+            if (model[k] == undefined) {
+                model[k] = {};
+            }
+            return this.getModel(model[k], keys.join('.'));
+        }
+    },
+    triggerHookAndSetValue: (field, value, detectModelChange, hookObservers, callback) => {
+        if (field.hook) {
+            const sub = field.hook
+                .pipe(tap((func) => {
+                func(field);
+            }))
+                .subscribe(() => {
+                field.fieldControl?.setValue(fieldUtils.toFieldValue(field, value), { onlySelf: false, emitEvent: false }, detectModelChange),
+                    callback && callback();
+            });
+            hookObservers.push(() => sub.unsubscribe());
+        }
+        else {
+            field.fieldControl?.setValue(fieldUtils.toFieldValue(field, value), { onlySelf: false, emitEvent: false }, detectModelChange);
+            callback && callback();
+        }
+    },
+    fromFieldValue: (field, target, datePipe) => {
+        if (field.type == 'treeselect') {
+            return _fieldUtils.fromTreeSelectValue(field, target);
+        }
+        if (field.type == 'datepicker') {
+            return _fieldUtils.fromDataPickerValue(field, target, datePipe);
+        }
+        if (field.type == 'multiselect') {
+            return _fieldUtils.fromMultiSelectValue(field, target);
+        }
+        if (field.type == 'image') {
+            return _fieldUtils.fromImageValue(field, target);
+        }
+        if (field.type == 'upload') {
+            return _fieldUtils.fromUploadValue(field, target);
+        }
+        return target;
+    },
+    fromTreeSelectValue: (field, target) => {
+        if (field.treeSelectProps?.selectionMode == 'single') {
+            return target.key;
+        }
+        return target.map((item) => item.key).join(',');
+    },
+    fromDataPickerValue: (field, target, datePipe) => {
+        const dateFormat = (field.datePickerProps?.dateFormat || 'yy-mm-dd').replace('yy', 'yyyy').replace('mm', 'MM');
+        return datePipe.transform(target, dateFormat) || target;
+    },
+    fromMultiSelectValue: (field, target) => {
+        if (!field.multiSelectProps?.optionValue) {
+            return target;
+        }
+        return target.join(',');
+    },
+    fromImageValue: (field, target) => {
+        return target.join(';');
+    },
+    fromUploadValue: (field, target) => {
+        return target.join(';');
+    },
+    toFieldValue: (field, raw) => {
+        if (field.type == 'treeselect') {
+            return _fieldUtils.toTreeSelectValue(field, raw);
+        }
+        if (field.type == 'multiselect') {
+            return _fieldUtils.toMultiSelectValue(field, raw);
+        }
+        if (field.type == 'image') {
+            return _fieldUtils.toImageValue(field, raw);
+        }
+        if (field.type == 'upload') {
+            return _fieldUtils.toUploadValue(field, raw);
+        }
+        return raw || '';
+    },
+    toTreeSelectValue: (field, raw) => {
+        if (field.treeSelectProps?.selectionMode == 'single') {
+            return _fieldUtils.findTreeNode(raw, field.treeSelectProps?.options);
+        }
+        const nodes = [];
+        _fieldUtils.findTreeNodes(raw?.split(',') || [], field.treeSelectProps?.options || [], nodes);
+        return nodes;
+    },
+    toMultiSelectValue: (field, raw) => {
+        if (!field.multiSelectProps?.optionValue) {
+            return raw || '';
+        }
+        return (raw && raw.split(',')) || '';
+    },
+    toImageValue: (field, raw) => {
+        return (raw && raw.split(';')) || [];
+    },
+    toUploadValue: (field, raw) => {
+        return (raw && raw.split(';')) || [];
+    },
+    findTreeNode(value, children) {
+        if (!children || children.length == 0)
+            return;
+        const n = children.find((o) => o.key == value);
+        if (n)
+            return n;
+        for (const ch of children) {
+            const cn = this.findTreeNode(value, ch.children);
+            if (cn)
+                return cn;
+        }
+        return;
+    },
+    findTreeNodes(values, children, nodes) {
+        if (!children || children.length == 0)
+            return;
+        const tars = children.filter((o) => values.indexOf(o.key) != -1);
+        nodes?.push(...tars);
+        for (const ch of children) {
+            this.findTreeNodes(values, ch.children, nodes);
+        }
+    },
+    transLog(rawModel, changedModel, mainValue, isNew) {
+        if (isNew) {
+            return '新建：' + mainValue;
+        }
+        const detail = [];
+        Object.keys(changedModel).forEach((key) => {
+            if (changedModel[key].type == 'codemirror') {
+                detail.push(`[${changedModel[key].name}] 变更`);
+                return;
+            }
+            detail.push(`[${changedModel[key].name}] ${rawModel[key] || ''} -> ${changedModel[key].value || ''}`);
+        });
+        return detail.join(';');
+    },
+    // 经测试select组件有内部bug
+    // 设置model时，fieldControl.setValue的emitEvent参数为false,仍会触发valueChanges事件
+    // 触发valueChanges会影响日志保存的准确性，故此方法仅是为了防止组件内部意外触发的变动
+    isFakedChange(newValue, oldValue, field) {
+        const changeTypes = ['inputtext', 'inputnumber', 'select', 'treeselect', 'datepicker', 'autocomplete', 'multiselect', 'radio'];
+        if (changeTypes.includes(field.type)) {
+            return (oldValue || '') == (newValue || '');
+        }
+        return false;
+    },
+};
+export const fieldUtils = {
+    props: _fieldUtils.props,
+    label: _fieldUtils.label,
+    triggerHookAndSetValue: _fieldUtils.triggerHookAndSetValue,
+    fromFieldValue: _fieldUtils.fromFieldValue,
+    toFieldValue: _fieldUtils.toFieldValue,
+    transLog: _fieldUtils.transLog,
+    isFakedChange: _fieldUtils.isFakedChange,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-utils.js","sourceRoot":"","sources":["../../../../../../projects/imm-ui/src/lib/form/form-field/field-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { FormField, FieldProps } from './form-field';\r\nimport { DatePipe } from '@angular/common';\r\nimport { I18nService } from '../../service/i18n.service';\r\nimport { tap } from 'rxjs';\r\n\r\nconst _fieldUtils = {\r\n\tprops: (field: FormField): FieldProps => {\r\n\t\tlet props: FieldProps = {};\r\n\t\tswitch (field.type) {\r\n\t\t\tcase 'inputtext':\r\n\t\t\t\tprops = field.inputTextProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'inputnumber':\r\n\t\t\t\tprops = field.inputNumberProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'select':\r\n\t\t\t\tprops = field.selectProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'treeselect':\r\n\t\t\t\tprops = field.treeSelectProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'datepicker':\r\n\t\t\t\tprops = field.datePickerProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'autocomplete':\r\n\t\t\t\tprops = field.autoCompleteProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'multiselect':\r\n\t\t\t\tprops = field.multiSelectProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'radio':\r\n\t\t\t\tprops = field.radioProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'textarea':\r\n\t\t\t\tprops = field.textAreaProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'upload':\r\n\t\t\t\tprops = field.uploadProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'image':\r\n\t\t\t\tprops = field.imageProps!;\r\n\t\t\t\tbreak;\r\n\t\t\tcase 'codemirror':\r\n\t\t\t\tprops = field.codeMirrorProps!;\r\n\t\t\t\tbreak;\r\n\t\t}\r\n\t\treturn props;\r\n\t},\r\n\tlabel: (field: FormField, i18nService: I18nService): string | undefined => {\r\n\t\tconst i18nKey = _fieldUtils.props(field).i18nKey;\r\n\t\tif (i18nKey) {\r\n\t\t\treturn i18nService.fanyi(i18nKey);\r\n\t\t}\r\n\t\treturn _fieldUtils.props(field).label;\r\n\t},\r\n\tsetModel(model: any, key: string, value: any) {\r\n\t\tconst keys = key.split('.');\r\n\t\tif (keys.length == 1) {\r\n\t\t\tmodel[key] = value;\r\n\t\t\treturn;\r\n\t\t} else {\r\n\t\t\tconst k: any = keys.shift();\r\n\t\t\tif (model[k] == undefined) {\r\n\t\t\t\tmodel[k] = {};\r\n\t\t\t}\r\n\t\t\tthis.setModel(model[k], keys.join('.'), value);\r\n\t\t}\r\n\t},\r\n\tgetModel(model: any, key: string): any {\r\n\t\tconst keys = key.split('.');\r\n\t\tif (keys.length == 1) {\r\n\t\t\treturn model[key];\r\n\t\t} else {\r\n\t\t\tconst k: any = keys.shift();\r\n\t\t\tif (model[k] == undefined) {\r\n\t\t\t\tmodel[k] = {};\r\n\t\t\t}\r\n\t\t\treturn this.getModel(model[k], keys.join('.'));\r\n\t\t}\r\n\t},\r\n\ttriggerHookAndSetValue: (field: FormField, value: any, detectModelChange: boolean, hookObservers: any[], callback: any) => {\r\n\t\tif (field.hook) {\r\n\t\t\tconst sub = field.hook\r\n\t\t\t\t.pipe(\r\n\t\t\t\t\ttap((func) => {\r\n\t\t\t\t\t\tfunc(field);\r\n\t\t\t\t\t}),\r\n\t\t\t\t)\r\n\t\t\t\t.subscribe(() => {\r\n\t\t\t\t\tfield.fieldControl?.setValue(fieldUtils.toFieldValue(field, value), { onlySelf: false, emitEvent: false }, detectModelChange),\r\n\t\t\t\t\t\tcallback && callback();\r\n\t\t\t\t});\r\n\t\t\thookObservers.push(() => sub.unsubscribe());\r\n\t\t} else {\r\n\t\t\tfield.fieldControl?.setValue(fieldUtils.toFieldValue(field, value), { onlySelf: false, emitEvent: false }, detectModelChange);\r\n\t\t\tcallback && callback();\r\n\t\t}\r\n\t},\r\n\tfromFieldValue: (field: FormField, target: any, datePipe: DatePipe): any => {\r\n\t\tif (field.type == 'treeselect') {\r\n\t\t\treturn _fieldUtils.fromTreeSelectValue(field, target);\r\n\t\t}\r\n\t\tif (field.type == 'datepicker') {\r\n\t\t\treturn _fieldUtils.fromDataPickerValue(field, target, datePipe);\r\n\t\t}\r\n\t\tif (field.type == 'multiselect') {\r\n\t\t\treturn _fieldUtils.fromMultiSelectValue(field, target);\r\n\t\t}\r\n\t\tif (field.type == 'image') {\r\n\t\t\treturn _fieldUtils.fromImageValue(field, target);\r\n\t\t}\r\n\t\tif (field.type == 'upload') {\r\n\t\t\treturn _fieldUtils.fromUploadValue(field, target);\r\n\t\t}\r\n\t\treturn target;\r\n\t},\r\n\tfromTreeSelectValue: (field: FormField, target: any): string => {\r\n\t\tif (field.treeSelectProps?.selectionMode == 'single') {\r\n\t\t\treturn target.key;\r\n\t\t}\r\n\t\treturn target.map((item: any) => item.key).join(',');\r\n\t},\r\n\tfromDataPickerValue: (field: FormField, target: any, datePipe: DatePipe): string => {\r\n\t\tconst dateFormat = (field.datePickerProps?.dateFormat || 'yy-mm-dd').replace('yy', 'yyyy').replace('mm', 'MM');\r\n\t\treturn datePipe.transform(target, dateFormat) || target;\r\n\t},\r\n\tfromMultiSelectValue: (field: FormField, target: any): string => {\r\n\t\tif (!field.multiSelectProps?.optionValue) {\r\n\t\t\treturn target;\r\n\t\t}\r\n\t\treturn target.join(',');\r\n\t},\r\n\tfromImageValue: (field: FormField, target: any): string => {\r\n\t\treturn target.join(';');\r\n\t},\r\n\tfromUploadValue: (field: FormField, target: any): string => {\r\n\t\treturn target.join(';');\r\n\t},\r\n\ttoFieldValue: (field: FormField, raw: any): any => {\r\n\t\tif (field.type == 'treeselect') {\r\n\t\t\treturn _fieldUtils.toTreeSelectValue(field, raw);\r\n\t\t}\r\n\t\tif (field.type == 'multiselect') {\r\n\t\t\treturn _fieldUtils.toMultiSelectValue(field, raw);\r\n\t\t}\r\n\t\tif (field.type == 'image') {\r\n\t\t\treturn _fieldUtils.toImageValue(field, raw);\r\n\t\t}\r\n\t\tif (field.type == 'upload') {\r\n\t\t\treturn _fieldUtils.toUploadValue(field, raw);\r\n\t\t}\r\n\t\treturn raw || '';\r\n\t},\r\n\ttoTreeSelectValue: (field: FormField, raw: any): any => {\r\n\t\tif (field.treeSelectProps?.selectionMode == 'single') {\r\n\t\t\treturn _fieldUtils.findTreeNode(raw, field.treeSelectProps?.options);\r\n\t\t}\r\n\t\tconst nodes: any[] = [];\r\n\t\t_fieldUtils.findTreeNodes(raw?.split(',') || [], field.treeSelectProps?.options || [], nodes);\r\n\t\treturn nodes;\r\n\t},\r\n\ttoMultiSelectValue: (field: FormField, raw: any): any => {\r\n\t\tif (!field.multiSelectProps?.optionValue) {\r\n\t\t\treturn raw || '';\r\n\t\t}\r\n\t\treturn (raw && raw.split(',')) || '';\r\n\t},\r\n\ttoImageValue: (field: FormField, raw: any): any => {\r\n\t\treturn (raw && raw.split(';')) || [];\r\n\t},\r\n\ttoUploadValue: (field: FormField, raw: any): any => {\r\n\t\treturn (raw && raw.split(';')) || [];\r\n\t},\r\n\tfindTreeNode(value: string, children?: any[]): any {\r\n\t\tif (!children || children.length == 0) return;\r\n\t\tconst n = children.find((o) => o.key == value);\r\n\t\tif (n) return n;\r\n\t\tfor (const ch of children) {\r\n\t\t\tconst cn = this.findTreeNode(value, ch.children);\r\n\t\t\tif (cn) return cn;\r\n\t\t}\r\n\t\treturn;\r\n\t},\r\n\tfindTreeNodes(values: string[], children?: any[], nodes?: any[]): void {\r\n\t\tif (!children || children.length == 0) return;\r\n\t\tconst tars = children.filter((o) => values.indexOf(o.key) != -1);\r\n\t\tnodes?.push(...tars);\r\n\t\tfor (const ch of children) {\r\n\t\t\tthis.findTreeNodes(values, ch.children, nodes);\r\n\t\t}\r\n\t},\r\n\ttransLog(rawModel: any, changedModel: any, mainValue: any, isNew: boolean): string {\r\n\t\tif (isNew) {\r\n\t\t\treturn '新建：' + mainValue;\r\n\t\t}\r\n\t\tconst detail: string[] = [];\r\n\t\tObject.keys(changedModel).forEach((key) => {\r\n\t\t\tif (changedModel[key].type == 'codemirror') {\r\n\t\t\t\tdetail.push(`[${changedModel[key].name}] 变更`);\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\t\t\tdetail.push(`[${changedModel[key].name}] ${rawModel[key] || ''} -> ${changedModel[key].value || ''}`);\r\n\t\t});\r\n\t\treturn detail.join(';');\r\n\t},\r\n\t// 经测试select组件有内部bug\r\n\t// 设置model时，fieldControl.setValue的emitEvent参数为false,仍会触发valueChanges事件\r\n\t// 触发valueChanges会影响日志保存的准确性，故此方法仅是为了防止组件内部意外触发的变动\r\n\tisFakedChange(newValue: any, oldValue: any, field: FormField): boolean {\r\n\t\tconst changeTypes = ['inputtext', 'inputnumber', 'select', 'treeselect', 'datepicker', 'autocomplete', 'multiselect', 'radio'];\r\n\t\tif (changeTypes.includes(field.type!)) {\r\n\t\t\treturn (oldValue || '') == (newValue || '');\r\n\t\t}\r\n\t\treturn false;\r\n\t},\r\n};\r\n\r\nexport const fieldUtils = {\r\n\tprops: _fieldUtils.props,\r\n\tlabel: _fieldUtils.label,\r\n\ttriggerHookAndSetValue: _fieldUtils.triggerHookAndSetValue,\r\n\tfromFieldValue: _fieldUtils.fromFieldValue,\r\n\ttoFieldValue: _fieldUtils.toFieldValue,\r\n\ttransLog: _fieldUtils.transLog,\r\n\tisFakedChange: _fieldUtils.isFakedChange,\r\n};\r\n"]}

package/esm2022/lib/form/form-field/form-field.mjs

@@ -0,0 +1,129 @@
+import { Component, input, ViewChild, ViewChildren } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { LabelDirective } from './label.directive';
+import { TranslatePipe } from '@ngx-translate/core';
+import { fieldUtils } from './field-utils';
+import { FormTypeComponent, } from './form-type';
+import * as i0 from "@angular/core";
+export class FormFieldComponent {
+    constructor() {
+        this.field = input();
+        this.props = fieldUtils.props;
+    }
+    ngOnInit() { }
+    labelClass() {
+        const lc = [];
+        if (this.field()?.fieldControl?.dirty) {
+            lc.push('ng-dirty');
+        }
+        if (this.field()?.fieldControl?.valid != undefined) {
+            lc.push('ng-valid');
+        }
+        return lc.join(' ');
+    }
+    getFieldComponents() {
+        return this.fieldComponents;
+    }
+    getFieldLabel() {
+        return this.fieldLabel;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: FormFieldComponent, isStandalone: true, selector: "form-field", inputs: { field: { classPropertyName: "field", publicName: "field", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "fieldLabel", first: true, predicate: ["fieldLabelRef"], descendants: true }, { propertyName: "fieldComponents", predicate: FormFieldComponent, descendants: true }], ngImport: i0, template: `
+		@if (field()?.group) {
+			<div [class]="field()?.groupClass">
+				@for (fchild of field()!.group; track fchild) {
+					@if (!fchild.hide) {
+						<div [class]="fchild.groupClass || fchild.class">
+							<form-field
+								class="w-full"
+								[field]="fchild">
+							</form-field>
+						</div>
+					}
+				}
+			</div>
+		} @else {
+			<div [class]="field()?.innerClass || 'px-4 my-1'">
+				<div class="flex flex-row flex-nowrap items-start">
+					<div
+						class="flex-none p-field field-label min-h-8 pt-[1.5px] flex items-center"
+						[style]="{ width: field()?.labelMinWidth(), maxWidth: '40%' }">
+						<label
+							[class]="labelClass()"
+							[fieldLabel]="field()!">
+							<span
+								style="user-select: none"
+								#fieldLabelRef
+								>{{ props(field()!).i18nKey ? (props(field()!).i18nKey! | translate) : props(field()!).label! }}</span
+							>
+							@if (props(field()!).required) {
+								<span class="field-required">*</span>
+							}
+						</label>
+					</div>
+					<div class="flex-1 min-h-8 pt-1 w-0 flex flex-row-reverse">
+						<div
+							#fieldTypeRef
+							class="w-full">
+							<form-type [field]="field()!"></form-type>
+						</div>
+					</div>
+				</div>
+			</div>
+		}
+	`, isInline: true, styles: [".p-field>label{margin:2px;text-overflow:ellipsis;display:block;color:#1e293b}.p-field>label:not(.ng-valid).ng-dirty{color:var(--p-red-500)!important}.p-field>label:not(.ng-valid).ng-dirty>.field-required{color:var(--p-red-500)!important}.field-required{padding-left:2.5px;color:var(--p-primary-color)}.field-label{display:inline-block;overflow-wrap:break-word;word-break:break-word;white-space:normal}\n"], dependencies: [{ kind: "component", type: FormFieldComponent, selector: "form-field", inputs: ["field"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "component", type: FormTypeComponent, selector: "form-type", inputs: ["field"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "directive", type: LabelDirective, selector: "[fieldLabel]", inputs: ["fieldLabel"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'form-field', standalone: true, imports: [ReactiveFormsModule, FormTypeComponent, TranslatePipe, LabelDirective], template: `
+		@if (field()?.group) {
+			<div [class]="field()?.groupClass">
+				@for (fchild of field()!.group; track fchild) {
+					@if (!fchild.hide) {
+						<div [class]="fchild.groupClass || fchild.class">
+							<form-field
+								class="w-full"
+								[field]="fchild">
+							</form-field>
+						</div>
+					}
+				}
+			</div>
+		} @else {
+			<div [class]="field()?.innerClass || 'px-4 my-1'">
+				<div class="flex flex-row flex-nowrap items-start">
+					<div
+						class="flex-none p-field field-label min-h-8 pt-[1.5px] flex items-center"
+						[style]="{ width: field()?.labelMinWidth(), maxWidth: '40%' }">
+						<label
+							[class]="labelClass()"
+							[fieldLabel]="field()!">
+							<span
+								style="user-select: none"
+								#fieldLabelRef
+								>{{ props(field()!).i18nKey ? (props(field()!).i18nKey! | translate) : props(field()!).label! }}</span
+							>
+							@if (props(field()!).required) {
+								<span class="field-required">*</span>
+							}
+						</label>
+					</div>
+					<div class="flex-1 min-h-8 pt-1 w-0 flex flex-row-reverse">
+						<div
+							#fieldTypeRef
+							class="w-full">
+							<form-type [field]="field()!"></form-type>
+						</div>
+					</div>
+				</div>
+			</div>
+		}
+	`, styles: [".p-field>label{margin:2px;text-overflow:ellipsis;display:block;color:#1e293b}.p-field>label:not(.ng-valid).ng-dirty{color:var(--p-red-500)!important}.p-field>label:not(.ng-valid).ng-dirty>.field-required{color:var(--p-red-500)!important}.field-required{padding-left:2.5px;color:var(--p-primary-color)}.field-label{display:inline-block;overflow-wrap:break-word;word-break:break-word;white-space:normal}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { fieldComponents: [{
+                type: ViewChildren,
+                args: [FormFieldComponent]
+            }], fieldLabel: [{
+                type: ViewChild,
+                args: ['fieldLabelRef', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-field.js","sourceRoot":"","sources":["../../../../../../projects/imm-ui/src/lib/form/form-field/form-field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAc,YAAY,EAAqC,MAAM,eAAe,CAAC;AACzH,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EACN,iBAAiB,GAajB,MAAM,aAAa,CAAC;;AA+JrB,MAAM,OAAO,kBAAkB;IAM9B;QAHA,UAAK,GAAG,KAAK,EAAa,CAAC;QAC3B,UAAK,GAAG,UAAU,CAAC,KAAK,CAAC;IAEV,CAAC;IAEhB,QAAQ,KAAU,CAAC;IAEnB,UAAU;QACT,MAAM,EAAE,GAAG,EAAE,CAAC;QACd,IAAI,IAAI,CAAC,KAAK,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;YACvC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACrB,CAAC;QACD,IAAI,IAAI,CAAC,KAAK,EAAE,EAAE,YAAY,EAAE,KAAK,IAAI,SAAS,EAAE,CAAC;YACpD,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACrB,CAAC;QACD,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC;IAED,kBAAkB;QACjB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC7B,CAAC;IAED,aAAa;QACZ,OAAO,IAAI,CAAC,UAAU,CAAC;IACxB,CAAC;+GA3BW,kBAAkB;mGAAlB,kBAAkB,4UAChB,kBAAkB,gDA9CtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CT,6dAEW,kBAAkB,yEAtEpB,mBAAmB,+BAAE,iBAAiB,oEAAE,aAAa,kDAAE,cAAc;;4FAsEnE,kBAAkB;kBAzE9B,SAAS;+BACC,YAAY,cACV,IAAI,WACP,CAAC,mBAAmB,EAAE,iBAAiB,EAAE,aAAa,EAAE,cAAc,CAAC,YAyBtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CT;wDAGiC,eAAe;sBAAhD,YAAY;uBAAC,kBAAkB;gBACe,UAAU;sBAAxD,SAAS;uBAAC,eAAe,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE","sourcesContent":["import { Component, input, ViewChild, ElementRef, ViewChildren, QueryList, effect, WritableSignal } from '@angular/core';\r\nimport { ReactiveFormsModule } from '@angular/forms';\r\nimport { LabelDirective } from './label.directive';\r\nimport { TranslatePipe } from '@ngx-translate/core';\r\nimport { fieldUtils } from './field-utils';\r\nimport { Observable } from 'rxjs';\r\nimport {\r\n\tFormTypeComponent,\r\n\tInputTextProps,\r\n\tInputNumberProps,\r\n\tSelectProps,\r\n\tTreeSelectProps,\r\n\tDatePickerProps,\r\n\tAutoCompleteProps,\r\n\tMultiSelectProps,\r\n\tRadioProps,\r\n\tTextAreaProps,\r\n\tUploadProps,\r\n\tImageProps,\r\n\tCodeMirrorProps,\r\n} from './form-type';\r\nimport { FieldControl } from './field-control';\r\n\r\nexport interface FormField {\r\n\tkey?: string;\r\n\ttype?:\r\n\t\t| 'inputtext'\r\n\t\t| 'inputnumber'\r\n\t\t| 'select'\r\n\t\t| 'treeselect'\r\n\t\t| 'datepicker'\r\n\t\t| 'autocomplete'\r\n\t\t| 'multiselect'\r\n\t\t| 'radio'\r\n\t\t| 'textarea'\r\n\t\t| 'upload'\r\n\t\t| 'image'\r\n\t\t| 'codemirror';\r\n\tdefault?: any;\r\n\tid?: string;\r\n\tname?: string;\r\n\tgroup?: FormField[];\r\n\tgroupClass?: string;\r\n\tclass?: string;\r\n\tinnerClass?: string;\r\n\tfieldControl?: FieldControl;\r\n\tinputTextProps?: InputTextProps;\r\n\tinputNumberProps?: InputNumberProps;\r\n\tselectProps?: SelectProps;\r\n\ttreeSelectProps?: TreeSelectProps;\r\n\tdatePickerProps?: DatePickerProps;\r\n\tautoCompleteProps?: AutoCompleteProps;\r\n\tmultiSelectProps?: MultiSelectProps;\r\n\tradioProps?: RadioProps;\r\n\ttextAreaProps?: TextAreaProps;\r\n\tuploadProps?: UploadProps;\r\n\timageProps?: ImageProps;\r\n\tcodeMirrorProps?: CodeMirrorProps;\r\n\thide?: boolean;\r\n\thideExpression?: (model: any, field?: FormField) => boolean;\r\n\thook?: Observable<(field?: FormField) => void>;\r\n\tvalidators?: any;\r\n\tinvalid?: boolean;\r\n\textra?: any;\r\n\tuuid?: string;\r\n\tlabelMinWidth?: WritableSignal<string | undefined>;\r\n\tinteractiveLabel?: boolean;\r\n\tform?:any\r\n}\r\n\r\nexport interface FieldProps {\r\n\ttype?: string;\r\n\tlabel?: string;\r\n\ti18nKey?: string;\r\n\tlabelClass?: string;\r\n\tlabelVariant?: 'in' | 'over' | 'on';\r\n\tvariant?: any;\r\n\tclass?: string;\r\n\tname?: string;\r\n\tplaceholder?: string;\r\n\tdisabled?: boolean;\r\n\thidden?: boolean;\r\n\trequired?: boolean;\r\n\tsize?: any;\r\n\tstyleClass?: string;\r\n\tstyle?: any;\r\n\tautofocus?: boolean;\r\n\tmin?: number;\r\n\tmax?: number;\r\n\tinputStyle?: any;\r\n\tinputStyleClass?: string;\r\n\tfluid?: boolean;\r\n\tariaLabel?: string;\r\n\tariaLabelledBy?: string;\r\n\tfocus?: FocusEvent;\r\n\tblur?: FocusEvent;\r\n\tkeyup?: KeyboardEvent;\r\n\tkeydown?: KeyboardEvent;\r\n\tclick?: MouseEvent;\r\n\tinput?: Event;\r\n\tchange?: Event;\r\n\tkeypress?: KeyboardEvent;\r\n}\r\n\r\nexport declare type AttributeEvent = (field: FormField, event?: any) => void;\r\n\r\n@Component({\r\n\tselector: 'form-field',\r\n\tstandalone: true,\r\n\timports: [ReactiveFormsModule, FormTypeComponent, TranslatePipe, LabelDirective],\r\n\tstyles:`\r\n\t\t.p-field > label {\r\n\t\t\tmargin: 2px;\r\n\t\t\ttext-overflow: ellipsis;\r\n\t\t\tdisplay: block;\r\n\t\t\tcolor: #1e293b;\r\n\t\t}\r\n\t\t.p-field > label:not(.ng-valid).ng-dirty {\r\n\t\t\tcolor: var(--p-red-500) !important;\r\n\t\t}\r\n\t\t.p-field > label:not(.ng-valid).ng-dirty > .field-required {\r\n\t\t\tcolor: var(--p-red-500) !important;\r\n\t\t}\r\n\t\t.field-required {\r\n\t\t\tpadding-left: 2.5px;\r\n\t\t\tcolor: var(--p-primary-color);\r\n\t\t}\r\n\t\t.field-label {\r\n\t\t\tdisplay: inline-block;\r\n\t\t\toverflow-wrap: break-word;\r\n\t\t\tword-break: break-word;\r\n\t\t\twhite-space: normal;\r\n\t\t}\r\n\t`,\r\n\ttemplate: `\r\n\t\t@if (field()?.group) {\r\n\t\t\t<div [class]=\"field()?.groupClass\">\r\n\t\t\t\t@for (fchild of field()!.group; track fchild) {\r\n\t\t\t\t\t@if (!fchild.hide) {\r\n\t\t\t\t\t\t<div [class]=\"fchild.groupClass || fchild.class\">\r\n\t\t\t\t\t\t\t<form-field\r\n\t\t\t\t\t\t\t\tclass=\"w-full\"\r\n\t\t\t\t\t\t\t\t[field]=\"fchild\">\r\n\t\t\t\t\t\t\t</form-field>\r\n\t\t\t\t\t\t</div>\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t</div>\r\n\t\t} @else {\r\n\t\t\t<div [class]=\"field()?.innerClass || 'px-4 my-1'\">\r\n\t\t\t\t<div class=\"flex flex-row flex-nowrap items-start\">\r\n\t\t\t\t\t<div\r\n\t\t\t\t\t\tclass=\"flex-none p-field field-label min-h-8 pt-[1.5px] flex items-center\"\r\n\t\t\t\t\t\t[style]=\"{ width: field()?.labelMinWidth(), maxWidth: '40%' }\">\r\n\t\t\t\t\t\t<label\r\n\t\t\t\t\t\t\t[class]=\"labelClass()\"\r\n\t\t\t\t\t\t\t[fieldLabel]=\"field()!\">\r\n\t\t\t\t\t\t\t<span\r\n\t\t\t\t\t\t\t\tstyle=\"user-select: none\"\r\n\t\t\t\t\t\t\t\t#fieldLabelRef\r\n\t\t\t\t\t\t\t\t>{{ props(field()!).i18nKey ? (props(field()!).i18nKey! | translate) : props(field()!).label! }}</span\r\n\t\t\t\t\t\t\t>\r\n\t\t\t\t\t\t\t@if (props(field()!).required) {\r\n\t\t\t\t\t\t\t\t<span class=\"field-required\">*</span>\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t</label>\r\n\t\t\t\t\t</div>\r\n\t\t\t\t\t<div class=\"flex-1 min-h-8 pt-1 w-0 flex flex-row-reverse\">\r\n\t\t\t\t\t\t<div\r\n\t\t\t\t\t\t\t#fieldTypeRef\r\n\t\t\t\t\t\t\tclass=\"w-full\">\r\n\t\t\t\t\t\t\t<form-type [field]=\"field()!\"></form-type>\r\n\t\t\t\t\t\t</div>\r\n\t\t\t\t\t</div>\r\n\t\t\t\t</div>\r\n\t\t\t</div>\r\n\t\t}\r\n\t`,\r\n})\r\nexport class FormFieldComponent {\r\n\t@ViewChildren(FormFieldComponent) fieldComponents?: QueryList<FormFieldComponent>;\r\n\t@ViewChild('fieldLabelRef', { static: false }) fieldLabel?: ElementRef;\r\n\tfield = input<FormField>();\r\n\tprops = fieldUtils.props;\r\n\r\n\tconstructor() {}\r\n\r\n\tngOnInit(): void {}\r\n\r\n\tlabelClass() {\r\n\t\tconst lc = [];\r\n\t\tif (this.field()?.fieldControl?.dirty) {\r\n\t\t\tlc.push('ng-dirty');\r\n\t\t}\r\n\t\tif (this.field()?.fieldControl?.valid != undefined) {\r\n\t\t\tlc.push('ng-valid');\r\n\t\t}\r\n\t\treturn lc.join(' ');\r\n\t}\r\n\r\n\tgetFieldComponents(): QueryList<FormFieldComponent> | undefined {\r\n\t\treturn this.fieldComponents;\r\n\t}\r\n\r\n\tgetFieldLabel() {\r\n\t\treturn this.fieldLabel;\r\n\t}\r\n}\r\n"]}

package/esm2022/lib/form/form-field/form-type.mjs

@@ -0,0 +1,123 @@
+import { Component, input } from '@angular/core';
+import { InputTextComponent } from '../form-type/inputtext.type';
+import { InputNumberComponent } from '../form-type/inputnumber.type';
+import { SelectComponent } from '../form-type/select.type';
+import { TreeSelectComponent } from '../form-type/treeselect.type';
+import { DatePickerComponent } from '../form-type/datepicker.type';
+import { AutoCompleteComponent } from '../form-type/autocomplete.type';
+import { MultiSelectComponent } from '../form-type/multiselect.type';
+import { RadioComponent } from '../form-type/radio.type';
+import { TextAreaComponent } from '../form-type/textarea.type';
+import { UploadComponent } from '../form-type/upload.type';
+import { ImageComponent } from '../form-type/image.type';
+import { CodeMirrorComponent } from '../form-type/codemirror.type';
+import * as i0 from "@angular/core";
+export class FormTypeComponent {
+    constructor() {
+        this.field = input();
+    }
+    ngOnInit() { }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormTypeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: FormTypeComponent, isStandalone: true, selector: "form-type", inputs: { field: { classPropertyName: "field", publicName: "field", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: `
+		@switch (field()?.type) {
+			@case ('inputtext') {
+				<form-inputtext [field]="field()!"></form-inputtext>
+			}
+			@case ('inputnumber') {
+				<form-inputnumber [field]="field()!"></form-inputnumber>
+			}
+			@case ('select') {
+				<form-select [field]="field()!"></form-select>
+			}
+			@case ('treeselect') {
+				<form-treeselect [field]="field()!"></form-treeselect>
+			}
+			@case ('datepicker') {
+				<form-datepicker [field]="field()!"></form-datepicker>
+			}
+			@case ('autocomplete') {
+				<form-autocomplete [field]="field()!"></form-autocomplete>
+			}
+			@case ('multiselect') {
+				<form-multiselect [field]="field()!"></form-multiselect>
+			}
+			@case ('radio') {
+				<form-radio [field]="field()!"></form-radio>
+			}
+			@case ('textarea') {
+				<form-textarea [field]="field()!"></form-textarea>
+			}
+			@case ('upload') {
+				<form-upload [field]="field()!"></form-upload>
+			}
+			@case ('image') {
+				<form-image [field]="field()!"></form-image>
+			}
+			@case ('codemirror') {
+				<form-codemirror [field]="field()!"></form-codemirror>
+			}
+		}
+	`, isInline: true, dependencies: [{ kind: "component", type: InputTextComponent, selector: "form-inputtext", inputs: ["field"] }, { kind: "component", type: InputNumberComponent, selector: "form-inputnumber", inputs: ["field"] }, { kind: "component", type: SelectComponent, selector: "form-select", inputs: ["field"] }, { kind: "component", type: TreeSelectComponent, selector: "form-treeselect", inputs: ["field"] }, { kind: "component", type: DatePickerComponent, selector: "form-datepicker", inputs: ["field"] }, { kind: "component", type: AutoCompleteComponent, selector: "form-autocomplete", inputs: ["field"] }, { kind: "component", type: MultiSelectComponent, selector: "form-multiselect", inputs: ["field"] }, { kind: "component", type: RadioComponent, selector: "form-radio", inputs: ["field"] }, { kind: "component", type: TextAreaComponent, selector: "form-textarea", inputs: ["field"] }, { kind: "component", type: UploadComponent, selector: "form-upload", inputs: ["field"] }, { kind: "component", type: ImageComponent, selector: "form-image", inputs: ["field"] }, { kind: "component", type: CodeMirrorComponent, selector: "form-codemirror", inputs: ["field"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FormTypeComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'form-type',
+                    standalone: true,
+                    imports: [
+                        InputTextComponent,
+                        InputNumberComponent,
+                        SelectComponent,
+                        TreeSelectComponent,
+                        DatePickerComponent,
+                        AutoCompleteComponent,
+                        MultiSelectComponent,
+                        RadioComponent,
+                        TextAreaComponent,
+                        UploadComponent,
+                        ImageComponent,
+                        CodeMirrorComponent,
+                    ],
+                    template: `
+		@switch (field()?.type) {
+			@case ('inputtext') {
+				<form-inputtext [field]="field()!"></form-inputtext>
+			}
+			@case ('inputnumber') {
+				<form-inputnumber [field]="field()!"></form-inputnumber>
+			}
+			@case ('select') {
+				<form-select [field]="field()!"></form-select>
+			}
+			@case ('treeselect') {
+				<form-treeselect [field]="field()!"></form-treeselect>
+			}
+			@case ('datepicker') {
+				<form-datepicker [field]="field()!"></form-datepicker>
+			}
+			@case ('autocomplete') {
+				<form-autocomplete [field]="field()!"></form-autocomplete>
+			}
+			@case ('multiselect') {
+				<form-multiselect [field]="field()!"></form-multiselect>
+			}
+			@case ('radio') {
+				<form-radio [field]="field()!"></form-radio>
+			}
+			@case ('textarea') {
+				<form-textarea [field]="field()!"></form-textarea>
+			}
+			@case ('upload') {
+				<form-upload [field]="field()!"></form-upload>
+			}
+			@case ('image') {
+				<form-image [field]="field()!"></form-image>
+			}
+			@case ('codemirror') {
+				<form-codemirror [field]="field()!"></form-codemirror>
+			}
+		}
+	`,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/form/form-field/label.directive.mjs

@@ -0,0 +1,62 @@
+import { Directive, HostListener, input } from '@angular/core';
+import { fieldUtils } from './field-utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../../service/action.service";
+export class LabelDirective {
+    constructor(action) {
+        this.action = action;
+        this.fieldLabel = input();
+    }
+    onMouseEnter() {
+        if (fieldUtils.props(this.fieldLabel()).disabled)
+            return;
+        if (!this.fieldLabel()?.interactiveLabel)
+            return;
+        this.action.setFieldLabelAction(this.fieldLabel().uuid, 'mouseenter');
+    }
+    onMouseLeave() {
+        if (fieldUtils.props(this.fieldLabel()).disabled)
+            return;
+        if (!this.fieldLabel()?.interactiveLabel)
+            return;
+        this.fieldLabel()?.interactiveLabel && this.action.setFieldLabelAction(this.fieldLabel().uuid, 'mouseleave');
+    }
+    onClick() {
+        console.log('-----click', this.fieldLabel());
+        if (this.fieldLabel()?.interactiveLabel) {
+            if (fieldUtils.props(this.fieldLabel()).disabled)
+                return;
+            this.action.setFieldLabelAction(this.fieldLabel().uuid, 'click');
+        }
+        else {
+            this.action.setFieldAction(this.fieldLabel());
+        }
+    }
+    onDoubleClick() {
+        if (this.fieldLabel()?.type === 'codemirror') {
+            this.action.setFieldLabelAction(this.fieldLabel().uuid, 'dblclick');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LabelDirective, deps: [{ token: i1.ActionService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: LabelDirective, isStandalone: true, selector: "[fieldLabel]", inputs: { fieldLabel: { classPropertyName: "fieldLabel", publicName: "fieldLabel", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "mouseenter": "onMouseEnter()", "mouseleave": "onMouseLeave()", "click": "onClick()", "dblclick": "onDoubleClick()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LabelDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[fieldLabel]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.ActionService }], propDecorators: { onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], onMouseLeave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }], onDoubleClick: [{
+                type: HostListener,
+                args: ['dblclick']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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