@alauda-fe/dynamic-plugin-shared 0.0.1-alpha.0

package/esm2022/form/base-form-container.mjs

@@ -0,0 +1,126 @@
+import { __decorate, __metadata } from "tslib";
+import { NotificationService } from '@alauda/ui';
+import { Location } from '@angular/common';
+import { Directive, Injector, Input, ViewChild } from '@angular/core';
+import { FormBuilder, NgForm } from '@angular/forms';
+import { identity } from 'lodash-es';
+import { Observable } from 'rxjs';
+import { createActions, yamlWriteOptions, } from '../code-editor/code-editor-configs';
+import { InterceptDeactivateService } from '../page-deactivate';
+import { isErrorMessage } from '../types';
+import { ObservableInput } from '../utils';
+import { parseAll, stringify } from '../utils/yaml';
+import * as i0 from "@angular/core";
+/**
+ * http://confluence.alauda.cn/display/FRON/Issue-Angular+related
+ * 由于formControl存在内存泄漏问题，内部 form 展示-隐藏切换应当采用 hidden 进行控制
+ */
+export class BaseFormContainer {
+    constructor(injector) {
+        this.isUpdate = false;
+        this.codeEditorOptions = yamlWriteOptions;
+        this.actionsConfig = createActions;
+        this.formView = 'UI';
+        this.submitting = false;
+        this.fillResource = identity;
+        this.notification = injector.get(NotificationService);
+        this.location = injector.get(Location);
+        this.fb = injector.get(FormBuilder);
+        this.interceptDeactivate = injector.get(InterceptDeactivateService);
+        this.form = this.fb.group({ resource: this.fb.control('') });
+    }
+    ngOnInit() {
+        this.resource = this.initResource;
+        this.form.patchValue({
+            resource: this.initResource,
+        });
+    }
+    switchFormView(view) {
+        let resource;
+        if (view === 'UI') {
+            try {
+                resource = this.yamlToResource(this.yaml);
+                this.form.patchValue({
+                    resource,
+                });
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+        else {
+            resource = this.form.get('resource').value;
+            this.originalYaml = this.yaml = this.resourceToYaml(resource);
+        }
+        this.resource = resource;
+        this.formView = view;
+    }
+    cancel(escape) {
+        this.interceptDeactivate.back(escape);
+    }
+    checkForm() {
+        this.ngForm.onSubmit(null);
+        if (this.formView === 'UI' && this.ngForm.invalid) {
+            return false;
+        }
+        if (this.formView === 'YAML') {
+            try {
+                this.resource = this.yamlToResource(this.yaml);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        const resource = this.form.get('resource').value;
+        this.resource = this.fillResource(resource);
+        return true;
+    }
+    yamlToResource(yaml) {
+        try {
+            const all = parseAll(yaml);
+            return (Array.isArray(this.resource) ? all : all[0]);
+        }
+        catch (e) {
+            if (isErrorMessage(e)) {
+                this.notification.error(e.message);
+            }
+            throw e;
+        }
+    }
+    resourceToYaml(resource) {
+        try {
+            if (Array.isArray(resource)) {
+                return resource
+                    .map(r => stringify(r, { blockQuote: 'literal' }))
+                    .join('\n---\r\n\n');
+            }
+            return stringify(resource, { blockQuote: 'literal' });
+        }
+        catch (error) {
+            console.error(error);
+            return '{}';
+        }
+    }
+    updateResource(resource) {
+        this.form.patchValue({ resource });
+        this.resource = resource;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseFormContainer, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: BaseFormContainer, inputs: { isUpdate: "isUpdate", initResource: "initResource" }, viewQueries: [{ propertyName: "ngForm", first: true, predicate: ["resourceForm"], descendants: true }], ngImport: i0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], BaseFormContainer.prototype, "initResource$", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseFormContainer, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }], propDecorators: { isUpdate: [{
+                type: Input
+            }], initResource: [{
+                type: Input
+            }], initResource$: [], ngForm: [{
+                type: ViewChild,
+                args: ['resourceForm', { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-form-container.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/form/base-form-container.ts"],"names":[],"mappings":"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","sourcesContent":["import { NotificationService } from '@alauda/ui';\nimport { Location } from '@angular/common';\nimport { Directive, Injector, Input, OnInit, ViewChild } from '@angular/core';\nimport { FormBuilder, FormGroup, NgForm } from '@angular/forms';\nimport { identity } from 'lodash-es';\nimport { Observable } from 'rxjs';\n\nimport {\n  createActions,\n  yamlWriteOptions,\n} from '../code-editor/code-editor-configs';\nimport { InterceptDeactivateService } from '../page-deactivate';\nimport { isErrorMessage } from '../types';\nimport { ObservableInput } from '../utils';\nimport { parseAll, stringify } from '../utils/yaml';\n\n/**\n * http://confluence.alauda.cn/display/FRON/Issue-Angular+related\n * 由于formControl存在内存泄漏问题，内部 form 展示-隐藏切换应当采用 hidden 进行控制\n */\n@Directive()\nexport abstract class BaseFormContainer<T = any> implements OnInit {\n  @Input()\n  isUpdate = false;\n\n  @Input()\n  initResource: T;\n\n  @ObservableInput()\n  initResource$: Observable<T>;\n\n  @ViewChild('resourceForm', { static: false })\n  private readonly ngForm: NgForm;\n\n  codeEditorOptions = yamlWriteOptions;\n  actionsConfig = createActions;\n  formView: 'UI' | 'YAML' = 'UI';\n  submitting = false;\n\n  resource: T;\n  yaml: string;\n  // 支持带 '恢复' 的 codeEditor\n  originalYaml: string;\n  fb: FormBuilder;\n  interceptDeactivate: InterceptDeactivateService;\n\n  form: FormGroup;\n\n  protected notification: NotificationService;\n  protected location: Location;\n  protected fillResource: (resource: T) => T = identity;\n\n  abstract submit(params?: unknown): void;\n\n  constructor(injector: Injector) {\n    this.notification = injector.get(NotificationService);\n    this.location = injector.get(Location);\n    this.fb = injector.get(FormBuilder);\n    this.interceptDeactivate = injector.get(InterceptDeactivateService);\n    this.form = this.fb.group({ resource: this.fb.control('') });\n  }\n\n  ngOnInit() {\n    this.resource = this.initResource;\n    this.form.patchValue({\n      resource: this.initResource,\n    });\n  }\n\n  switchFormView(view: 'YAML' | 'UI') {\n    let resource: T;\n    if (view === 'UI') {\n      try {\n        resource = this.yamlToResource(this.yaml);\n        this.form.patchValue({\n          resource,\n        });\n      } catch (err) {\n        console.error(err);\n      }\n    } else {\n      resource = this.form.get('resource').value;\n      this.originalYaml = this.yaml = this.resourceToYaml(resource);\n    }\n    this.resource = resource;\n    this.formView = view;\n  }\n\n  cancel(escape?: boolean) {\n    this.interceptDeactivate.back(escape);\n  }\n\n  protected checkForm() {\n    this.ngForm.onSubmit(null);\n    if (this.formView === 'UI' && this.ngForm.invalid) {\n      return false;\n    }\n    if (this.formView === 'YAML') {\n      try {\n        this.resource = this.yamlToResource(this.yaml);\n        return true;\n      } catch {\n        return false;\n      }\n    }\n    const resource = this.form.get('resource').value as T;\n    this.resource = this.fillResource(resource);\n\n    return true;\n  }\n\n  protected yamlToResource(yaml: string): T {\n    try {\n      const all = parseAll(yaml);\n      return (Array.isArray(this.resource) ? all : all[0]) as T;\n    } catch (e) {\n      if (isErrorMessage(e)) {\n        this.notification.error(e.message);\n      }\n      throw e;\n    }\n  }\n\n  protected resourceToYaml(resource: T) {\n    try {\n      if (Array.isArray(resource)) {\n        return resource\n          .map(r => stringify(r, { blockQuote: 'literal' }))\n          .join('\\n---\\r\\n\\n');\n      }\n      return stringify(resource, { blockQuote: 'literal' });\n    } catch (error) {\n      console.error(error);\n      return '{}';\n    }\n  }\n\n  protected updateResource(resource: T) {\n    this.form.patchValue({ resource });\n    this.resource = resource;\n  }\n}\n"]}

package/esm2022/form/base-nested-form-control.mjs

@@ -0,0 +1,190 @@
+import { coerceAttrBoolean } from '@alauda/ui';
+import { ChangeDetectorRef, Directive, inject, Input, QueryList, ViewChildren, } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm, } from '@angular/forms';
+import { assocPath, identity, mergeDeepRight, path } from 'ramda';
+import { ReplaySubject, startWith, switchMap, Subject, takeUntil, debounceTime, merge, combineLatest, filter, map, tap, take, of, } from 'rxjs';
+import * as i0 from "@angular/core";
+export function createNestedFormControl({ autoEmitChange = false, asyncValidator = false, } = {}) {
+    return class NestedFormControl extends BaseNestedFormControl {
+        constructor() {
+            super(...arguments);
+            this.autoEmitChange = autoEmitChange;
+            this.asyncValidator = asyncValidator;
+        }
+    };
+}
+export class BaseNestedFormControl {
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(val) {
+        this._disabled = coerceAttrBoolean(val);
+    }
+    constructor() {
+        this._disabled = false;
+        this.model = null;
+        this.submitted = false;
+        this.autoEmitChange = false;
+        this.asyncValidator = false;
+        this.cdr = inject(ChangeDetectorRef);
+        this.destroy$$ = new Subject();
+        this.hostForm = inject(NgForm, { optional: true }) ??
+            inject(FormGroupDirective, { optional: true });
+        if (this.hostForm) {
+            this.hostForm.ngSubmit.pipe(takeUntil(this.destroy$$)).subscribe(() => {
+                this.submitted = this.hostForm.submitted;
+                this.onSubmitted?.();
+                this.cdr.markForCheck();
+            });
+        }
+    }
+    ngAfterViewInit() {
+        this.controls.changes
+            .pipe(startWith(this.controls), switchMap((controls) => controls.length
+            ? merge(...controls.toArray().map(control => control.statusChanges)).pipe(startWith(null))
+            : of(null)), debounceTime(0))
+            .subscribe(() => {
+            this.onValidatorChange?.();
+        });
+        if (this.autoEmitChange) {
+            this.controls.changes
+                .pipe(startWith(this.controls), switchMap((controls) => merge(...controls.toArray().map(control => control.valueChanges))))
+                .pipe(debounceTime(0))
+                .subscribe(() => {
+                this.emitModel(this.model);
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        this.cdr.markForCheck();
+    }
+    writeValue(value) {
+        this.model = this.valueIn(value);
+        this.cdr.markForCheck();
+    }
+    validate(_control) {
+        const getErrors = () => this.controls?.reduce((acc, control) => {
+            if (control.errors) {
+                return mergeDeepRight(acc, control.name ? { [control.name]: control.errors } : control.errors);
+            }
+            return acc;
+        }, {});
+        return this.asyncValidator
+            ? combineLatest((this.controls?.toArray() ?? []).map(control => control.statusChanges.pipe(startWith(control.status)))).pipe(debounceTime(0), filter(statuses => statuses.includes('INVALID') || !statuses.includes('PENDING')), take(1), map(() => getErrors()), tap(() => {
+                this.cdr.markForCheck();
+            }))
+            : getErrors();
+    }
+    emitModel(model = this.model) {
+        this.model = model;
+        this.emitValue(this.modelOut(this.model));
+    }
+    emitValue(value) {
+        if (this.onChange) {
+            this.onChange(value);
+        }
+    }
+    valueIn(value) {
+        return value;
+    }
+    modelOut(model) {
+        return model;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseNestedFormControl, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: BaseNestedFormControl, inputs: { disabled: "disabled" }, viewQueries: [{ propertyName: "controls", predicate: NgControl, descendants: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseNestedFormControl, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [], propDecorators: { controls: [{
+                type: ViewChildren,
+                args: [NgControl]
+            }], disabled: [{
+                type: Input
+            }] } });
+/**
+ * @deprecated use {@link BaseNestedFormControl} instead.
+ */
+export class BaseNestedFormControlPure extends BaseNestedFormControl {
+    constructor() {
+        super();
+        this.model$ = new ReplaySubject(1);
+        this.model$.subscribe(model => {
+            this.model = model;
+            this.cdr.markForCheck();
+        });
+    }
+    writeValue(value) {
+        this.model$.next(this.valueIn(value));
+    }
+    emitValue(value) {
+        if (this.onChange) {
+            this.onChange(value);
+            this.writeValue(value);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseNestedFormControlPure, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: BaseNestedFormControlPure, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseNestedFormControlPure, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [] });
+function collectPaths(mapper, parent) {
+    return Object.entries(mapper).reduce((acc, [key, value]) => {
+        const path = typeof value === 'string' ? value.split('.') : value;
+        if (Array.isArray(path)) {
+            acc.push([parent.concat(key), path]);
+            return acc;
+        }
+        return acc.concat(collectPaths(path, parent.concat(key)));
+    }, []);
+}
+export function dataTransfer(mapper) {
+    const tuples = collectPaths(mapper, []);
+    let _source;
+    let _target = {};
+    return [
+        source => {
+            _source = source;
+            return tuples.reduce((acc, [left, right]) => {
+                const newValue = path(right, source);
+                if (path(left, acc) === newValue) {
+                    return acc;
+                }
+                return (_target = assocPath(left, newValue, acc));
+            }, _target);
+        },
+        target => {
+            _target = target;
+            return tuples.reduce((acc, [left, right]) => {
+                const newValue = path(left, target);
+                if (path(right, acc) === newValue) {
+                    return acc;
+                }
+                return (_source = assocPath(right, newValue, acc));
+            }, _source);
+        },
+    ];
+}
+function parsePath(path) {
+    return typeof path === 'string' ? path.split('.') : path;
+}
+export function copyValue(from, to, mapper = identity) {
+    const fromPath = parsePath(from);
+    const toPath = parsePath(to);
+    return (object) => assocPath(toPath, mapper(path(fromPath, object)), object);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-nested-form-control.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/form/base-nested-form-control.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceAttrBoolean } from '@alauda/ui';\nimport {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Directive,\n  inject,\n  Input,\n  OnDestroy,\n  QueryList,\n  ViewChildren,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  FormGroupDirective,\n  NgControl,\n  NgForm,\n  ValidationErrors,\n} from '@angular/forms';\nimport { assocPath, identity, mergeDeepRight, path } from 'ramda';\nimport {\n  ReplaySubject,\n  startWith,\n  switchMap,\n  Subject,\n  takeUntil,\n  debounceTime,\n  merge,\n  Observable,\n  combineLatest,\n  filter,\n  map,\n  tap,\n  take,\n  of,\n} from 'rxjs';\n\nexport function createNestedFormControl<V, M = V>({\n  autoEmitChange = false,\n  asyncValidator = false,\n}: {\n  autoEmitChange?: boolean;\n  asyncValidator?: boolean;\n} = {}): // workaround: https://github.com/microsoft/TypeScript/issues/30355\nnew () => BaseNestedFormControl<V, M> {\n  return class NestedFormControl extends BaseNestedFormControl<V, M> {\n    protected override autoEmitChange = autoEmitChange;\n    protected override asyncValidator = asyncValidator;\n  };\n}\n\n@Directive()\nexport class BaseNestedFormControl<V, M = V>\n  implements AfterViewInit, OnDestroy, ControlValueAccessor\n{\n  @ViewChildren(NgControl)\n  protected controls: QueryList<NgControl>;\n\n  @Input()\n  get disabled() {\n    return this._disabled;\n  }\n\n  set disabled(val: boolean | '') {\n    this._disabled = coerceAttrBoolean(val);\n  }\n\n  private _disabled = false;\n\n  onValidatorChange: () => void;\n  onChange: (_: V) => void;\n  onTouched: () => void;\n  onSubmitted: () => void;\n\n  model: M = null;\n  submitted = false;\n\n  protected autoEmitChange = false;\n  protected asyncValidator = false;\n  protected cdr = inject(ChangeDetectorRef);\n  protected destroy$$ = new Subject<void>();\n  protected hostForm =\n    inject(NgForm, { optional: true }) ??\n    inject(FormGroupDirective, { optional: true });\n\n  constructor() {\n    if (this.hostForm) {\n      this.hostForm.ngSubmit.pipe(takeUntil(this.destroy$$)).subscribe(() => {\n        this.submitted = this.hostForm.submitted;\n        this.onSubmitted?.();\n        this.cdr.markForCheck();\n      });\n    }\n  }\n\n  ngAfterViewInit() {\n    this.controls.changes\n      .pipe(\n        startWith(this.controls),\n        switchMap((controls: QueryList<NgControl>) =>\n          controls.length\n            ? merge(\n                ...controls.toArray().map(control => control.statusChanges),\n              ).pipe(startWith(null))\n            : of(null),\n        ),\n        debounceTime(0),\n      )\n      .subscribe(() => {\n        this.onValidatorChange?.();\n      });\n\n    if (this.autoEmitChange) {\n      this.controls.changes\n        .pipe(\n          startWith(this.controls),\n          switchMap((controls: QueryList<NgControl>) =>\n            merge(...controls.toArray().map(control => control.valueChanges)),\n          ),\n        )\n        .pipe(debounceTime(0))\n        .subscribe(() => {\n          this.emitModel(this.model);\n        });\n    }\n  }\n\n  ngOnDestroy() {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  registerOnValidatorChange(fn: () => void) {\n    this.onValidatorChange = fn;\n  }\n\n  registerOnChange(fn: (_: V) => void) {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void) {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean) {\n    this.disabled = isDisabled;\n    this.cdr.markForCheck();\n  }\n\n  writeValue(value: V) {\n    this.model = this.valueIn(value);\n    this.cdr.markForCheck();\n  }\n\n  validate(\n    _control?: AbstractControl,\n  ): ValidationErrors | null | Observable<ValidationErrors | null> {\n    const getErrors = () =>\n      this.controls?.reduce((acc, control) => {\n        if (control.errors) {\n          return mergeDeepRight(\n            acc,\n            control.name ? { [control.name]: control.errors } : control.errors,\n          );\n        }\n        return acc;\n      }, {} as ValidationErrors);\n\n    return this.asyncValidator\n      ? combineLatest(\n          (this.controls?.toArray() ?? []).map(control =>\n            control.statusChanges.pipe(startWith(control.status)),\n          ),\n        ).pipe(\n          debounceTime(0),\n          filter(\n            statuses =>\n              statuses.includes('INVALID') || !statuses.includes('PENDING'),\n          ),\n          take(1),\n          map(() => getErrors()),\n          tap(() => {\n            this.cdr.markForCheck();\n          }),\n        )\n      : getErrors();\n  }\n\n  emitModel(model: M = this.model) {\n    this.model = model;\n    this.emitValue(this.modelOut(this.model));\n  }\n\n  emitValue(value: V) {\n    if (this.onChange) {\n      this.onChange(value);\n    }\n  }\n\n  protected valueIn(value: V): M {\n    return value as any;\n  }\n\n  protected modelOut(model: M): V {\n    return model as any;\n  }\n}\n\n/**\n * @deprecated use {@link BaseNestedFormControl} instead.\n */\n@Directive()\nexport class BaseNestedFormControlPure<V, M = V> extends BaseNestedFormControl<\n  V,\n  M\n> {\n  model$ = new ReplaySubject<M>(1);\n\n  constructor() {\n    super();\n\n    this.model$.subscribe(model => {\n      this.model = model;\n      this.cdr.markForCheck();\n    });\n  }\n\n  override writeValue(value: V) {\n    this.model$.next(this.valueIn(value));\n  }\n\n  override emitValue(value: V) {\n    if (this.onChange) {\n      this.onChange(value);\n      this.writeValue(value);\n    }\n  }\n}\n\ntype Path = string | Array<string | number>;\n\ninterface Mapper {\n  [x: string]: Mapper | Path;\n}\n\ntype PathTuple = [string[], string[]];\n\nfunction collectPaths(mapper: Mapper, parent: string[]): PathTuple[] {\n  return Object.entries(mapper).reduce((acc, [key, value]) => {\n    const path = typeof value === 'string' ? value.split('.') : value;\n    if (Array.isArray(path)) {\n      acc.push([parent.concat(key), path]);\n      return acc;\n    }\n    return acc.concat(collectPaths(path, parent.concat(key)));\n  }, []);\n}\n\nexport function dataTransfer<\n  S extends object,\n  T extends object,\n  M extends Record<keyof T, Path | Mapper> = Record<keyof T, Path | Mapper>,\n>(mapper: M): [(source: S) => T, (target: T) => S] {\n  const tuples = collectPaths(mapper, []);\n  let _source: S;\n  let _target: T = {} as T;\n  return [\n    source => {\n      _source = source;\n      return tuples.reduce((acc, [left, right]) => {\n        const newValue = path<unknown>(right, source);\n\n        if (path(left, acc) === newValue) {\n          return acc;\n        }\n\n        return (_target = assocPath<unknown, T>(left, newValue, acc));\n      }, _target);\n    },\n    target => {\n      _target = target;\n      return tuples.reduce((acc, [left, right]) => {\n        const newValue = path<unknown>(left, target);\n\n        if (path(right, acc) === newValue) {\n          return acc;\n        }\n\n        return (_source = assocPath<unknown, S>(right, newValue, acc));\n      }, _source);\n    },\n  ];\n}\n\nfunction parsePath(path: Path): Array<string | number> {\n  return typeof path === 'string' ? path.split('.') : path;\n}\n\nexport function copyValue<T extends object>(\n  from: Path,\n  to: Path,\n  mapper: (v: any) => any = identity,\n) {\n  const fromPath = parsePath(from);\n  const toPath = parsePath(to);\n  return (object: T) =>\n    assocPath(toPath, mapper(path(fromPath, object)), object);\n}\n"]}

package/esm2022/form/errors-mapper/base-errors-mapper.mjs

@@ -0,0 +1,41 @@
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { Directive, Injector } from '@angular/core';
+import { DefaultErrorsMapperService } from './default-errors-mapper.service';
+import * as i0 from "@angular/core";
+export class BaseErrorsMapper {
+    getErrorMessage(errors, errorsMapper, errorsMapperFn, namePrefix, ignoreUnknownError = false) {
+        const firstError = Object.keys(errors || {})[0];
+        if (!firstError) {
+            return;
+        }
+        if (errorsMapper?.[firstError]) {
+            return errorsMapper[firstError];
+        }
+        if (errorsMapperFn) {
+            const res = errorsMapperFn(errors);
+            if (res) {
+                return res;
+            }
+        }
+        // only required error should be modified
+        if (namePrefix && firstError === 'required') {
+            return this.translate.get('required_item', { name: namePrefix });
+        }
+        const definedError = this.mapperService.map(firstError, errors[firstError]);
+        return definedError
+            ? (namePrefix || '') + definedError
+            : ignoreUnknownError
+                ? ''
+                : this.translate.get('the_value_is_invalid');
+    }
+    constructor(injector) {
+        this.translate = injector.get(TranslateService);
+        this.mapperService = injector.get(DefaultErrorsMapperService);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseErrorsMapper, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: BaseErrorsMapper, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseErrorsMapper, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.Injector }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form/errors-mapper/default-errors-mapper.service.mjs

@@ -0,0 +1,65 @@
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda-fe/dynamic-plugin-sdk";
+export class DefaultErrorsMapperService {
+    constructor(translate) {
+        this.translate = translate;
+    }
+    map(key, error) {
+        switch (key) {
+            case 'required': {
+                return this.translate.get('field_required');
+            }
+            case 'pattern': {
+                return this.translate.get('invalid_pattern');
+            }
+            case 'minlength': {
+                return this.translate.get('warning_min_length', {
+                    length: error.requiredLength,
+                });
+            }
+            case 'maxlength': {
+                return this.translate.get('warning_max_length', {
+                    length: error.requiredLength,
+                });
+            }
+            case 'min': {
+                return this.translate.get('warning_min', {
+                    value: error.min,
+                });
+            }
+            case 'max': {
+                return this.translate.get('warning_max', {
+                    value: error.max,
+                });
+            }
+            case 'number': {
+                return this.translate.get('invalid_number');
+            }
+            case 'includes': {
+                return this.translate.get('option_has_expired');
+            }
+            case 'dropdown_min_length': {
+                return this.translate.get('dropdown_min_length', {
+                    length: error.minLength,
+                });
+            }
+            case 'dropdown_max_length': {
+                return this.translate.get('dropdown_max_length', {
+                    length: error.maxLength,
+                });
+            }
+            default: {
+                return '';
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DefaultErrorsMapperService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DefaultErrorsMapperService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DefaultErrorsMapperService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/form/errors-mapper/errors-mapper-component/component.mjs

@@ -0,0 +1,53 @@
+import { __decorate, __metadata } from "tslib";
+import { AsyncPipe, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Input, ViewEncapsulation, } from '@angular/core';
+import { Observable, combineLatest, distinctUntilChanged, map, startWith, } from 'rxjs';
+import { ObservableInput, publishRef } from '../../../utils';
+import { BaseErrorsMapper } from '../base-errors-mapper';
+import * as i0 from "@angular/core";
+export class ErrorsMapperComponent extends BaseErrorsMapper {
+    constructor() {
+        super(...arguments);
+        this.ignoreUnknownError = false;
+        this.errorMessage$ = combineLatest([
+            this.errors$,
+            this.errorsMapper$,
+            this.errorsMapperFn$,
+            this.controlName$.pipe(startWith('')),
+            this.translate.locale$,
+        ]).pipe(map(([errors, errorsMapper, errorsMapperFn, name]) => this.getErrorMessage(errors, errorsMapper, errorsMapperFn, name, this.ignoreUnknownError)), distinctUntilChanged(), publishRef());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ErrorsMapperComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: ErrorsMapperComponent, isStandalone: true, selector: "acl-errors-mapper", inputs: { errors: "errors", errorsMapper: "errorsMapper", errorsMapperFn: "errorsMapperFn", controlName: "controlName", ignoreUnknownError: "ignoreUnknownError" }, usesInheritance: true, ngImport: i0, template: "<span\n  *ngIf=\"errors$ | async\"\n  class=\"acl-error-hint\"\n>\n  {{ errorMessage$ | async }}\n  <ng-content></ng-content>\n</span>\n", styles: ["acl-errors-mapper{display:block;color:rgb(var(--aui-color-red));font-size:var(--aui-font-size-s);line-height:var(--aui-line-height-s);font-weight:var(--aui-font-weight-normal)}acl-errors-mapper .acl-error-hint{display:inline-block;margin-top:var(--aui-spacing-s)}.aui-form-item__error-wrapper acl-errors-mapper .acl-error-hint,.aui-form-item__hint-wrapper acl-errors-mapper .acl-error-hint{margin-top:0}\n"], dependencies: [{ kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperComponent.prototype, "errors$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperComponent.prototype, "errorsMapper$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperComponent.prototype, "errorsMapperFn$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], ErrorsMapperComponent.prototype, "controlName$", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ErrorsMapperComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'acl-errors-mapper', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, preserveWhitespaces: false, standalone: true, imports: [AsyncPipe, NgIf], template: "<span\n  *ngIf=\"errors$ | async\"\n  class=\"acl-error-hint\"\n>\n  {{ errorMessage$ | async }}\n  <ng-content></ng-content>\n</span>\n", styles: ["acl-errors-mapper{display:block;color:rgb(var(--aui-color-red));font-size:var(--aui-font-size-s);line-height:var(--aui-line-height-s);font-weight:var(--aui-font-weight-normal)}acl-errors-mapper .acl-error-hint{display:inline-block;margin-top:var(--aui-spacing-s)}.aui-form-item__error-wrapper acl-errors-mapper .acl-error-hint,.aui-form-item__hint-wrapper acl-errors-mapper .acl-error-hint{margin-top:0}\n"] }]
+        }], propDecorators: { errors: [{
+                type: Input
+            }], errors$: [], errorsMapper: [{
+                type: Input
+            }], errorsMapper$: [], errorsMapperFn: [{
+                type: Input
+            }], errorsMapperFn$: [], controlName: [{
+                type: Input
+            }], controlName$: [], ignoreUnknownError: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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