ngx-vest-forms
Version:
Opinionated template-driven forms library for Angular
175 lines • 28.8 kB
JavaScript
import { Directive, inject, input, Output } from '@angular/core';
import { NgForm, PristineChangeEvent, StatusChangeEvent, ValueChangeEvent, } from '@angular/forms';
import { debounceTime, distinctUntilChanged, filter, map, Observable, of, ReplaySubject, startWith, Subject, switchMap, take, takeUntil, tap, zip, } from 'rxjs';
import { toObservable } from '@angular/core/rxjs-interop';
import { cloneDeep, getAllFormErrors, mergeValuesAndRawValues, set, } from '../utils/form-utils';
import { validateShape } from '../utils/shape-validation';
import * as i0 from "@angular/core";
export class FormDirective {
constructor() {
this.ngForm = inject(NgForm, { self: true, optional: false });
/**
* The value of the form, this is needed for the validation part
*/
this.formValue = input(null);
/**
* Static vest suite that will be used to feed our angular validators
*/
this.suite = input(null);
/**
* The shape of our form model. This is a deep required version of the form model
* The goal is to add default values to the shape so when the template-driven form
* contains values that shouldn't be there (typo's) that the developer gets run-time
* errors in dev mode
*/
this.formShape = input(null);
/**
* Updates the validation config which is a dynamic object that will be used to
* trigger validations on the dependant fields
* Eg: ```typescript
* validationConfig = {
* 'passwords.password': ['passwords.confirmPassword']
* }
* ```
*
* This will trigger the updateValueAndValidity on passwords.confirmPassword every time the passwords.password gets a new value
*
* @param v
*/
this.validationConfig = input(null);
this.pending$ = this.ngForm.form.events.pipe(filter((v) => v instanceof StatusChangeEvent), map((v) => v.status), filter((v) => v === 'PENDING'), distinctUntilChanged());
/**
* Emits every time the form status changes in a state
* that is not PENDING
* We need this to assure that the form is in 'idle' state
*/
this.idle$ = this.ngForm.form.events.pipe(filter((v) => v instanceof StatusChangeEvent), map((v) => v.status), filter((v) => v !== 'PENDING'), distinctUntilChanged());
/**
* Triggered as soon as the form value changes
* Also every time Angular creates a new control or group
* It also contains the disabled values (raw values)
*/
this.formValueChange = this.ngForm.form.events.pipe(filter((v) => v instanceof ValueChangeEvent), map((v) => v.value), map(() => mergeValuesAndRawValues(this.ngForm.form)));
/**
* Emits an object with all the errors of the form
* every time a form control or form groups changes its status to valid or invalid
*/
this.errorsChange = this.ngForm.form.events.pipe(filter((v) => v instanceof StatusChangeEvent), map((v) => v.status), filter((v) => v !== 'PENDING'), map(() => getAllFormErrors(this.ngForm.form)));
/**
* Triggered as soon as the form becomes dirty
*/
this.dirtyChange = this.ngForm.form.events.pipe(filter((v) => v instanceof PristineChangeEvent), map((v) => !v.pristine), startWith(this.ngForm.form.dirty), distinctUntilChanged());
this.destroy$$ = new Subject();
/**
* Fired when the status of the root form changes.
*/
this.statusChanges$ = this.ngForm.form.statusChanges.pipe(startWith(this.ngForm.form.status), distinctUntilChanged());
/**
* Triggered When the form becomes valid but waits until the form is idle
*/
this.validChange = this.statusChanges$.pipe(filter((e) => e === 'VALID' || e === 'INVALID'), map((v) => v === 'VALID'), distinctUntilChanged());
/**
* Used to debounce formValues to make sure vest isn't triggered all the time
*/
this.formValueCache = {};
// When the validation config changes
// Listen to changes of the left-side of the config and trigger the updateValueAndValidity
// function on the dependant controls or groups at the right-side of the config
toObservable(this.validationConfig)
.pipe(filter((conf) => !!conf), switchMap((conf) => {
if (!conf) {
return of(null);
}
const streams = Object.keys(conf).map((key) => {
return this.ngForm?.form.get(key)?.valueChanges.pipe(
// Wait until something is pending
switchMap(() => this.pending$),
// Wait until the form is not pending anymore
switchMap(() => this.idle$), map(() => this.ngForm?.form.get(key)?.value), takeUntil(this.destroy$$), tap((v) => {
conf[key]?.forEach((path) => {
this.ngForm?.form.get(path)?.updateValueAndValidity({
onlySelf: true,
emitEvent: true,
});
});
}));
});
return zip(streams);
}))
.subscribe();
/**
* Trigger shape validations if the form gets updated
* This is how we can throw run-time errors
*/
this.formValueChange.pipe(takeUntil(this.destroy$$)).subscribe((v) => {
if (this.formShape()) {
validateShape(v, this.formShape());
}
});
/**
* Mark all the fields as touched when the form is submitted
*/
this.ngForm.ngSubmit.subscribe(() => {
this.ngForm.form.markAllAsTouched();
});
}
/**
* This will feed the formValueCache, debounce it till the next tick
* and create an asynchronous validator that runs a vest suite
* @param field
* @param validationOptions
* @returns an asynchronous validator function
*/
createAsyncValidator(field, validationOptions) {
if (!this.suite()) {
return () => of(null);
}
return (value) => {
if (!this.formValue()) {
return of(null);
}
const mod = cloneDeep(this.formValue());
set(mod, field, value); // Update the property with path
if (!this.formValueCache[field]) {
this.formValueCache[field] = {
sub$$: new ReplaySubject(1), // Keep track of the last model
};
this.formValueCache[field].debounced = this.formValueCache[field].sub$$.pipe(debounceTime(validationOptions.debounceTime));
}
// Next the latest model in the cache for a certain field
this.formValueCache[field].sub$$.next(mod);
return this.formValueCache[field].debounced.pipe(
// When debounced, take the latest value and perform the asynchronous vest validation
take(1), switchMap(() => {
return new Observable((observer) => {
this.suite()(mod, field).done((result) => {
const errors = result.getErrors()[field];
observer.next(errors ? { error: errors[0], errors } : null);
observer.complete();
});
});
}), takeUntil(this.destroy$$));
};
}
ngOnDestroy() {
this.destroy$$.next();
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: FormDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.0.1", type: FormDirective, isStandalone: true, selector: "form[scVestForm]", inputs: { formValue: { classPropertyName: "formValue", publicName: "formValue", isSignal: true, isRequired: false, transformFunction: null }, suite: { classPropertyName: "suite", publicName: "suite", isSignal: true, isRequired: false, transformFunction: null }, formShape: { classPropertyName: "formShape", publicName: "formShape", isSignal: true, isRequired: false, transformFunction: null }, validationConfig: { classPropertyName: "validationConfig", publicName: "validationConfig", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { formValueChange: "formValueChange", errorsChange: "errorsChange", dirtyChange: "dirtyChange", validChange: "validChange" }, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: FormDirective, decorators: [{
type: Directive,
args: [{
selector: 'form[scVestForm]',
standalone: true,
}]
}], ctorParameters: () => [], propDecorators: { formValueChange: [{
type: Output
}], errorsChange: [{
type: Output
}], dirtyChange: [{
type: Output
}], validChange: [{
type: Output
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.directive.js","sourceRoot":"","sources":["../../../../../projects/ngx-vest-forms/src/lib/directives/form.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, inject, input, OnDestroy, Output } from '@angular/core';\nimport {\n  AsyncValidatorFn,\n  NgForm,\n  PristineChangeEvent,\n  StatusChangeEvent,\n  ValidationErrors,\n  ValueChangeEvent,\n} from '@angular/forms';\nimport {\n  debounceTime,\n  distinctUntilChanged,\n  filter,\n  map,\n  Observable,\n  of,\n  ReplaySubject,\n  startWith,\n  Subject,\n  switchMap,\n  take,\n  takeUntil,\n  tap,\n  zip,\n} from 'rxjs';\nimport { StaticSuite } from 'vest';\nimport { toObservable } from '@angular/core/rxjs-interop';\nimport { DeepRequired } from '../utils/deep-required';\nimport {\n  cloneDeep,\n  getAllFormErrors,\n  mergeValuesAndRawValues,\n  set,\n} from '../utils/form-utils';\nimport { validateShape } from '../utils/shape-validation';\nimport { ValidationOptions } from './validation-options';\n\n@Directive({\n  selector: 'form[scVestForm]',\n  standalone: true,\n})\nexport class FormDirective<T extends Record<string, any>> implements OnDestroy {\n  public readonly ngForm = inject(NgForm, { self: true, optional: false });\n\n  /**\n   * The value of the form, this is needed for the validation part\n   */\n  public readonly formValue = input<T | null>(null);\n\n  /**\n   * Static vest suite that will be used to feed our angular validators\n   */\n  public readonly suite = input<StaticSuite<\n    string,\n    string,\n    (model: T, field: string) => void\n  > | null>(null);\n\n  /**\n   * The shape of our form model. This is a deep required version of the form model\n   * The goal is to add default values to the shape so when the template-driven form\n   * contains values that shouldn't be there (typo's) that the developer gets run-time\n   * errors in dev mode\n   */\n  public readonly formShape = input<DeepRequired<T> | null>(null);\n\n  /**\n   * Updates the validation config which is a dynamic object that will be used to\n   * trigger validations on the dependant fields\n   * Eg: ```typescript\n   * validationConfig = {\n   *     'passwords.password': ['passwords.confirmPassword']\n   * }\n   * ```\n   *\n   * This will trigger the updateValueAndValidity on passwords.confirmPassword every time the passwords.password gets a new value\n   *\n   * @param v\n   */\n  public readonly validationConfig = input<{ [key: string]: string[] } | null>(\n    null\n  );\n\n  private readonly pending$ = this.ngForm.form.events.pipe(\n    filter((v) => v instanceof StatusChangeEvent),\n    map((v) => (v as StatusChangeEvent).status),\n    filter((v) => v === 'PENDING'),\n    distinctUntilChanged()\n  );\n\n  /**\n   * Emits every time the form status changes in a state\n   * that is not PENDING\n   * We need this to assure that the form is in 'idle' state\n   */\n  public readonly idle$ = this.ngForm.form.events.pipe(\n    filter((v) => v instanceof StatusChangeEvent),\n    map((v) => (v as StatusChangeEvent).status),\n    filter((v) => v !== 'PENDING'),\n    distinctUntilChanged()\n  );\n\n  /**\n   * Triggered as soon as the form value changes\n   * Also every time Angular creates a new control or group\n   * It also contains the disabled values (raw values)\n   */\n  @Output() public readonly formValueChange = this.ngForm.form.events.pipe(\n    filter((v) => v instanceof ValueChangeEvent),\n    map((v) => (v as ValueChangeEvent<any>).value),\n    map(() => mergeValuesAndRawValues<T>(this.ngForm.form))\n  );\n\n  /**\n   * Emits an object with all the errors of the form\n   * every time a form control or form groups changes its status to valid or invalid\n   */\n  @Output() public readonly errorsChange = this.ngForm.form.events.pipe(\n    filter((v) => v instanceof StatusChangeEvent),\n    map((v) => (v as StatusChangeEvent).status),\n    filter((v) => v !== 'PENDING'),\n    map(() => getAllFormErrors(this.ngForm.form))\n  );\n\n  /**\n   * Triggered as soon as the form becomes dirty\n   */\n  @Output() public readonly dirtyChange = this.ngForm.form.events.pipe(\n    filter((v) => v instanceof PristineChangeEvent),\n    map((v) => !(v as PristineChangeEvent).pristine),\n    startWith(this.ngForm.form.dirty),\n    distinctUntilChanged()\n  );\n  private readonly destroy$$ = new Subject<void>();\n\n  /**\n   * Fired when the status of the root form changes.\n   */\n  private readonly statusChanges$ = this.ngForm.form.statusChanges.pipe(\n    startWith(this.ngForm.form.status),\n    distinctUntilChanged()\n  );\n\n  /**\n   * Triggered When the form becomes valid but waits until the form is idle\n   */\n  @Output() public readonly validChange = this.statusChanges$.pipe(\n    filter((e) => e === 'VALID' || e === 'INVALID'),\n    map((v) => v === 'VALID'),\n    distinctUntilChanged()\n  );\n\n  /**\n   * Used to debounce formValues to make sure vest isn't triggered all the time\n   */\n  private readonly formValueCache: {\n    [field: string]: Partial<{\n      sub$$: ReplaySubject<unknown>;\n      debounced: Observable<any>;\n    }>;\n  } = {};\n\n  public constructor() {\n    // When the validation config changes\n    // Listen to changes of the left-side of the config and trigger the updateValueAndValidity\n    // function on the dependant controls or groups at the right-side of the config\n    toObservable(this.validationConfig)\n      .pipe(\n        filter((conf) => !!conf),\n        switchMap((conf) => {\n          if (!conf) {\n            return of(null);\n          }\n          const streams = Object.keys(conf).map((key) => {\n            return this.ngForm?.form.get(key)?.valueChanges.pipe(\n              // Wait until something is pending\n              switchMap(() => this.pending$),\n              // Wait until the form is not pending anymore\n              switchMap(() => this.idle$),\n              map(() => this.ngForm?.form.get(key)?.value),\n              takeUntil(this.destroy$$),\n              tap((v) => {\n                conf[key]?.forEach((path: string) => {\n                  this.ngForm?.form.get(path)?.updateValueAndValidity({\n                    onlySelf: true,\n                    emitEvent: true,\n                  });\n                });\n              })\n            );\n          });\n          return zip(streams);\n        })\n      )\n      .subscribe();\n\n    /**\n     * Trigger shape validations if the form gets updated\n     * This is how we can throw run-time errors\n     */\n    this.formValueChange.pipe(takeUntil(this.destroy$$)).subscribe((v) => {\n      if (this.formShape()) {\n        validateShape(v, this.formShape() as DeepRequired<T>);\n      }\n    });\n\n    /**\n     * Mark all the fields as touched when the form is submitted\n     */\n    this.ngForm.ngSubmit.subscribe(() => {\n      this.ngForm.form.markAllAsTouched();\n    });\n  }\n\n  /**\n   * This will feed the formValueCache, debounce it till the next tick\n   * and create an asynchronous validator that runs a vest suite\n   * @param field\n   * @param validationOptions\n   * @returns an asynchronous validator function\n   */\n  public createAsyncValidator(field: string, validationOptions: ValidationOptions): AsyncValidatorFn {\n    if (!this.suite()) {\n      return () => of(null);\n    }\n    return (value: any) => {\n      if (!this.formValue()) {\n        return of(null);\n      }\n      const mod = cloneDeep(this.formValue() as T);\n      set(mod as object, field, value); // Update the property with path\n      if (!this.formValueCache[field]) {\n        this.formValueCache[field] = {\n          sub$$: new ReplaySubject(1), // Keep track of the last model\n        };\n        this.formValueCache[field].debounced = this.formValueCache[\n          field\n          ].sub$$!.pipe(debounceTime(validationOptions.debounceTime));\n      }\n      // Next the latest model in the cache for a certain field\n      this.formValueCache[field].sub$$!.next(mod);\n\n      return this.formValueCache[field].debounced!.pipe(\n        // When debounced, take the latest value and perform the asynchronous vest validation\n        take(1),\n        switchMap(() => {\n          return new Observable((observer) => {\n            this.suite()!(mod, field).done((result) => {\n              const errors = result.getErrors()[field];\n              observer.next(errors ? { error: errors[0], errors } : null);\n              observer.complete();\n            });\n          }) as Observable<ValidationErrors | null>;\n        }),\n        takeUntil(this.destroy$$)\n      );\n    };\n  }\n\n  public ngOnDestroy(): void {\n    this.destroy$$.next();\n  }\n}\n"]}