@dereekb/dbx-form 0.0.1

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

@@ -0,0 +1,9 @@
+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>;
+}

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

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

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

@@ -0,0 +1,15 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbxForm } from './form';
+import * as i0 from "@angular/core";
+/**
+ * Used to see form value changes.
+ */
+export declare class DbxFormValueChangesDirective<T extends object = any> extends AbstractSubscriptionDirective implements OnInit {
+    readonly form: DbxForm;
+    readonly dbxFormValueChange: EventEmitter<T>;
+    constructor(form: DbxForm);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormValueChangesDirective<any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFormValueChangesDirective<any>, "[dbxFormValueChange]", never, {}, { "dbxFormValueChange": "dbxFormValueChange"; }, never>;
+}

package/lib/form/form.d.ts

@@ -0,0 +1,51 @@
+import { Provider, Type } from '@angular/core';
+import { Observable } from 'rxjs';
+import { LockSet } from '@dereekb/rxjs';
+/**
+ * Current state of a DbxForm
+ */
+export declare enum DbxFormState {
+    INITIALIZING = -1,
+    INCOMPLETE = 0,
+    COMPLETE = 1,
+    RESET = 2
+}
+/**
+ * DbxForm stream event
+ */
+export interface DbxFormEvent {
+    readonly isComplete: boolean;
+    readonly state: DbxFormState;
+    readonly pristine?: boolean;
+    readonly untouched?: boolean;
+    readonly lastResetAt?: Date;
+    readonly changesCount?: number;
+}
+/**
+ * Form that has an event stream, value, and state items.
+ */
+export declare abstract class DbxForm {
+    /**
+     * LockSet for the form.
+     */
+    abstract readonly lockSet: LockSet;
+    /**
+     * True if the form is complete/valid.
+     */
+    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;
+    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[];

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

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbxForm } from '../form/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);
+    /**
+     * Sets a LoadingContext that is watched for the loading state.
+     */
+    set obs(obs: Observable<T>);
+    private _setObs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormSourceDirective<any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFormSourceDirective<any>, "[dbxFormSource]", never, { "obs": "dbxFormSource"; }, {}, never>;
+}

package/lib/form/form.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 "./loading/form.loading.directive";
+import * as i4 from "@angular/common";
+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 ɵinj: i0.ɵɵInjectorDeclaration<DbxFormModule>;
+}

package/lib/form/index.d.ts

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

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

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbxForm } 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 DbxFormLoadingPairSourceDirective<T extends object = any> extends AbstractSubscriptionDirective {
+    readonly form: DbxForm;
+    constructor(form: DbxForm);
+    /**
+     * Sets a LoadingContext that is watched for the loading state.
+     */
+    set obs(obs: Observable<LoadingState<T>>);
+    private _setObs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormLoadingPairSourceDirective<any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxFormLoadingPairSourceDirective<any>, "[dbxFormLoadingPairSource]", never, { "obs": "dbxFormLoadingPairSource"; }, {}, never>;
+}

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

@@ -0,0 +1 @@
+export * from './form.loading.directive';

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

@@ -0,0 +1,38 @@
+import { ClickableAnchor } from "@dereekb/dbx-core";
+import { Maybe } from "@dereekb/util";
+import { Observable } from "rxjs";
+export interface ChecklistItemDisplayContent<T = any> {
+    /**
+     * Label to display.
+     */
+    label?: Maybe<string>;
+    /**
+     * Secondary label/value to display. May be used as the string value.
+     */
+    sublabel?: Maybe<string>;
+    /**
+    * Hint/description to display.
+    */
+    description?: Maybe<string>;
+    /**
+     * Whether or not to display the ripple. Is true by default if the anchor is present.
+     */
+    ripple?: Maybe<boolean>;
+    /**
+     * Optional anchor to apply on the visible content.
+     */
+    anchor?: Maybe<ClickableAnchor>;
+    /**
+     * Value metadata. How it is used depends on the display component used.
+     */
+    meta?: Maybe<T>;
+}
+/**
+ * Component used for rendering checklist content.
+ *
+ * Content is injected.
+ */
+export interface ChecklistItemFieldDisplayComponent<T = any> {
+    displayContent?: ChecklistItemDisplayContent<T>;
+}
+export declare type ChecklistItemFieldDisplayContentObs<T = any> = Observable<ChecklistItemDisplayContent<T>>;

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

