@dereekb/dbx-form 0.0.1

package/esm2020/lib/formly/field/wrapper/subsection.wrapper.component.mjs

@@ -0,0 +1,35 @@
+import { Component } from '@angular/core';
+import { FieldWrapper } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@dereekb/dbx-web";
+import * as i2 from "@angular/common";
+export class FormSubsectionWrapperComponent extends FieldWrapper {
+    get description() {
+        return this.to.description;
+    }
+}
+FormSubsectionWrapperComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: FormSubsectionWrapperComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+FormSubsectionWrapperComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: FormSubsectionWrapperComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <div class="form-section form-subsection">
+      <h4>{{ to.label }}</h4>
+      <div class="form-section-content">
+        <ng-container #fieldComponent></ng-container>
+      </div>
+      <dbx-hint *ngIf="description"><small>{{ description }}</small></dbx-hint>
+    </div>
+  `, isInline: true, components: [{ type: i1.DbxHintComponent, selector: "dbx-hint" }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: FormSubsectionWrapperComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <div class="form-section form-subsection">
+      <h4>{{ to.label }}</h4>
+      <div class="form-section-content">
+        <ng-container #fieldComponent></ng-container>
+      </div>
+      <dbx-hint *ngIf="description"><small>{{ description }}</small></dbx-hint>
+    </div>
+  `
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Vic2VjdGlvbi53cmFwcGVyLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1mb3JtL3NyYy9saWIvZm9ybWx5L2ZpZWxkL3dyYXBwZXIvc3Vic2VjdGlvbi53cmFwcGVyLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTFDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQzs7OztBQWFoRCxNQUFNLE9BQU8sOEJBQStCLFNBQVEsWUFBWTtJQUU5RCxJQUFJLFdBQVc7UUFDYixPQUFPLElBQUksQ0FBQyxFQUFFLENBQUMsV0FBVyxDQUFDO0lBQzdCLENBQUM7OzJIQUpVLDhCQUE4QjsrR0FBOUIsOEJBQThCLDJFQVYvQjs7Ozs7Ozs7R0FRVDsyRkFFVSw4QkFBOEI7a0JBWDFDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFOzs7Ozs7OztHQVFUO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNYXliZSB9IGZyb20gJ0BkZXJlZWtiL3V0aWwnO1xuaW1wb3J0IHsgRmllbGRXcmFwcGVyIH0gZnJvbSAnQG5neC1mb3JtbHkvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICB0ZW1wbGF0ZTogYFxuICAgIDxkaXYgY2xhc3M9XCJmb3JtLXNlY3Rpb24gZm9ybS1zdWJzZWN0aW9uXCI+XG4gICAgICA8aDQ+e3sgdG8ubGFiZWwgfX08L2g0PlxuICAgICAgPGRpdiBjbGFzcz1cImZvcm0tc2VjdGlvbi1jb250ZW50XCI+XG4gICAgICAgIDxuZy1jb250YWluZXIgI2ZpZWxkQ29tcG9uZW50PjwvbmctY29udGFpbmVyPlxuICAgICAgPC9kaXY+XG4gICAgICA8ZGJ4LWhpbnQgKm5nSWY9XCJkZXNjcmlwdGlvblwiPjxzbWFsbD57eyBkZXNjcmlwdGlvbiB9fTwvc21hbGw+PC9kYngtaGludD5cbiAgICA8L2Rpdj5cbiAgYFxufSlcbmV4cG9ydCBjbGFzcyBGb3JtU3Vic2VjdGlvbldyYXBwZXJDb21wb25lbnQgZXh0ZW5kcyBGaWVsZFdyYXBwZXIge1xuXG4gIGdldCBkZXNjcmlwdGlvbigpOiBNYXliZTxzdHJpbmc+IHtcbiAgICByZXR1cm4gdGhpcy50by5kZXNjcmlwdGlvbjtcbiAgfVxuXG59XG4iXX0=

package/esm2020/lib/formly/field/wrapper/toggle.wrapper.component.mjs

