@dereekb/dbx-form 0.0.1 → 1.0.0

package/lib/form/action/form.action.directive.d.ts

@@ -3,7 +3,7 @@ import { Observable } from 'rxjs';
 import { ActionContextStoreSourceInstance } from '@dereekb/dbx-core';
 import { ReadableError } from '@dereekb/util';
 import { LockSet } from '@dereekb/rxjs';
-import { DbxForm } from '../../form/form';
+import { DbxMutableForm } from '../../form/form';
 import * as i0 from "@angular/core";
 export interface DbxActionFormTriggerResult {
     value?: any;
@@ -20,7 +20,7 @@ export declare const APP_ACTION_FORM_DISABLED_KEY = "actionForm";
  * If the source is not considered modified, the trigger will be ignored.
  */
 export declare class DbxActionFormDirective<T = any> implements OnInit, OnDestroy {
-    readonly form: DbxForm;
+    readonly form: DbxMutableForm;
     readonly source: ActionContextStoreSourceInstance<object, any>;
     readonly lockSet: LockSet;
     /**
@@ -34,7 +34,7 @@ export declare class DbxActionFormDirective<T = any> implements OnInit, OnDestro
     appActionFormModified?: DbxActionFormModifiedFn<T>;
     private _triggeredSub;
     private _isCompleteSub;
-    constructor(form: DbxForm, source: ActionContextStoreSourceInstance<object, any>);
+    constructor(form: DbxMutableForm, source: ActionContextStoreSourceInstance<object, any>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     protected preCheckReadyValue(value: T): Observable<boolean>;

package/lib/form/action/form.action.module.d.ts

@@ -2,8 +2,8 @@ import * as i0 from "@angular/core";
 import * as i1 from "./form.action.directive";
 import * as i2 from "@angular/common";
 import * as i3 from "@angular/material/dialog";
-export declare class DbxFormlyActionModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormlyActionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormlyActionModule, [typeof i1.DbxActionFormDirective], [typeof i2.CommonModule, typeof i3.MatDialogModule], [typeof i1.DbxActionFormDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormlyActionModule>;
+export declare class DbxFormActionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormActionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormActionModule, [typeof i1.DbxActionFormDirective], [typeof i2.CommonModule, typeof i3.MatDialogModule], [typeof i1.DbxActionFormDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormActionModule>;
 }

package/lib/form/action/index.d.ts

@@ -1,2 +1,3 @@
+export * from './transition';
 export * from './form.action.module';
 export * from './form.action.directive';

package/lib/form/action/transition/form.action.transition.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./form.action.transition.safety.directive";
+import * as i2 from "@angular/common";
+export declare class DbxFormActionTransitionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormActionTransitionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormActionTransitionModule, [typeof i1.DbxActionFormSafetyDirective], [typeof i2.CommonModule], [typeof i1.DbxActionFormSafetyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormActionTransitionModule>;
+}

package/lib/form/action/transition/form.action.transition.safety.directive.d.ts

@@ -0,0 +1,20 @@
+import { ViewContainerRef } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { HookResult, Transition, TransitionService } from '@uirouter/core';
+import { ActionContextStoreSourceInstance } from '@dereekb/dbx-core';
+import { DbxActionTransitionSafetyType, DbxActionTransitionSafetyDirective } from '@dereekb/dbx-web';
+import { DbxActionFormDirective } from '../form.action.directive';
+import * as i0 from "@angular/core";
+/**
+ * Extension of DbxActionTransitionSafetyDirective that forces the form to update first.
+ *
+ * NOTE: Only works with UIRouter
+ */
+export declare class DbxActionFormSafetyDirective<T, O> extends DbxActionTransitionSafetyDirective<T, O> {
+    readonly appActionForm: DbxActionFormDirective<T>;
+    inputSafetyType?: DbxActionTransitionSafetyType;
+    constructor(appActionForm: DbxActionFormDirective<T>, source: ActionContextStoreSourceInstance<T, O>, transitionService: TransitionService, viewContainerRef: ViewContainerRef, dialog: MatDialog);
+    protected _handleOnBeforeTransition(transition: Transition): HookResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionFormSafetyDirective<any, any>, [{ host: true; }, null, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionFormSafetyDirective<any, any>, "[dbxActionFormSafety]", never, { "inputSafetyType": "dbxActionFormSafety"; }, {}, never>;
+}

package/lib/form/action/transition/index.d.ts

@@ -0,0 +1,2 @@
+export * from './form.action.transition.module';
+export * from './form.action.transition.safety.directive';

package/lib/form/form.d.ts

@@ -1,14 +1,14 @@
 import { Provider, Type } from '@angular/core';
 import { Observable } from 'rxjs';
 import { LockSet } from '@dereekb/rxjs';
+import { Maybe } from '@dereekb/util';
 /**
  * Current state of a DbxForm
  */
 export declare enum DbxFormState {
     INITIALIZING = -1,
-    INCOMPLETE = 0,
-    COMPLETE = 1,
-    RESET = 2
+    RESET = 0,
+    USED = 1
 }
 /**
  * DbxForm stream event
@@ -20,32 +20,43 @@ export interface DbxFormEvent {
     readonly untouched?: boolean;
     readonly lastResetAt?: Date;
     readonly changesCount?: number;
+    readonly isDisabled?: boolean;
 }
 /**
  * Form that has an event stream, value, and state items.
  */
-export declare abstract class DbxForm {
+export declare abstract class DbxForm<T = any> {
+    abstract readonly stream$: Observable<DbxFormEvent>;
+    /**
+     * Returns an observable that returns the current state of the form.
+     */
+    abstract getValue(): Observable<T>;
+}
+export declare abstract class DbxMutableForm<T = any> extends DbxForm<T> {
     /**
      * LockSet for the form.
      */
-    abstract readonly lockSet: LockSet;
+    abstract readonly lockSet?: LockSet;
     /**
-     * True if the form is complete/valid.
+     * Sets the initial value of the form, and resets the form.
+     *
+     * @param value
+     */
+    abstract setValue(value: Maybe<Partial<T>>): void;
+    /**
+     * Resets the form to the initial value.
      */
-    abstract readonly isComplete: boolean;
-    abstract readonly state: DbxFormState;
-    abstract readonly stream$: Observable<DbxFormEvent>;
-    abstract readonly value: any;
-    abstract setValue(value: any): void;
     abstract resetForm(): void;
+    /**
+     * Sets the form's disabled state.
+     *
+     * @param disabled
+     */
+    abstract setDisabled(disabled?: boolean): void;
+    /**
+     * Force the form to update itself as if it was changed.
+     */
     abstract forceFormUpdate(): void;
 }
-/**
- * A typed DbxForm
- */
-export interface TypedDbxForm<T> extends DbxForm {
-    readonly value: T;
-    setValue(value: T): void;
-    resetForm(): void;
-}
 export declare function ProvideDbxForm<S extends DbxForm>(sourceType: Type<S>): Provider[];
+export declare function ProvideDbxMutableForm<S extends DbxMutableForm>(sourceType: Type<S>): Provider[];

package/lib/form/form.module.d.ts

@@ -1,10 +1,9 @@
 import * as i0 from "@angular/core";
-import * as i1 from "./form.input.directive";
-import * as i2 from "./form.changes.directive";
-import * as i3 from "./loading/form.loading.directive";
-import * as i4 from "@angular/common";
+import * as i1 from "./action/transition/form.action.transition.module";
+import * as i2 from "./action/form.action.module";
+import * as i3 from "./io/form.io.module";
 export declare class DbxFormModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormModule, [typeof i1.DbxFormSourceDirective, typeof i2.DbxFormValueChangesDirective, typeof i3.DbxFormLoadingPairSourceDirective], [typeof i4.CommonModule], [typeof i1.DbxFormSourceDirective, typeof i2.DbxFormValueChangesDirective, typeof i3.DbxFormLoadingPairSourceDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormModule, never, never, [typeof i1.DbxFormActionTransitionModule, typeof i2.DbxFormActionModule, typeof i3.DbxFormIoModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormModule>;
 }

package/lib/form/index.d.ts

@@ -1,6 +1,4 @@
 export * from './action';
-export * from './loading';
-export * from './form.changes.directive';
-export * from './form.input.directive';
+export * from './io';
 export * from './form.module';
 export * from './form';

package/lib/form/{form.changes.directive.d.ts → io/form.changes.directive.d.ts}

@@ -1,6 +1,6 @@
 import { EventEmitter, OnInit } from '@angular/core';
 import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
-import { DbxForm } from './form';
+import { DbxForm } from '../form';
 import * as i0 from "@angular/core";
 /**
  * Used to see form value changes.

package/lib/form/{form.input.directive.d.ts → io/form.input.directive.d.ts}

@@ -1,13 +1,13 @@
 import { Observable } from 'rxjs';
 import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
-import { DbxForm } from '../form/form';
+import { DbxMutableForm } from '../form';
 import * as i0 from "@angular/core";
 /**
  * Used with a FormComponent to set the value based on the input value.
  */
 export declare class DbxFormSourceDirective<T extends object = any> extends AbstractSubscriptionDirective {
-    readonly form: DbxForm;
-    constructor(form: DbxForm);
+    readonly form: DbxMutableForm;
+    constructor(form: DbxMutableForm);
     /**
      * Sets a LoadingContext that is watched for the loading state.
      */

package/lib/form/io/form.io.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./form.input.directive";
+import * as i2 from "./form.changes.directive";
+import * as i3 from "./form.loading.directive";
+import * as i4 from "@angular/common";
+export declare class DbxFormIoModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormIoModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormIoModule, [typeof i1.DbxFormSourceDirective, typeof i2.DbxFormValueChangesDirective, typeof i3.DbxFormLoadingSourceDirective], [typeof i4.CommonModule], [typeof i1.DbxFormSourceDirective, typeof i2.DbxFormValueChangesDirective, typeof i3.DbxFormLoadingSourceDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormIoModule>;
+}

package/lib/form/io/form.loading.directive.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbxMutableForm } from '../../form/form';
+import { LoadingState } from '@dereekb/rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Used with a FormComponent to set the value from a LoadingState when the value is available.
+ */
+export declare class DbxFormLoadingSourceDirective<T extends object = any> extends AbstractSubscriptionDirective {
+    readonly form: DbxMutableForm;
+    constructor(form: DbxMutableForm);
+    /**
+     * Sets a LoadingContext that is watched for the loading state.
+     */
+    set obs(obs: Observable<LoadingState<T>>);
+    private _setObs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormLoadingSourceDirective<any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFormLoadingSourceDirective<any>, "[dbxFormLoadingSource]", never, { "obs": "dbxFormLoadingSource"; }, {}, never>;
+}

package/lib/form/io/index.d.ts

@@ -0,0 +1,4 @@
+export * from './form.loading.directive';
+export * from './form.changes.directive';
+export * from './form.input.directive';
+export * from './form.io.module';

package/lib/form.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./form/form.module";
+import * as i2 from "./formly/formly.module";
+import * as i3 from "./formly/field/form.field.module";
+export declare class DbxFormExtensionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormExtensionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormExtensionModule, never, never, [typeof i1.DbxFormModule, typeof i2.DbxFormlyModule, typeof i3.DbxFormFormlyFieldModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormExtensionModule>;
+}

package/lib/formly/config/index.d.ts

@@ -0,0 +1 @@
+export * from './validation';

package/lib/formly/config/validation.d.ts

@@ -0,0 +1,19 @@
+import { FieldTypeConfig } from '@ngx-formly/core';
+import { ValidationMessageOption } from '@ngx-formly/core/lib/models';
+export declare function minLengthValidationMessage(err: any, field: FieldTypeConfig): string;
+export declare function maxLengthValidationMessage(err: any, field: FieldTypeConfig): string;
+export declare function minValidationMessage(err: any, field: FieldTypeConfig): string;
+export declare function maxValidationMessage(err: any, field: FieldTypeConfig): string;
+export declare const REQUIRED_VALIDATION_MESSAGE: {
+    name: string;
+    message: string;
+};
+export declare const MIN_LENGTH_VALIDATION_MESSAGE: ValidationMessageOption;
+export declare const MAX_LENGTH_VALIDATION_MESSAGE: ValidationMessageOption;
+export declare const MIN_VALIDATION_MESSAGE: ValidationMessageOption;
+export declare const MAX_VALIDATION_MESSAGE: ValidationMessageOption;
+export declare const INVALID_PHONE_NUMBER_MESSAGE: {
+    name: string;
+    message: string;
+};
+export declare function defaultValidationMessages(): ValidationMessageOption[];

package/lib/formly/field/checklist/_checklist.scss

@@ -0,0 +1,76 @@
+@use '../../../style/theming';
+
+// MARK: Variables
+$dbx-checklist-item-spacing: 8px;
+
+// MARK: Mixin
+@mixin core() {
+
+  .dbx-checklist-item {
+    @include theming.elevation(1);
+    margin-bottom: 8px;
+
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    justify-content: left;
+
+    .dbx-checklist-item-check {
+      flex: auto 0 0;
+      // margin-right: $dbx-checklist-item-spacing;
+      padding: 12px;
+    }
+
+    .dbx-checklist-item-content-wrapper {
+      height: 100%;
+      width: 100%;
+    }
+
+    .dbx-checklist-item-content {
+      display: flex;
+      align-items: center;
+
+      min-height: 44px;
+      flex: auto 1 1;
+      padding: $dbx-checklist-item-spacing 0;
+      padding-left: $dbx-checklist-item-spacing;
+      border-left: 1px solid black;
+    }
+
+  }
+
+}
+
+@mixin color($theme-config) {}
+
+@mixin typography($typography-config) {
+
+  .dbx-default-checklist-item-field {
+
+    .item-label {
+      font-size: 1.35em;
+      line-height: 1.35em;
+    }
+
+    .item-sublabel {}
+
+    .item-description {}
+
+  }
+
+}
+
+@mixin theme($theme-config) {
+  @include theming.private-check-duplicate-theme-styles($theme-config, 'dbx-form-field-checklist') {
+    $color: theming.get-color-config($theme-config);
+    $typography: theming.get-typography-config($theme-config);
+
+    @if $color !=null {
+      @include color($theme-config);
+    }
+
+    @if $typography !=null {
+      @include typography($typography);
+    }
+  }
+}

package/lib/formly/field/checklist/checklist.field.d.ts

@@ -0,0 +1,45 @@
+import { Observable } from 'rxjs';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { ChecklistItemDisplayContent, ChecklistItemFieldDisplayContentObs } from './checklist.item';
+import { KeyValueTransformMap, Maybe } from '@dereekb/util';
+import { ChecklistItemFieldBuilderInput } from './checklist.item.field';
+export declare type ChecklistItemFieldDataSetFieldKey<D> = keyof D & string;
+export declare type ChecklistItemFieldDataSetFieldValueForKey<D, K extends keyof D = keyof D> = D[K];
+export declare type ChecklistType<D> = KeyValueTransformMap<D, boolean>;
+export declare type ChecklistItemFieldDataSetBuilderInput<D, T> = {
+    key: ChecklistItemFieldDataSetFieldKey<D>;
+} & ChecklistItemFieldBuilderInput<T>;
+export interface ChecklistItemFieldDataSetItem<D, T extends ChecklistType<D>> {
+    /**
+     * Key for the field.
+     */
+    key: ChecklistItemFieldDataSetFieldKey<T>;
+    /**
+     * Base field configuration to use.
+     */
+    field: ChecklistItemFieldBuilderInput<T>;
+}
+/**
+ * Used for building a set of configurations for a data-type object that has as second object that is used as a checklist.
+ */
+export declare class ChecklistItemFieldDataSetBuilder<D extends object, C extends ChecklistType<D> = ChecklistType<D>> {
+    readonly dataObs: Observable<D>;
+    private _fields;
+    readonly dataObs$: Observable<D>;
+    constructor(dataObs: Observable<D>);
+    /**
+     * Merges the input config with existing configuration.
+     *
+     * The displayContentObs, if provided, will merge with the existing observable and the two objects merged.
+     */
+    merge<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>): void;
+    override<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>): void;
+    _assertFieldExists(key: ChecklistItemFieldDataSetFieldKey<D>): ChecklistItemFieldDataSetItem<D, any>;
+    showValueFieldArrayCount<T extends ChecklistItemFieldDataSetFieldValueForKey<D> & Array<any>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>): void;
+    showValueField<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>, labelFn?: (value: T) => Maybe<string>): void;
+    field<T>(config: ChecklistItemFieldDataSetBuilderInput<D, T>): void;
+    build(): FormlyFieldConfig[];
+    customContentFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(mapFn: (data: D) => ChecklistItemDisplayContent): ChecklistItemFieldDisplayContentObs<T>;
+    contentWithValueFromData<K extends keyof D = keyof D, T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: K, contentFn?: (value: T) => ChecklistItemDisplayContent): ChecklistItemFieldDisplayContentObs<T>;
+    contentWithDisplayValueFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, labelFn?: (value: T) => Maybe<string>): ChecklistItemFieldDisplayContentObs<T>;
+}