@@ -0,0 +1,48 @@
+import { ComponentFactoryResolver, NgZone, OnDestroy, OnInit, Type, ViewContainerRef } from '@angular/core';
+import { ValidationErrors, FormGroup } from '@angular/forms';
+import { FieldType, FormlyFieldConfig } from '@ngx-formly/core';
+import { ChecklistItemFieldDisplayComponent, ChecklistItemFieldDisplayContentObs } from './checklist.item';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export interface DbxChecklistItemFieldConfig<T = any> {
+    /**
+     * Observable used to retrieve content to display for the item.
+     */
+    displayContentObs: ChecklistItemFieldDisplayContentObs<T>;
+    /**
+     * Custom component class to use by default.
+     */
+    componentClass?: Type<ChecklistItemFieldDisplayComponent<T>>;
+}
+export interface ChecklistItemFormlyFieldConfig<T = any> extends DbxChecklistItemFieldConfig<T>, FormlyFieldConfig {
+}
+export declare class DbxChecklistItemFieldComponent<T = any> extends FieldType<ChecklistItemFormlyFieldConfig<T>> 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 label(): Maybe<string>;
+    get description(): Maybe<string>;
+    get required(): Maybe<boolean>;
+    get errors(): Maybe<ValidationErrors>;
+    get componentClass(): Type<ChecklistItemFieldDisplayComponent<T>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    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 {
+    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);
+    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

@@ -0,0 +1,10 @@
+import { ChecklistItemDisplayContent, ChecklistItemFieldDisplayComponent } from './checklist.item';
+import * as i0 from "@angular/core";
+export declare class DbxDefaultChecklistItemFieldDisplayComponent implements ChecklistItemFieldDisplayComponent<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>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxDefaultChecklistItemFieldDisplayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxDefaultChecklistItemFieldDisplayComponent, "ng-component", never, { "displayContent": "displayContent"; }, {}, never, never>;
+}

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

@@ -0,0 +1,50 @@
+import { Observable } from 'rxjs';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { FieldConfig } 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 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>;
+}

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

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./checklist.item.field.component";
+import * as i2 from "./checklist.item.field.content.default.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@dereekb/dbx-web";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/material/core";
+import * as i7 from "@angular/material/checkbox";
+import * as i8 from "@angular/material/button";
+import * as i9 from "@angular/material/icon";
+import * as i10 from "@dereekb/dbx-core";
+import * as i11 from "../wrapper/form.wrapper.module";
+import * as i12 from "@ngx-formly/core";
+export declare class DbxFormFormlyChecklistItemFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyChecklistItemFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyChecklistItemFieldModule, [typeof i1.DbxChecklistItemFieldComponent, typeof i1.DbxChecklistItemContentComponent, typeof i2.DbxDefaultChecklistItemFieldDisplayComponent], [typeof i3.CommonModule, typeof i4.DbxTextModule, typeof i5.FormsModule, typeof i5.ReactiveFormsModule, typeof i6.MatRippleModule, typeof i7.MatCheckboxModule, typeof i8.MatButtonModule, typeof i9.MatIconModule, typeof i4.DbxAnchorModule, typeof i10.DbxInjectedComponentModule, typeof i11.DbxFormFormlyWrapperModule, typeof i12.FormlyModule], [typeof i11.DbxFormFormlyWrapperModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyChecklistItemFieldModule>;
+}

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

@@ -0,0 +1,5 @@
+export * from './checklist.item.field.component';
+export * from './checklist.item.field.content.default.component';
+export * from './checklist.item.field.module';
+export * from './checklist.item.field';
+export * from './checklist.item';

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

@@ -0,0 +1,22 @@
+import { OnInit, Type } from '@angular/core';
+import { DbxInjectedComponentConfig } from '@dereekb/dbx-core';
+import { FieldType, FormlyFieldConfig } from '@ngx-formly/core';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+export interface FormComponentFieldWrappedComponent {
+    field: FieldType<FormComponentFieldFieldConfig>;
+}
+export declare abstract class AbstractFormComponentFieldWrappedComponent implements FormComponentFieldWrappedComponent {
+    abstract field: FieldType<FormComponentFieldFieldConfig>;
+}
+export interface FormComponentFieldFieldConfig<T extends FormComponentFieldWrappedComponent = any> extends FormlyFieldConfig {
+    componentClass: Type<T>;
+}
+export declare class FormComponentFieldComponent<T extends FormComponentFieldWrappedComponent = any> extends FieldType<FormComponentFieldFieldConfig<T>> implements OnInit {
+    private _config?;
+    get config(): Maybe<DbxInjectedComponentConfig>;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormComponentFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormComponentFieldComponent<any>, "ng-component", never, {}, {}, never, never>;
+}

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