@@ -0,0 +1,58 @@
+import { Component } from '@angular/core';
+import { of } from 'rxjs';
+import { first, shareReplay, switchMap } from 'rxjs/operators';
+import { AbstractFormExpandableSectionWrapperDirective } from './expandable.wrapper.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/slide-toggle";
+import * as i2 from "@angular/common";
+/**
+ * Section that is expandable by a button until a value is set, or the button is pressed.
+ */
+export class FormToggleSectionWrapperComponent extends AbstractFormExpandableSectionWrapperDirective {
+    constructor() {
+        super(...arguments);
+        this.$slideLabel = this._toggleOpen.pipe(switchMap(x => {
+            if (this.toggleSection?.toggleLabelObs) {
+                return this.toggleSection?.toggleLabelObs(x);
+            }
+            else {
+                return of(this.expandLabel);
+            }
+        }), shareReplay(1));
+    }
+    get toggleSection() {
+        return this.to.toggleSection;
+    }
+    onToggleChange() {
+        this.show$.pipe(first()).subscribe((show) => {
+            this._toggleOpen.next(!show);
+        });
+    }
+}
+FormToggleSectionWrapperComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: FormToggleSectionWrapperComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+FormToggleSectionWrapperComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: FormToggleSectionWrapperComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+  <div class="form-toggle-wrapper" [ngSwitch]="show$ | async">
+    <div class="form-toggle-wrapper-toggle">
+      <mat-slide-toggle [checked]="show$ | async" (toggleChange)="onToggleChange()">{{ $slideLabel | async }}</mat-slide-toggle>
+    </div>
+    <ng-container *ngSwitchCase="true">
+      <ng-container #fieldComponent></ng-container>
+    </ng-container>
+  </div>
+  `, isInline: true, components: [{ type: i1.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["disabled", "disableRipple", "color", "tabIndex", "name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "checked"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }], directives: [{ type: i2.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i2.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }], pipes: { "async": i2.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: FormToggleSectionWrapperComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+  <div class="form-toggle-wrapper" [ngSwitch]="show$ | async">
+    <div class="form-toggle-wrapper-toggle">
+      <mat-slide-toggle [checked]="show$ | async" (toggleChange)="onToggleChange()">{{ $slideLabel | async }}</mat-slide-toggle>
+    </div>
+    <ng-container *ngSwitchCase="true">
+      <ng-container #fieldComponent></ng-container>
+    </ng-container>
+  </div>
+  `
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/formly/field/wrapper/toggle.wrapper.mjs