package/lib/formly/field/checklist/checklist.item.field.component.d.ts

@@ -1,6 +1,8 @@
-import { ComponentFactoryResolver, NgZone, OnDestroy, OnInit, Type, ViewContainerRef } from '@angular/core';
+import { ChangeDetectorRef } from '@angular/core';
+import { DbxInjectedComponentConfig } from '@dereekb/dbx-core';
+import { OnDestroy, OnInit, Type } from '@angular/core';
 import { ValidationErrors, FormGroup } from '@angular/forms';
-import { FieldType, FormlyFieldConfig } from '@ngx-formly/core';
+import { FieldType, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
 import { ChecklistItemFieldDisplayComponent, ChecklistItemFieldDisplayContentObs } from './checklist.item';
 import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
 import { Maybe } from '@dereekb/util';
@@ -15,18 +17,20 @@ export interface DbxChecklistItemFieldConfig<T = any> {
      */
     componentClass?: Type<ChecklistItemFieldDisplayComponent<T>>;
 }
-export interface ChecklistItemFormlyFieldConfig<T = any> extends DbxChecklistItemFieldConfig<T>, FormlyFieldConfig {
+export interface ChecklistItemFormlyFieldConfig<T = any> extends FormlyFieldConfig {
+    checklistField: DbxChecklistItemFieldConfig<T>;
 }
-export declare class DbxChecklistItemFieldComponent<T = any> extends FieldType<ChecklistItemFormlyFieldConfig<T>> implements OnInit, OnDestroy {
+export declare class DbxChecklistItemFieldComponent<T = any> extends FieldType<ChecklistItemFormlyFieldConfig<T> & FieldTypeConfig> implements OnInit, OnDestroy {
     private _displayContent;
     readonly displayContent$: import("rxjs").Observable<import("./checklist.item").ChecklistItemDisplayContent<T>>;
     readonly anchor$: import("rxjs").Observable<Maybe<import("@dereekb/dbx-core").ClickableAnchor>>;
     readonly rippleDisabled$: import("rxjs").Observable<boolean>;
     get formGroup(): FormGroup;
-    get checkboxFieldKey(): string;
+    get formControlName(): string;
     get label(): Maybe<string>;
     get description(): Maybe<string>;
     get required(): Maybe<boolean>;
+    get checklistField(): DbxChecklistItemFieldConfig<T>;
     get errors(): Maybe<ValidationErrors>;
     get componentClass(): Type<ChecklistItemFieldDisplayComponent<T>>;
     ngOnInit(): void;
@@ -34,14 +38,11 @@ export declare class DbxChecklistItemFieldComponent<T = any> extends FieldType<C
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxChecklistItemFieldComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxChecklistItemFieldComponent<any>, "ng-component", never, {}, {}, never, never>;
 }
-export declare class DbxChecklistItemContentComponent<T = any> extends AbstractSubscriptionDirective implements OnInit {
+export declare class DbxChecklistItemContentComponent<T = any> extends AbstractSubscriptionDirective {
     readonly checklistItemFieldComponent: DbxChecklistItemFieldComponent<T>;
-    readonly resolver: ComponentFactoryResolver;
-    readonly ngZone: NgZone;
-    readonly displayContent$: import("rxjs").Observable<import("./checklist.item").ChecklistItemDisplayContent<T>>;
-    readonly isLoading$: import("rxjs").Observable<import("./checklist.item").ChecklistItemDisplayContent<T>>;
-    contentRef: ViewContainerRef;
-    constructor(checklistItemFieldComponent: DbxChecklistItemFieldComponent<T>, resolver: ComponentFactoryResolver, ngZone: NgZone);
+    readonly cdRef: ChangeDetectorRef;
+    config?: DbxInjectedComponentConfig;
+    constructor(checklistItemFieldComponent: DbxChecklistItemFieldComponent<T>, cdRef: ChangeDetectorRef);
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxChecklistItemContentComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxChecklistItemContentComponent<any>, "dbx-checklist-item-content-component", never, {}, {}, never, never>;

package/lib/formly/field/checklist/checklist.item.field.content.default.component.d.ts

@@ -1,7 +1,7 @@
 import { ChecklistItemDisplayContent, ChecklistItemFieldDisplayComponent } from './checklist.item';
 import * as i0 from "@angular/core";
 export declare class DbxDefaultChecklistItemFieldDisplayComponent implements ChecklistItemFieldDisplayComponent<any> {
-    displayContent?: ChecklistItemDisplayContent<any>;
+    displayContent: ChecklistItemDisplayContent<any>;
     get label(): import("../../../../../../../dist/packages/util/src").Maybe<string>;
     get sublabel(): import("../../../../../../../dist/packages/util/src").Maybe<string>;
     get description(): import("../../../../../../../dist/packages/util/src").Maybe<string>;

package/lib/formly/field/checklist/checklist.item.field.d.ts

@@ -1,50 +1,6 @@
-import { Observable } from 'rxjs';
-import { FormlyFieldConfig } from '@ngx-formly/core';
-import { FieldConfig } from '../field';
+import { LabeledFieldConfig } from '../field';
 import { DbxChecklistItemFieldConfig, ChecklistItemFormlyFieldConfig } from './checklist.item.field.component';
-import { ChecklistItemDisplayContent, ChecklistItemFieldDisplayContentObs } from './checklist.item';
-import { KeyValueTransformMap, Maybe } from '@dereekb/util';
-export interface ChecklistItemFieldConfig<T = any> extends FieldConfig, DbxChecklistItemFieldConfig<T> {
+export interface ChecklistItemFieldConfig<T = any> extends LabeledFieldConfig, DbxChecklistItemFieldConfig<T> {
 }
 export declare type ChecklistItemFieldBuilderInput<T = any> = Partial<ChecklistItemFieldConfig<T>> & Pick<ChecklistItemFieldConfig<T>, 'key' | 'displayContentObs'>;
-export declare function checklistItemField<T = any>({ key, label, placeholder, displayContentObs, componentClass, required }: ChecklistItemFieldBuilderInput<T>): ChecklistItemFormlyFieldConfig<T>;
-export declare type ChecklistItemFieldDataSetFieldKey<D> = keyof D & string;
-export declare type ChecklistItemFieldDataSetFieldValueForKey<D, K extends keyof D = keyof D> = D[K];
-export declare type ChecklistType<D> = KeyValueTransformMap<D, boolean>;
-export declare type ChecklistItemFieldDataSetBuilderInput<D, T> = {
-    key: ChecklistItemFieldDataSetFieldKey<D>;
-} & ChecklistItemFieldBuilderInput<T>;
-export interface ChecklistItemFieldDataSetItem<D, T extends ChecklistType<D>> {
-    /**
-     * Key for the field.
-     */
-    key: ChecklistItemFieldDataSetFieldKey<T>;
-    /**
-     * Base field configuration to use.
-     */
-    field: ChecklistItemFieldBuilderInput<T>;
-}
-/**
- * Used for building a set of configurations for a data-type object that has as second object that is used as a checklist.
- */
-export declare class ChecklistItemFieldDataSetBuilder<D extends object, C extends ChecklistType<D> = ChecklistType<D>> {
-    readonly dataObs: Observable<D>;
-    private _fields;
-    readonly dataObs$: Observable<D>;
-    constructor(dataObs: Observable<D>);
-    /**
-     * Merges the input config with existing configuration.
-     *
-     * The displayContentObs, if provided, will merge with the existing observable and the two objects merged.
-     */
-    merge<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>): void;
-    override<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>): void;
-    _assertFieldExists(key: ChecklistItemFieldDataSetFieldKey<D>): ChecklistItemFieldDataSetItem<D, any>;
-    showValueFieldArrayCount<T extends ChecklistItemFieldDataSetFieldValueForKey<D> & Array<any>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>): void;
-    showValueField<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>, labelFn?: (value: T) => Maybe<string>): void;
-    field<T>(config: ChecklistItemFieldDataSetBuilderInput<D, T>): void;
-    build(): FormlyFieldConfig[];
-    customContentFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(mapFn: (data: D) => ChecklistItemDisplayContent): ChecklistItemFieldDisplayContentObs<T>;
-    contentWithValueFromData<K extends keyof D = keyof D, T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: K, contentFn?: (value: T) => ChecklistItemDisplayContent): ChecklistItemFieldDisplayContentObs<T>;
-    contentWithDisplayValueFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, labelFn?: (value: T) => Maybe<string>): ChecklistItemFieldDisplayContentObs<T>;
-}
+export declare function checklistItemField<T = any>(config: ChecklistItemFieldBuilderInput<T>): ChecklistItemFormlyFieldConfig<T>;

package/lib/formly/field/checklist/index.d.ts

@@ -3,3 +3,4 @@ export * from './checklist.item.field.content.default.component';
 export * from './checklist.item.field.module';
 export * from './checklist.item.field';
 export * from './checklist.item';
+export * from './checklist.field';

package/lib/formly/field/component/component.field.component.d.ts

@@ -10,12 +10,16 @@ export declare abstract class AbstractFormComponentFieldWrappedComponent impleme
     abstract field: FieldType<FormComponentFieldFieldConfig>;
 }
 export interface FormComponentFieldFieldConfig<T extends FormComponentFieldWrappedComponent = any> extends FormlyFieldConfig {
-    componentClass: Type<T>;
+    componentField: {
+        componentClass: Type<T>;
+    };
 }
 export declare class FormComponentFieldComponent<T extends FormComponentFieldWrappedComponent = any> extends FieldType<FormComponentFieldFieldConfig<T>> implements OnInit {
     private _config?;
     get config(): Maybe<DbxInjectedComponentConfig>;
-    constructor();
+    get componentField(): {
+        componentClass: Type<T>;
+    };
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FormComponentFieldComponent<any>, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FormComponentFieldComponent<any>, "ng-component", never, {}, {}, never, never>;

package/lib/formly/field/field.d.ts

@@ -1,11 +1,20 @@
-import { FormlyFieldConfig } from '@ngx-formly/core';
+import { FormlyFieldConfig, FormlyTemplateOptions } from '@ngx-formly/core';
 export interface FieldConfig {
+    key: string;
+    required?: boolean;
+    readonly?: boolean;
+}
+export declare type DisableAutocompleteForField = false;
+export interface LabeledFieldConfig extends FieldConfig {
     key: string;
     label?: string;
     placeholder?: string;
     required?: boolean;
     readonly?: boolean;
-    autocomplete?: string;
+    /**
+     * Sets the autocomplete values.
+     */
+    autocomplete?: string | DisableAutocompleteForField;
 }
 export interface DefaultValueFieldConfig<T = any> {
     defaultValue?: T;
@@ -18,14 +27,19 @@ export interface AttributesFieldConfig {
 export interface DescriptionFieldConfig {
     description?: string;
 }
+export declare type PartialPotentialFieldConfig = Partial<FieldConfig> & Partial<LabeledFieldConfig> & Partial<AttributesFieldConfig> & Partial<DescriptionFieldConfig>;
 /**
  * Validates the configuration on the input field.
  */
 export declare function formlyField<T extends FormlyFieldConfig = FormlyFieldConfig>(fieldConfig: T): T;
+export declare function templateOptionsForFieldConfig(fieldConfig: Partial<FieldConfig> & Partial<LabeledFieldConfig> & Partial<AttributesFieldConfig> & Partial<DescriptionFieldConfig>, override?: any): {
+    templateOptions: Partial<FormlyTemplateOptions>;
+};
+export declare function templateOptionsValueForFieldConfig<T extends FormlyTemplateOptions>(fieldConfig: PartialPotentialFieldConfig, override?: PartialPotentialFieldConfig & unknown): Partial<T>;
 /**
  * Returns configuration for a formlyField that will disable autofill/autocomplete for a field.
  */
-export declare function disableFormlyFieldAutofill(): {
+export declare function disableFormlyFieldAutofillAttributes(): {
     name: string;
     autocomplete: string;
 };

package/lib/formly/field/form.field.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./checklist/checklist.item.field.module";
+import * as i3 from "./component/component.field.module";
+import * as i4 from "./selection/selection.module";
+import * as i5 from "./texteditor/texteditor.field.module";
+import * as i6 from "./value/value.module";
+import * as i7 from "./wrapper/form.wrapper.module";
+export declare class DbxFormFormlyFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyFieldModule, never, [typeof i1.CommonModule], [typeof i2.DbxFormFormlyChecklistItemFieldModule, typeof i3.DbxFormFormlyComponentFieldModule, typeof i4.DbxFormFormlySelectionModule, typeof i5.DbxFormFormlyTextEditorFieldModule, typeof i6.DbxFormFormlyValueModule, typeof i7.DbxFormFormlyWrapperModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyFieldModule>;
+}

package/lib/formly/field/index.d.ts

@@ -1,6 +1,8 @@
 export * from './checklist';
 export * from './component';
 export * from './selection';
+export * from './texteditor';
 export * from './value';
 export * from './wrapper';
 export * from './field';
+export * from './form.field.module';