@@ -0,0 +1,6 @@
+import { Type } from "@angular/core";
+import { FormComponentFieldWrappedComponent, FormComponentFieldFieldConfig } from "./component.field.component";
+export interface ComponentFieldConfig<T> {
+    componentClass: Type<T>;
+}
+export declare function componentField<T extends FormComponentFieldWrappedComponent>({ componentClass }: ComponentFieldConfig<T>): FormComponentFieldFieldConfig<T>;

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

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./component.field.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@dereekb/dbx-core";
+import * as i4 from "@ngx-formly/core";
+export declare class DbxFormFormlyComponentFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyComponentFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyComponentFieldModule, [typeof i1.FormComponentFieldComponent], [typeof i2.CommonModule, typeof i3.DbxInjectedComponentModule, typeof i4.FormlyModule], [typeof i1.FormComponentFieldComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyComponentFieldModule>;
+}

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

@@ -0,0 +1,3 @@
+export * from './component.field.component';
+export * from './component.field.module';
+export * from './component.field';

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

@@ -0,0 +1,31 @@
+import { FormlyFieldConfig } from '@ngx-formly/core';
+export interface FieldConfig {
+    key: string;
+    label?: string;
+    placeholder?: string;
+    required?: boolean;
+    readonly?: boolean;
+    autocomplete?: string;
+}
+export interface DefaultValueFieldConfig<T = any> {
+    defaultValue?: T;
+}
+export interface AttributesFieldConfig {
+    attributes?: {
+        [key: string]: string | number;
+    };
+}
+export interface DescriptionFieldConfig {
+    description?: string;
+}
+/**
+ * Validates the configuration on the input field.
+ */
+export declare function formlyField<T extends FormlyFieldConfig = FormlyFieldConfig>(fieldConfig: T): T;
+/**
+ * Returns configuration for a formlyField that will disable autofill/autocomplete for a field.
+ */
+export declare function disableFormlyFieldAutofill(): {
+    name: string;
+    autocomplete: string;
+};

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

@@ -0,0 +1,6 @@
+export * from './checklist';
+export * from './component';
+export * from './selection';
+export * from './value';
+export * from './wrapper';
+export * from './field';

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

@@ -0,0 +1,3 @@
+export * from './pickable';
+export * from './searchable';
+export * from './selection';

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

@@ -0,0 +1,5 @@
+export * from './pickable.chip.field.component';
+export * from './pickable.field.directive';
+export * from './pickable.field.module';
+export * from './pickable.list.field.component';
+export * from './pickable';

package/lib/formly/field/selection/pickable/pickable.chip.field.component.d.ts