@@ -0,0 +1,10 @@
+import { concatArraysUnique } from '@dereekb/util';
+export function addToggleWrapperToField({ fieldConfig, toggleSection = {} }) {
+    fieldConfig.wrappers = concatArraysUnique(fieldConfig.wrappers, ['toggle']);
+    fieldConfig.templateOptions = {
+        ...fieldConfig.templateOptions,
+        toggleSection
+    };
+    return fieldConfig;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9nZ2xlLndyYXBwZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZm9ybS9zcmMvbGliL2Zvcm1seS9maWVsZC93cmFwcGVyL3RvZ2dsZS53cmFwcGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQU9uRCxNQUFNLFVBQVUsdUJBQXVCLENBQUMsRUFBRSxXQUFXLEVBQUUsYUFBYSxHQUFHLEVBQUUsRUFBMkI7SUFDbEcsV0FBVyxDQUFDLFFBQVEsR0FBRyxrQkFBa0IsQ0FBQyxXQUFXLENBQUMsUUFBUSxFQUFFLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQztJQUM1RSxXQUFXLENBQUMsZUFBZSxHQUFHO1FBQzVCLEdBQUcsV0FBVyxDQUFDLGVBQWU7UUFDOUIsYUFBYTtLQUNkLENBQUM7SUFDRixPQUFPLFdBQVcsQ0FBQztBQUNyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRm9ybWx5RmllbGRDb25maWcgfSBmcm9tICdAbmd4LWZvcm1seS9jb3JlJztcbmltcG9ydCB7IEZvcm1Ub2dnbGVTZWN0aW9uQ29uZmlnIH0gZnJvbSAnLi90b2dnbGUud3JhcHBlci5jb21wb25lbnQnO1xuaW1wb3J0IHsgY29uY2F0QXJyYXlzVW5pcXVlIH0gZnJvbSAnQGRlcmVla2IvdXRpbCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRm9ybVRvZ2dsZVdyYXBwZXJDb25maWcge1xuICBmaWVsZENvbmZpZzogRm9ybWx5RmllbGRDb25maWc7XG4gIHRvZ2dsZVNlY3Rpb24/OiBGb3JtVG9nZ2xlU2VjdGlvbkNvbmZpZztcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGFkZFRvZ2dsZVdyYXBwZXJUb0ZpZWxkKHsgZmllbGRDb25maWcsIHRvZ2dsZVNlY3Rpb24gPSB7fSB9OiBGb3JtVG9nZ2xlV3JhcHBlckNvbmZpZyk6IEZvcm1seUZpZWxkQ29uZmlnIHtcbiAgZmllbGRDb25maWcud3JhcHBlcnMgPSBjb25jYXRBcnJheXNVbmlxdWUoZmllbGRDb25maWcud3JhcHBlcnMsIFsndG9nZ2xlJ10pO1xuICBmaWVsZENvbmZpZy50ZW1wbGF0ZU9wdGlvbnMgPSB7XG4gICAgLi4uZmllbGRDb25maWcudGVtcGxhdGVPcHRpb25zLFxuICAgIHRvZ2dsZVNlY3Rpb25cbiAgfTtcbiAgcmV0dXJuIGZpZWxkQ29uZmlnO1xufVxuIl19

package/esm2020/lib/formly/formly.component.mjs

@@ -0,0 +1,134 @@
+import { distinctUntilChanged } from 'rxjs/operators';
+import { Component, NgZone } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { BehaviorSubject } from 'rxjs';
+import { debounceTime, startWith } from 'rxjs/operators';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbxFormState } from '../form/form';
+import { DbxFormlyContext } from './formly.context';
+import { cloneDeep } from 'lodash';
+import * as i0 from "@angular/core";
+import * as i1 from "./formly.context";
+import * as i2 from "@ngx-formly/core";
+import * as i3 from "@angular/forms";
+export class DbxFormlyComponent extends AbstractSubscriptionDirective {
+    constructor(context, ngZone) {
+        super();
+        this.context = context;
+        this.ngZone = ngZone;
+        this._changesCount = 0;
+        this._fields = [];
+        this._events = new BehaviorSubject({ isComplete: false, state: DbxFormState.INITIALIZING });
+        this.form = new FormGroup({});
+        this.model = {};
+        this.options = {};
+    }
+    ngOnInit() {
+        this.context.setDelegate(this);
+        this.sub = this.form.valueChanges.pipe(startWith(this.form.value), distinctUntilChanged(), debounceTime(50)).subscribe((_) => this._updateForChange());
+    }
+    ngOnDestroy() {
+        this.context.lockSet.onNextUnlock(() => {
+            super.ngOnDestroy();
+            this.context.clearDelegate(this);
+            this._events.complete();
+        });
+    }
+    get fields() {
+        return this._fields;
+    }
+    // MARK: Delegate
+    get isComplete() {
+        return this._events.value.isComplete;
+    }
+    get state() {
+        return this._events.value.state;
+    }
+    get stream$() {
+        return this._events.asObservable();
+    }
+    setFields(fields) {
+        this._fields = fields;
+    }
+    getValue() {
+        return this.form.value; // this.model
+    }
+    setValue(value) {
+        /*
+        if (value === this.model) {
+          return; // Ignore the same value being set.
+        }
+        */
+        this.model = cloneDeep(value);
+        if (this.options.updateInitialValue) {
+            this.options.updateInitialValue();
+            this.options.resetModel?.();
+        }
+        // Re-mark as untouched and pristine.
+        this.form.markAsUntouched();
+        this.form.markAsPristine();
+        this._lastResetAt = new Date();
+        this._changesCount = 0;
+        // After updating the value, if the form is still untouched mark it as pristine again.
+        // Sometimes the values get marked as changed and break pristine before a user has time to interact.
+        setTimeout(() => {
+            if (this.form.untouched) {
+                this.form.markAsPristine();
+            }
+        }, 500);
+    }
+    resetForm() {
+        if (this.options.resetModel) {
+            this.options.resetModel();
+        }
+    }
+    isDisabled() {
+        return this.form.disabled;
+    }
+    setDisabled(disabled = true) {
+        // console.log('setting disabled: ', disabled);
+        if (disabled) {
+            this.form.disable();
+        }
+        else {
+            this.form.enable();
+        }
+    }
+    // MARK: Update
+    forceFormUpdate() {
+        this._updateForChange();
+    }
+    _updateForChange() {
+        const complete = this.form.valid;
+        this._changesCount += 1;
+        const nextState = {
+            isComplete: complete,
+            state: (complete) ? DbxFormState.COMPLETE : DbxFormState.INCOMPLETE,
+            untouched: this.form.untouched,
+            pristine: this.form.pristine,
+            changesCount: this._changesCount,
+            lastResetAt: this._lastResetAt
+        };
+        this._events.next(nextState);
+    }
+}
+DbxFormlyComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormlyComponent, deps: [{ token: i1.DbxFormlyContext }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+DbxFormlyComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbxFormlyComponent, selector: "dbx-formly", exportAs: ["formly"], usesInheritance: true, ngImport: i0, template: `
+    <form [formGroup]="form" class="dbx-formly">
+      <formly-form [form]="form" [fields]="fields" [model]="model"></formly-form>
+    </form>
+  `, isInline: true, components: [{ type: i2.FormlyForm, selector: "formly-form", inputs: ["form", "model", "fields", "options"], outputs: ["modelChange"] }], directives: [{ type: i3.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormlyComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-formly',
+                    exportAs: 'formly',
+                    template: `
+    <form [formGroup]="form" class="dbx-formly">
+      <formly-form [form]="form" [fields]="fields" [model]="model"></formly-form>
+    </form>
+  `,
+                    // TODO: styleUrls: ['./form.scss'],
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DbxFormlyContext }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formly.component.js","sourceRoot":"","sources":["../../../../../../packages/dbx-form/src/lib/formly/formly.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { distinctUntilChanged } from 'rxjs/operators';\nimport { Component, NgZone, OnDestroy, OnInit } from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { FormlyFieldConfig, FormlyFormOptions } from '@ngx-formly/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { debounceTime, startWith } from 'rxjs/operators';\nimport { AbstractSubscriptionDirective } from '@dereekb/dbx-core';\nimport { DbxFormEvent, DbxFormState } from '../form/form';\nimport { DbxFormlyContext, DbxFormlyContextDelegate } from './formly.context';\nimport { cloneDeep } from 'lodash';\n\n@Component({\n  selector: 'dbx-formly',\n  exportAs: 'formly',\n  template: `\n    <form [formGroup]=\"form\" class=\"dbx-formly\">\n      <formly-form [form]=\"form\" [fields]=\"fields\" [model]=\"model\"></formly-form>\n    </form>\n  `,\n  // TODO: styleUrls: ['./form.scss'],\n})\nexport class DbxFormlyComponent<T extends object> extends AbstractSubscriptionDirective implements DbxFormlyContextDelegate<T>, OnInit, OnDestroy {\n\n  private _changesCount = 0;\n  private _lastResetAt?: Date;\n\n  private _fields: FormlyFieldConfig[] = [];\n  private _events = new BehaviorSubject<DbxFormEvent>({ isComplete: false, state: DbxFormState.INITIALIZING });\n\n  form = new FormGroup({});\n  model: any = {};\n  options: FormlyFormOptions = {};\n\n  constructor(private readonly context: DbxFormlyContext<T>, private readonly ngZone: NgZone) {\n    super();\n  }\n\n  ngOnInit(): void {\n    this.context.setDelegate(this);\n    this.sub = this.form.valueChanges.pipe(\n      startWith(this.form.value),\n      distinctUntilChanged(),\n      debounceTime(50)\n    ).subscribe((_) => this._updateForChange());\n  }\n\n  override ngOnDestroy(): void {\n    this.context.lockSet.onNextUnlock(() => {\n      super.ngOnDestroy();\n      this.context.clearDelegate(this);\n      this._events.complete();\n    });\n  }\n\n  get fields(): FormlyFieldConfig[] {\n    return this._fields;\n  }\n\n  // MARK: Delegate\n  get isComplete(): boolean {\n    return this._events.value.isComplete;\n  }\n\n  get state(): DbxFormState {\n    return this._events.value.state;\n  }\n\n  get stream$(): Observable<DbxFormEvent> {\n    return this._events.asObservable();\n  }\n\n  setFields(fields: FormlyFieldConfig[]): void {\n    this._fields = fields;\n  }\n\n  getValue(): T {\n    return this.form.value; // this.model\n  }\n\n  setValue(value: T): void {\n    /*\n    if (value === this.model) {\n      return; // Ignore the same value being set.\n    }\n    */\n\n    this.model = cloneDeep(value) as T;\n\n    if (this.options.updateInitialValue) {\n      this.options.updateInitialValue();\n      this.options.resetModel?.();\n    }\n\n    // Re-mark as untouched and pristine.\n    this.form.markAsUntouched();\n    this.form.markAsPristine();\n    this._lastResetAt = new Date();\n    this._changesCount = 0;\n\n    // After updating the value, if the form is still untouched mark it as pristine again.\n    // Sometimes the values get marked as changed and break pristine before a user has time to interact.\n    setTimeout(() => {\n      if (this.form.untouched) {\n        this.form.markAsPristine();\n      }\n    }, 500);\n  }\n\n  resetForm(): void {\n    if (this.options.resetModel) {\n      this.options.resetModel();\n    }\n  }\n\n  isDisabled(): boolean {\n    return this.form.disabled;\n  }\n\n  setDisabled(disabled = true): void {\n    // console.log('setting disabled: ', disabled);\n    if (disabled) {\n      this.form.disable();\n    } else {\n      this.form.enable();\n    }\n  }\n\n  // MARK: Update\n  forceFormUpdate(): void {\n    this._updateForChange();\n  }\n\n  private _updateForChange(): void {\n    const complete = this.form.valid;\n\n    this._changesCount += 1;\n\n    const nextState: DbxFormEvent = {\n      isComplete: complete,\n      state: (complete) ? DbxFormState.COMPLETE : DbxFormState.INCOMPLETE,\n      untouched: this.form.untouched,\n      pristine: this.form.pristine,\n      changesCount: this._changesCount,\n      lastResetAt: this._lastResetAt\n    };\n\n    this._events.next(nextState);\n  }\n\n}\n"]}

package/esm2020/lib/formly/formly.context.mjs

@@ -0,0 +1,111 @@
+import { BehaviorSubject, of } from 'rxjs';
+import { DbxForm, DbxFormState } from '../form/form';
+import { mergeMap } from 'rxjs/operators';
+import { LockSet } from '@dereekb/rxjs';
+/**
+ * Allows a directive to provide a formly context and form.
+ */
+export function ProvideFormlyContext() {
+    return [{
+            provide: DbxFormlyContext,
+            useClass: DbxFormlyContext
+        }, {
+            provide: DbxForm,
+            useExisting: DbxFormlyContext
+        }];
+}
+/**
+ * DbxForm Instance that registers a delegate and manages the state of that form/delegate.
+ */
+export class DbxFormlyContext {
+    constructor() {
+        this.lockSet = new LockSet();
+        this._disabled = false;
+        this._delegate = DbxFormlyContext.EMPTY_DELEGATE;
+        this._streamSubject = new BehaviorSubject(of(DbxFormlyContext.INITIAL_STATE));
+        this._stream$ = this._streamSubject.pipe(mergeMap((stream) => stream));
+    }
+    destroy() {
+        this._streamSubject.complete();
+    }
+    get isDestroyed() {
+        return this._streamSubject.isStopped;
+    }
+    setDelegate(delegate) {
+        this._delegate = delegate ?? DbxFormlyContext.EMPTY_DELEGATE;
+        this._streamSubject.next(this._delegate.stream$);
+        this._delegate.setFields(this._fields);
+        this._delegate.setValue(this._initialValue);
+        this._delegate.setDisabled(this._disabled);
+    }
+    clearDelegate(delegate) {
+        if (this._delegate === delegate && !this.isDestroyed) {
+            this.setDelegate(undefined);
+        }
+    }
+    get fields() {
+        return this._fields;
+    }
+    set fields(fields) {
+        this._fields = fields;
+        this._delegate.setFields(this._fields);
+    }
+    // MARK: FormComponent
+    get isComplete() {
+        return this._delegate.isComplete;
+    }
+    get state() {
+        return this._delegate.state;
+    }
+    get stream$() {
+        return this._stream$;
+    }
+    get value() {
+        return this._delegate.getValue();
+    }
+    setValue(value) {
+        this._initialValue = value;
+        this._delegate.setValue(value);
+    }
+    isDisabled() {
+        return this._delegate.isDisabled();
+    }
+    setDisabled(disabled = true) {
+        this._disabled = disabled;
+        this._delegate.setDisabled(disabled);
+    }
+    resetForm() {
+        this._delegate.resetForm();
+    }
+    forceFormUpdate() {
+        this._delegate.forceFormUpdate();
+    }
+}
+DbxFormlyContext.INITIAL_STATE = { isComplete: false, state: DbxFormState.INITIALIZING };
+DbxFormlyContext.EMPTY_DELEGATE = {
+    isComplete: false,
+    state: DbxFormState.INITIALIZING,
+    stream$: of(DbxFormlyContext.INITIAL_STATE),
+    setFields(fields) {
+        // Do nothing.
+    },
+    getValue() {
+        return undefined;
+    },
+    setValue(value) {
+        // Do nothing.
+    },
+    resetForm() {
+        // Do nothing.
+    },
+    forceFormUpdate() {
+        // Do nothing.
+    },
+    isDisabled() {
+        return false;
+    },
+    setDisabled(disabled) {
+        // Do nothing.
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formly.context.js","sourceRoot":"","sources":["../../../../../../packages/dbx-form/src/lib/formly/formly.context.ts"],"names":[],"mappings":"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","sourcesContent":["import { Provider, Type } from '@angular/core';\nimport { BehaviorSubject, Observable, of } from 'rxjs';\nimport { DbxForm, DbxFormEvent, DbxFormState, TypedDbxForm } from '../form/form';\nimport { FormlyFieldConfig } from '@ngx-formly/core';\nimport { mergeMap } from 'rxjs/operators';\nimport { LockSet } from '@dereekb/rxjs';\nimport { Maybe } from '@dereekb/util';\n\n/**\n * DbxFormlyContext delegate.\n * \n * This is usually the component or element that contains the form itself.\n */\nexport interface DbxFormlyContextDelegate<T = any> {\n  readonly isComplete: boolean;\n  readonly state: DbxFormState;\n  readonly stream$: Observable<DbxFormEvent>;\n  setFields(fields: Maybe<FormlyFieldConfig[]>): void;\n  getValue(): T;\n  setValue(value: Maybe<Partial<T>>): void;\n  resetForm(): void;\n  forceFormUpdate(): void;\n  isDisabled(): boolean;\n  setDisabled(disabled?: boolean): void;\n}\n\n/**\n * Allows a directive to provide a formly context and form.\n */\nexport function ProvideFormlyContext(): Provider[] {\n  return [{\n    provide: DbxFormlyContext,\n    useClass: DbxFormlyContext\n  }, {\n    provide: DbxForm,\n    useExisting: DbxFormlyContext\n  }];\n}\n\n/**\n * DbxForm Instance that registers a delegate and manages the state of that form/delegate.\n */\nexport class DbxFormlyContext<T> implements TypedDbxForm<T> {\n\n  readonly lockSet = new LockSet();\n\n  private static INITIAL_STATE = { isComplete: false, state: DbxFormState.INITIALIZING };\n\n  private static EMPTY_DELEGATE: DbxFormlyContextDelegate<any> = {\n    isComplete: false,\n    state: DbxFormState.INITIALIZING,\n    stream$: of(DbxFormlyContext.INITIAL_STATE),\n    setFields(fields: FormlyFieldConfig[]): void {\n      // Do nothing.\n    },\n    getValue(): any {\n      return undefined;\n    },\n    setValue(value: any): void {\n      // Do nothing.\n    },\n    resetForm(): void {\n      // Do nothing.\n    },\n    forceFormUpdate(): void {\n      // Do nothing.\n    },\n    isDisabled(): boolean {\n      return false;\n    },\n    setDisabled(disabled?: boolean): void {\n      // Do nothing.\n    }\n  };\n\n  private _fields?: Maybe<FormlyFieldConfig[]>;\n  private _initialValue?: Maybe<Partial<T>>;\n  private _disabled: boolean = false;\n\n  private _delegate: DbxFormlyContextDelegate<T> = DbxFormlyContext.EMPTY_DELEGATE;\n  private _streamSubject = new BehaviorSubject<Observable<DbxFormEvent>>(of(DbxFormlyContext.INITIAL_STATE));\n  private _stream$ = this._streamSubject.pipe(mergeMap((stream) => stream));\n\n  constructor() { }\n\n  destroy(): void {\n    this._streamSubject.complete();\n  }\n\n  get isDestroyed(): boolean {\n    return this._streamSubject.isStopped;\n  }\n\n  setDelegate(delegate?: DbxFormlyContextDelegate<T>): void {\n    this._delegate = delegate ?? DbxFormlyContext.EMPTY_DELEGATE;\n    this._streamSubject.next(this._delegate.stream$);\n    this._delegate.setFields(this._fields);\n    this._delegate.setValue(this._initialValue);\n    this._delegate.setDisabled(this._disabled);\n  }\n\n  clearDelegate(delegate: DbxFormlyContextDelegate<T>): void {\n    if (this._delegate === delegate && !this.isDestroyed) {\n      this.setDelegate(undefined);\n    }\n  }\n\n  get fields(): Maybe<FormlyFieldConfig[]> {\n    return this._fields;\n  }\n\n  set fields(fields: Maybe<FormlyFieldConfig[]>) {\n    this._fields = fields;\n    this._delegate.setFields(this._fields);\n  }\n\n  // MARK: FormComponent\n  get isComplete(): boolean {\n    return this._delegate.isComplete;\n  }\n\n  get state(): DbxFormState {\n    return this._delegate.state;\n  }\n\n  get stream$(): Observable<DbxFormEvent> {\n    return this._stream$;\n  }\n\n  get value(): T {\n    return this._delegate.getValue();\n  }\n\n  setValue(value: Partial<T>): void {\n    this._initialValue = value;\n    this._delegate.setValue(value);\n  }\n\n  isDisabled(): boolean {\n    return this._delegate.isDisabled();\n  }\n\n  setDisabled(disabled = true): void {\n    this._disabled = disabled;\n    this._delegate.setDisabled(disabled);\n  }\n\n  resetForm(): void {\n    this._delegate.resetForm();\n  }\n\n  forceFormUpdate(): void {\n    this._delegate.forceFormUpdate();\n  }\n\n}\n"]}

package/esm2020/lib/formly/formly.directive.mjs

@@ -0,0 +1,101 @@
+import { SubscriptionObject } from '@dereekb/rxjs';
+import { BehaviorSubject } from 'rxjs';
+import { Directive, Input } from '@angular/core';
+import { DbxFormlyContext } from './formly.context';
+import * as i0 from "@angular/core";
+import * as i1 from "./formly.context";
+/**
+ * Abstract component for wrapping a form.
+ */
+export class AbstractFormlyFormDirective {
+    constructor(context) {
+        this.context = context;
+    }
+    get disabled() {
+        return this.context.isDisabled();
+    }
+    set disabled(disabled) {
+        this.context.setDisabled(disabled);
+    }
+    ngOnDestroy() {
+        this.context.destroy();
+    }
+    // Utility Functions
+    getValue() {
+        return this.context.value;
+    }
+    setValue(value) {
+        this.context.setValue(value);
+    }
+    clearValue() {
+        this.setValue({});
+    }
+}
+AbstractFormlyFormDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractFormlyFormDirective, deps: [{ token: i1.DbxFormlyContext }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractFormlyFormDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractFormlyFormDirective, inputs: { disabled: "disabled" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractFormlyFormDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.DbxFormlyContext }]; }, propDecorators: { disabled: [{
+                type: Input
+            }] } });
+/**
+ * Abstract component for wrapping a form.
+ */
+export class AbstractSyncFormlyFormDirective extends AbstractFormlyFormDirective {
+    ngOnInit() {
+        this.context.fields = this.fields;
+    }
+}
+AbstractSyncFormlyFormDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractSyncFormlyFormDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractSyncFormlyFormDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractSyncFormlyFormDirective, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractSyncFormlyFormDirective, decorators: [{
+            type: Directive
+        }] });
+/**
+ * Abstract component for wrapping an asyncrhronously-configured form.
+ */
+export class AbstractAsyncFormlyFormDirective extends AbstractFormlyFormDirective {
+    constructor() {
+        super(...arguments);
+        this._fieldsSub = new SubscriptionObject();
+    }
+    ngOnInit() {
+        this._fieldsSub.subscription = this.fields$.subscribe((fields) => {
+            this.context.fields = fields;
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._fieldsSub.destroy();
+    }
+}
+AbstractAsyncFormlyFormDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractAsyncFormlyFormDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractAsyncFormlyFormDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractAsyncFormlyFormDirective, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractAsyncFormlyFormDirective, decorators: [{
+            type: Directive
+        }] });
+export class AbstractConfigAsyncFormlyFormDirective extends AbstractAsyncFormlyFormDirective {
+    constructor() {
+        super(...arguments);
+        this._config = new BehaviorSubject(undefined);
+        this.config$ = this._config.asObservable();
+    }
+    get config() {
+        return this._config.value;
+    }
+    set config(config) {
+        this._config.next(config);
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._config.complete();
+    }
+}
+AbstractConfigAsyncFormlyFormDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractConfigAsyncFormlyFormDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractConfigAsyncFormlyFormDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractConfigAsyncFormlyFormDirective, inputs: { config: "config" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractConfigAsyncFormlyFormDirective, decorators: [{
+            type: Directive
+        }], propDecorators: { config: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/formly/formly.module.mjs

@@ -0,0 +1,59 @@
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import { DbxFormlyComponent } from './formly.component';
+// import { FormComponentFieldComponent } from './fields/component/component.field.component';
+// import { DbxFormWrapperModule } from './fields/wrappers/form.wrapper.module';
+import { FormlyMatToggleModule } from '@ngx-formly/material/toggle';
+import { FormlyModule } from '@ngx-formly/core';
+import * as i0 from "@angular/core";
+export class DbxFormlyModule {
+}
+DbxFormlyModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormlyModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbxFormlyModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormlyModule, declarations: [DbxFormlyComponent], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        FormlyModule,
+        FormlyMatToggleModule], exports: [
+        // Modules (?)
+        FormsModule,
+        ReactiveFormsModule,
+        // DbxFormWrapperModule, // todo!
+        // Directives
+        DbxFormlyComponent] });
+DbxFormlyModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormlyModule, imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            FormlyModule,
+            FormlyMatToggleModule
+        ], 
+        // Modules (?)
+        FormsModule,
+        ReactiveFormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormlyModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        FormlyModule,
+                        FormlyMatToggleModule
+                    ],
+                    declarations: [
+                        DbxFormlyComponent,
+                        // FormComponentFieldComponent
+                    ],
+                    exports: [
+                        // Modules (?)
+                        FormsModule,
+                        ReactiveFormsModule,
+                        // DbxFormWrapperModule, // todo!
+                        // Directives
+                        DbxFormlyComponent,
+                        // FormComponentFieldComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/formly/index.mjs

@@ -0,0 +1,6 @@
+export * from './field';
+export * from './formly.context';
+export * from './formly.directive';
+export * from './formly.component';
+export * from './formly.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZm9ybS9zcmMvbGliL2Zvcm1seS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9maWVsZCc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm1seS5jb250ZXh0JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybWx5LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm1seS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtbHkubW9kdWxlJztcbiJdfQ==

package/esm2020/lib/index.mjs

@@ -0,0 +1,5 @@
+export * from './form';
+export * from './formly';
+export * from './layout';
+export * from './validator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZm9ybS9zcmMvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mb3JtJztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybWx5JztcbmV4cG9ydCAqIGZyb20gJy4vbGF5b3V0JztcbmV4cG9ydCAqIGZyb20gJy4vdmFsaWRhdG9yJztcbiJdfQ==

package/esm2020/lib/layout/form.layout.module.mjs

@@ -0,0 +1,26 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DbxFormSpacerComponent } from './form.spacer.component';
+import * as i0 from "@angular/core";
+export class DbxFormLayoutModule {
+}
+DbxFormLayoutModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormLayoutModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbxFormLayoutModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormLayoutModule, declarations: [DbxFormSpacerComponent], imports: [CommonModule], exports: [DbxFormSpacerComponent] });
+DbxFormLayoutModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormLayoutModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbxFormLayoutModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule
+                    ],
+                    declarations: [
+                        DbxFormSpacerComponent
+                    ],
+                    exports: [
+                        DbxFormSpacerComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS5sYXlvdXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZvcm0vc3JjL2xpYi9sYXlvdXQvZm9ybS5sYXlvdXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDOztBQWFqRSxNQUFNLE9BQU8sbUJBQW1COztnSEFBbkIsbUJBQW1CO2lIQUFuQixtQkFBbUIsaUJBTjVCLHNCQUFzQixhQUh0QixZQUFZLGFBTVosc0JBQXNCO2lIQUdiLG1CQUFtQixZQVZyQjtZQUNQLFlBQVk7U0FDYjsyRkFRVSxtQkFBbUI7a0JBWC9CLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFO3dCQUNQLFlBQVk7cUJBQ2I7b0JBQ0QsWUFBWSxFQUFFO3dCQUNaLHNCQUFzQjtxQkFDdkI7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLHNCQUFzQjtxQkFDdkI7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IERieEZvcm1TcGFjZXJDb21wb25lbnQgfSBmcm9tICcuL2Zvcm0uc3BhY2VyLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGVcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgRGJ4Rm9ybVNwYWNlckNvbXBvbmVudFxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgRGJ4Rm9ybVNwYWNlckNvbXBvbmVudFxuICBdXG59KVxuZXhwb3J0IGNsYXNzIERieEZvcm1MYXlvdXRNb2R1bGUgeyB9XG4iXX0=