@@ -0,0 +1,10 @@
+import { AbstractDbxPickableItemFieldDirective, PickableItemFieldItem } from "./pickable.field.directive";
+import * as i0 from "@angular/core";
+/**
+ * Used for picking pre-set values using chips as the presentation.
+ */
+export declare class DbxPickableChipFieldComponent<T> extends AbstractDbxPickableItemFieldDirective<T> {
+    itemClicked(item: PickableItemFieldItem<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPickableChipFieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxPickableChipFieldComponent<any>, "ng-component", never, {}, {}, never, never>;
+}

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

@@ -0,0 +1,28 @@
+import { Maybe } from "@dereekb/util";
+import { Observable } from "rxjs";
+import { SelectionDisplayValue, SelectionValue, SelectionValueHashFn } from "../selection";
+export interface PickableValueFieldValue<T, M = any> extends SelectionValue<T, M> {
+}
+export interface PickableValueFieldDisplayValue<T, M = any> extends SelectionDisplayValue<T, M> {
+}
+/**
+ * PickableValueField function for retrieving all values.
+ */
+export declare type PickableValueFieldLoadValuesFn<T, M = any> = () => Observable<PickableValueFieldValue<T, M>[]>;
+/**
+ * PickableValueField function that allows the values a chance to go through another observable for any changes.
+ *
+ * Values may not have metadata on them in some cases, where the value may infact be an unknown value.
+ * The returned value should be marked as unknown, or if it has no meta but is known, isUnknown should be marked false.
+ *
+ * The value itself should not change. All other fields on the value may change, however.
+ */
+export declare type PickableValueFieldDisplayFn<T, M = any> = (values: PickableValueFieldValue<T, M>[]) => Observable<PickableValueFieldDisplayValue<T, M>[]>;
+/**
+ * Used for filtering the values that should be displayed.
+ */
+export declare type PickableValueFieldFilterFn<T, M = any> = (flterText: Maybe<string>, values: PickableValueFieldDisplayValue<T, M>[]) => Observable<T[]>;
+/**
+ * Used to hash the value from the input pickable value.
+ */
+export declare type PickableValueFieldHashFn<T> = SelectionValueHashFn<T>;

package/lib/formly/field/selection/pickable/pickable.field.directive.d.ts

@@ -0,0 +1,155 @@
+import { DbxInjectedComponentConfig } from "@dereekb/dbx-core";
+import { LoadingStateContextInstance, LoadingState } from "@dereekb/rxjs";
+import { Maybe } from "@dereekb/util";
+import { OnDestroy, OnInit } from "@angular/core";
+import { FormControl, AbstractControl } from "@angular/forms";
+import { MatInput } from "@angular/material/input";
+import { FieldType, FormlyFieldConfig } from "@ngx-formly/core";
+import { Observable } from "rxjs";
+import { PickableValueFieldDisplayFn, PickableValueFieldDisplayValue, PickableValueFieldFilterFn, PickableValueFieldHashFn, PickableValueFieldLoadValuesFn, PickableValueFieldValue } from "./pickable";
+import * as i0 from "@angular/core";
+/**
+ * Wraps the selected state with the items.
+ */
+export interface PickableItemFieldItem<T> {
+    display: PickableValueFieldDisplayValue<T>;
+    selected?: boolean;
+}
+export declare type PickableItemFieldItemSortFn<T> = (items: PickableItemFieldItem<T>[]) => PickableItemFieldItem<T>[];
+export interface PickableValueFieldsFieldConfig<T> {
+    /**
+     * Loads all pickable values.
+     */
+    loadValues: PickableValueFieldLoadValuesFn<T>;
+    /**
+     * Used for building a display value given the input.
+     */
+    displayForValue: PickableValueFieldDisplayFn<T>;
+    /**
+     * Used for hashing display values and omitting repeat values.
+     *
+     * If hashForValue is not provided, the value's value will be used as is.
+     */
+    hashForValue?: PickableValueFieldHashFn<T>;
+    /**
+     * Used for filtering values via the search text.
+     */
+    filterValues?: PickableValueFieldFilterFn<T>;
+    /**
+     * Used for sorting the items before they are displayed.
+     *
+     * Should only be used to sort values.
+     */
+    sortItems?: PickableItemFieldItemSortFn<T>;
+    /**
+     * Whether or not to allow multiple items to be selected.
+     */
+    multiSelect?: boolean;
+    /**
+     * Whether or not to set/get values as an array or a single value. If set false, multiSelect is ignored.
+     */
+    asArrayValue?: boolean;
+    /**
+     * Whether or not to show the text filter. True by default if filterValues is provided.
+     */
+    showTextFilter?: boolean;
+    /**
+     * Whether or not to skip the filter function when the input is empty.
+     *
+     * True by default.
+     */
+    skipFilterFnOnEmpty?: boolean;
+    /**
+     * Filter Label
+     */
+    filterLabel?: string;
+    /**
+     * The maximum number of values that can be picked
+     */
+    maxPicks?: number;
+    /**
+     * Optional description/hint to display.
+     */
+    description?: string;
+    /**
+     * Footer Display
+     */
+    footerConfig?: DbxInjectedComponentConfig;
+}
+export interface PickableValueFieldsFormlyFieldConfig<T> extends PickableValueFieldsFieldConfig<T>, FormlyFieldConfig {
+}
+/**
+ * Displayed value with the computed hash.
+ */
+export interface PickableValueFieldDisplayValueWithHash<T, M = any> extends PickableValueFieldDisplayValue<T, M> {
+    _hash: any;
+}
+/**
+ * Used for picking pre-set values using items as the presentation.
+ */
+export declare class AbstractDbxPickableItemFieldDirective<T> extends FieldType<PickableValueFieldsFormlyFieldConfig<T>> implements OnInit, OnDestroy {
+    filterMatInput: MatInput;
+    readonly inputCtrl: FormControl;
+    private _formControlObs;
+    readonly formControl$: Observable<AbstractControl>;
+    private _displayHashMap;
+    readonly filterInputValue$: Observable<string>;
+    readonly filterInputValueString$: Observable<string>;
+    readonly loadResultsDisplayValuesState$: Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>>;
+    readonly _formControlValue: Observable<T | T[]>;
+    readonly loadResultsDisplayValues$: Observable<PickableValueFieldDisplayValueWithHash<T>[]>;
+    /**
+     * Current values in the form control.
+     */
+    readonly values$: Observable<T[]>;
+    /**
+     * Current values with their display value.
+     */
+    readonly displayValuesState$: Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>>;
+    /**
+     * Results to be displayed if filtered.
+     */
+    readonly filteredSearchResultsState$: Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>>;
+    readonly filteredSearchResults$: Observable<PickableValueFieldDisplayValueWithHash<T>[]>;
+    readonly items$: Observable<PickableItemFieldItem<T>[]>;
+    readonly itemsLoadingState$: Observable<LoadingState>;
+    /**
+     * Context used for managing the loading of items, or when the current results change.
+     */
+    readonly context: LoadingStateContextInstance<any, LoadingState<any>>;
+    readonly filterItemsLoadingState$: Observable<LoadingState>;
+    /**
+     * Context used for searching/filtering.
+     */
+    readonly filterResultsContext: LoadingStateContextInstance<any, LoadingState<PickableValueFieldDisplayValueWithHash<T, any>[]>>;
+    get multiSelect(): boolean;
+    get asArrayValue(): boolean;
+    get filterLabel(): Maybe<string>;
+    get readonly(): Maybe<boolean>;
+    get required(): Maybe<boolean>;
+    get placeholder(): string;
+    get description(): Maybe<string>;
+    get sortItems(): Maybe<PickableItemFieldItemSortFn<T>>;
+    get hashForValue(): PickableValueFieldHashFn<T>;
+    get displayForValue(): PickableValueFieldDisplayFn<T>;
+    get showFilterInput(): boolean;
+    get filterValuesFn(): PickableValueFieldFilterFn<T>;
+    get skipFilterFnOnEmpty(): boolean;
+    get _filterValues(): PickableValueFieldFilterFn<T>;
+    get showTextFilter(): boolean;
+    get loadValuesFn(): PickableValueFieldLoadValuesFn<T>;
+    get values(): T[];
+    get footerConfig(): Maybe<DbxInjectedComponentConfig>;
+    loadDisplayValuesForValues(values: T[]): Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>>;
+    loadDisplayValuesForFieldValues(values: PickableValueFieldValue<T>[]): Observable<LoadingState<PickableValueFieldDisplayValueWithHash<T>[]>>;
+    getDisplayValuesForFieldValues(values: PickableValueFieldValue<T>[]): Observable<PickableValueFieldDisplayValueWithHash<T>[]>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected _getValueOnFormControl(valueOnFormControl: any): T[];
+    addValue(value: T): void;
+    removeValue(value: T): void;
+    setValues(values: T[]): void;
+    protected _setValueOnFormControl(values: T[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxPickableItemFieldDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxPickableItemFieldDirective<any>, never, never, {}, {}, never>;
+}

package/lib/formly/field/selection/pickable/pickable.field.module.d.ts

@@ -0,0 +1,20 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./pickable.chip.field.component";
+import * as i2 from "./pickable.list.field.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@dereekb/dbx-web";
+import * as i5 from "@angular/forms";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/input";
+import * as i8 from "@angular/material/form-field";
+import * as i9 from "@angular/material/autocomplete";
+import * as i10 from "@angular/material/list";
+import * as i11 from "@dereekb/dbx-core";
+import * as i12 from "@angular/material/chips";
+import * as i13 from "@angular/material/icon";
+import * as i14 from "@ngx-formly/core";
+export declare class DbxFormFormlyPickableFieldModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxFormFormlyPickableFieldModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxFormFormlyPickableFieldModule, [typeof i1.DbxPickableChipFieldComponent, typeof i2.DbxPickableListFieldComponent], [typeof i3.CommonModule, typeof i4.DbxTextModule, typeof i4.DbxLoadingModule, typeof i4.DbxButtonModule, typeof i5.FormsModule, typeof i6.MatButtonModule, typeof i7.MatInputModule, typeof i8.MatFormFieldModule, typeof i5.ReactiveFormsModule, typeof i9.MatAutocompleteModule, typeof i10.MatListModule, typeof i11.DbxDatePipeModule, typeof i4.DbxAnchorModule, typeof i12.MatChipsModule, typeof i13.MatIconModule, typeof i11.DbxInjectedComponentModule, typeof i14.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxFormFormlyPickableFieldModule>;
+}