@dereekb/dbx-form 5.0.0 → 5.0.1

package/esm2020/lib/formly/field/checklist/checklist.field.mjs

@@ -23,10 +23,7 @@ export class ChecklistItemFieldDataSetBuilder {
             key
         };
         if (currentField.displayContentObs && config.displayContentObs) {
-            mergedConfig.displayContentObs = combineLatest([
-                currentField.displayContentObs,
-                config.displayContentObs
-            ]).pipe(map(([a, b]) => {
+            mergedConfig.displayContentObs = combineLatest([currentField.displayContentObs, config.displayContentObs]).pipe(map(([a, b]) => {
                 const result = {
                     ...a,
                     ...b
@@ -102,4 +99,4 @@ export class ChecklistItemFieldDataSetBuilder {
         return this.contentWithValueFromData(key, (value) => ({ label: sanitizeLabel(labelFn(value)) }));
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checklist.field.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-form/src/lib/formly/field/checklist/checklist.field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,aAAa,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AAGnE,OAAO,EAAwB,qBAAqB,EAAS,MAAM,eAAe,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAkC,MAAM,wBAAwB,CAAC;AAmB5F;;GAEG;AACH,MAAM,OAAO,gCAAgC;IAM3C,YAAqB,OAAsB;QAAtB,YAAO,GAAP,OAAO,CAAe;QAJnC,YAAO,GAAG,IAAI,GAAG,EAA4F,CAAC;QAE7G,aAAQ,GAAG,IAAI,CAAC,OAAO,CAAC;IAEc,CAAC;IAEhD;;;;OAIG;IACH,KAAK,CAAI,GAAyC,EAAE,MAAkD;QACpG,MAAM,YAAY,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;QACxD,MAAM,YAAY,GAAgD;YAChE,GAAG,YAAY;YACf,GAAG,MAAM;YACT,GAAG;SACG,CAAC;QAET,IAAI,YAAY,CAAC,iBAAiB,IAAI,MAAM,CAAC,iBAAiB,EAAE;YAC9D,YAAY,CAAC,iBAAiB,GAAG,aAAa,CAAC;gBAC7C,YAAY,CAAC,iBAAiB;gBAC9B,MAAM,CAAC,iBAAiB;aACzB,CAAC,CAAC,IAAI,CACL,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE;gBACb,MAAM,MAAM,GAAG;oBACb,GAAG,CAAC;oBACJ,GAAG,CAAC;iBACL,CAAC;gBAEF,0CAA0C;gBAC1C,OAAO,MAAM,CAAC;YAChB,CAAC,CAAC,EACF,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;SACH;QAED,yCAAyC;QAEzC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IAC3B,CAAC;IAED,QAAQ,CAAI,GAAyC,EAAE,MAAkD;QACvG,MAAM,YAAY,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC;QAElD,IAAI,CAAC,KAAK,CAAC;YACT,GAAG,YAAY,CAAC,KAAK;YACrB,GAAG,MAAM;YACT,GAAG;SACJ,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB,CAAC,GAAyC;QAC1D,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAE3C,IAAI,CAAC,YAAY,EAAE;YACjB,MAAM,IAAI,KAAK,CAAC,4BAA4B,GAAG,uCAAuC,CAAC,CAAC;SACzF;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,wBAAwB,CAA0E,GAAyC,EAAE,MAA6D;QACxM,OAAO,IAAI,CAAC,KAAK,CAAC;YAChB,iBAAiB,EAAE,IAAI,CAAC,+BAA+B,CAAC,GAAG,EAAE,CAAC,CAAI,EAAE,EAAE,CAAC,qBAAqB,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;YACxG,GAAG,MAAM;YACT,GAAG;SACJ,CAAC,CAAC;IACL,CAAC;IAED,cAAc,CAAwG,GAAyC,EAAE,MAA6D,EAAE,UAAuC,CAAC,CAAI,EAAE,EAAE,CAAE,CAAyC,EAAE,QAAQ,EAAE;QACrU,OAAO,IAAI,CAAC,KAAK,CAAC;YAChB,iBAAiB,EAAE,IAAI,CAAC,+BAA+B,CAAC,GAAG,EAAE,OAAO,CAAC;YACrE,GAAG,MAAM;YACT,GAAG;SACJ,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAI,MAAmD;QAC1D,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;QAEvB,MAAM,KAAK,GAAuD;YAChE,GAAG;YACH,KAAK,EAAE,MAAqE;SAC7E,CAAC;QAEF,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC/B,CAAC;IAED,qBAAqB;IACrB,KAAK;QACH,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;YACzD,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;IAChB,qBAAqB,CAAwG,KAAkD;QAC7K,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;IACxC,CAAC;IAED,wBAAwB,CAAqI,GAAM,EAAE,SAAwD;QAC3N,OAAO,IAAI,CAAC,qBAAqB,CAAC,CAAC,IAAI,EAAE,EAAE;YACzC,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAiB,CAAC;YACvC,MAAM,OAAO,GAAG,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC;YAElC,OAAO;gBACL,IAAI;gBACJ,GAAG,OAAO;aACX,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,+BAA+B,CAAwG,GAAyC,EAAE,UAAuC,CAAC,CAAI,EAAE,EAAE,CAAE,CAAyC,EAAE,QAAQ,EAAE;QACvR,SAAS,aAAa,CAAC,KAAoB;YACzC,OAAO,KAAK,IAAI,KAAK,CAAC;QACxB,CAAC;QAED,OAAO,IAAI,CAAC,wBAAwB,CAAC,GAAG,EAAE,CAAC,KAAQ,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACtG,CAAC;CAEF","sourcesContent":["import { Observable, combineLatest, map, shareReplay } from 'rxjs';\nimport { FormlyFieldConfig } from '@ngx-formly/core';\nimport { ChecklistItemDisplayContent, ChecklistItemFieldDisplayContentObs } from './checklist.item';\nimport { KeyValueTransformMap, addPlusPrefixToNumber, Maybe } from '@dereekb/util';\nimport { checklistItemField, ChecklistItemFieldBuilderInput } from './checklist.item.field';\n\nexport type ChecklistItemFieldDataSetFieldKey<D> = keyof D & string;\nexport type ChecklistItemFieldDataSetFieldValueForKey<D, K extends keyof D = keyof D> = D[K];\nexport type ChecklistType<D> = KeyValueTransformMap<D, boolean>;\n\nexport type ChecklistItemFieldDataSetBuilderInput<D, T> = { key: ChecklistItemFieldDataSetFieldKey<D> } & ChecklistItemFieldBuilderInput<T>;\n\nexport interface ChecklistItemFieldDataSetItem<D, T extends ChecklistType<D>> {\n  /**\n   * Key for the field.\n   */\n  key: ChecklistItemFieldDataSetFieldKey<T>;\n  /**\n   * Base field configuration to use.\n   */\n  field: ChecklistItemFieldBuilderInput<T>;\n}\n\n/**\n * Used for building a set of configurations for a data-type object that has as second object that is used as a checklist.\n */\nexport class ChecklistItemFieldDataSetBuilder<D extends object, C extends ChecklistType<D> = ChecklistType<D>> {\n\n  private _fields = new Map<ChecklistItemFieldDataSetFieldKey<C>, ChecklistItemFieldDataSetItem<D, ChecklistType<D>>>();\n\n  readonly dataObs$ = this.dataObs;\n\n  constructor(readonly dataObs: Observable<D>) { }\n\n  /**\n   * Merges the input config with existing configuration.\n   * \n   * The displayContentObs, if provided, will merge with the existing observable and the two objects merged.\n   */\n  merge<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>) {\n    const currentField = this._assertFieldExists(key).field;\n    const mergedConfig: ChecklistItemFieldDataSetBuilderInput<D, T> = {\n      ...currentField,\n      ...config,\n      key\n    } as any;\n\n    if (currentField.displayContentObs && config.displayContentObs) {\n      mergedConfig.displayContentObs = combineLatest([\n        currentField.displayContentObs,\n        config.displayContentObs\n      ]).pipe(\n        map(([a, b]) => {\n          const result = {\n            ...a,\n            ...b\n          };\n\n          // console.log('A and b: ', a, b, result);\n          return result;\n        }),\n        shareReplay(1)\n      );\n    }\n\n    // console.log('Merged: ', mergedConfig);\n\n    this.field(mergedConfig);\n  }\n\n  override<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>) {\n    const currentField = this._assertFieldExists(key);\n\n    this.field({\n      ...currentField.field,\n      ...config,\n      key\n    });\n  }\n\n  _assertFieldExists(key: ChecklistItemFieldDataSetFieldKey<D>): ChecklistItemFieldDataSetItem<D, any> {\n    const currentField = this._fields.get(key);\n\n    if (!currentField) {\n      throw new Error(`Expected field with key \"${key}\" for override() but was unavailable.`);\n    }\n\n    return currentField;\n  }\n\n  showValueFieldArrayCount<T extends ChecklistItemFieldDataSetFieldValueForKey<D> & Array<unknown>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>) {\n    return this.field({\n      displayContentObs: this.contentWithDisplayValueFromData(key, (x: T) => addPlusPrefixToNumber(x?.length)),\n      ...config,\n      key\n    });\n  }\n\n  showValueField<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>, labelFn: (value: T) => Maybe<string> = (x: T) => (x as unknown as object | number | string)?.toString()) {\n    return this.field({\n      displayContentObs: this.contentWithDisplayValueFromData(key, labelFn),\n      ...config,\n      key\n    });\n  }\n\n  field<T>(config: ChecklistItemFieldDataSetBuilderInput<D, T>) {\n    const key = config.key;\n\n    const field: ChecklistItemFieldDataSetItem<D, ChecklistType<D>> = {\n      key,\n      field: config as unknown as ChecklistItemFieldBuilderInput<ChecklistType<D>>\n    };\n\n    this._fields.set(key, field);\n  }\n\n  // MARK: Build/Finish\n  build(): FormlyFieldConfig[] {\n    return Array.from(this._fields.values()).map(({ field }) => {\n      return checklistItemField(field);\n    });\n  }\n\n  // MARK: Utility\n  customContentFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(mapFn: (data: D) => ChecklistItemDisplayContent<T>): ChecklistItemFieldDisplayContentObs<T> {\n    return this.dataObs$.pipe(map(mapFn));\n  }\n\n  contentWithValueFromData<K extends keyof D = keyof D, T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: K, contentFn?: (value: T) => ChecklistItemDisplayContent<T>): ChecklistItemFieldDisplayContentObs<T> {\n    return this.customContentFromData((data) => {\n      const meta = data[key] as unknown as T;\n      const content = contentFn?.(meta);\n\n      return {\n        meta,\n        ...content\n      };\n    });\n  }\n\n  contentWithDisplayValueFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, labelFn: (value: T) => Maybe<string> = (x: T) => (x as unknown as object | number | string)?.toString()): ChecklistItemFieldDisplayContentObs<T> {\n    function sanitizeLabel(label: Maybe<string>): string {\n      return label ?? 'N/A';\n    }\n\n    return this.contentWithValueFromData(key, (value: T) => ({ label: sanitizeLabel(labelFn(value)) }));\n  }\n\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checklist.field.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-form/src/lib/formly/field/checklist/checklist.field.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, combineLatest, map, shareReplay } from 'rxjs';\nimport { FormlyFieldConfig } from '@ngx-formly/core';\nimport { ChecklistItemDisplayContent, ChecklistItemFieldDisplayContentObs } from './checklist.item';\nimport { KeyValueTransformMap, addPlusPrefixToNumber, Maybe } from '@dereekb/util';\nimport { checklistItemField, ChecklistItemFieldBuilderInput } from './checklist.item.field';\n\nexport type ChecklistItemFieldDataSetFieldKey<D> = keyof D & string;\nexport type ChecklistItemFieldDataSetFieldValueForKey<D, K extends keyof D = keyof D> = D[K];\nexport type ChecklistType<D> = KeyValueTransformMap<D, boolean>;\n\nexport type ChecklistItemFieldDataSetBuilderInput<D, T> = { key: ChecklistItemFieldDataSetFieldKey<D> } & ChecklistItemFieldBuilderInput<T>;\n\nexport interface ChecklistItemFieldDataSetItem<D, T extends ChecklistType<D>> {\n  /**\n   * Key for the field.\n   */\n  key: ChecklistItemFieldDataSetFieldKey<T>;\n  /**\n   * Base field configuration to use.\n   */\n  field: ChecklistItemFieldBuilderInput<T>;\n}\n\n/**\n * Used for building a set of configurations for a data-type object that has as second object that is used as a checklist.\n */\nexport class ChecklistItemFieldDataSetBuilder<D extends object, C extends ChecklistType<D> = ChecklistType<D>> {\n  private _fields = new Map<ChecklistItemFieldDataSetFieldKey<C>, ChecklistItemFieldDataSetItem<D, ChecklistType<D>>>();\n\n  readonly dataObs$ = this.dataObs;\n\n  constructor(readonly dataObs: Observable<D>) {}\n\n  /**\n   * Merges the input config with existing configuration.\n   *\n   * The displayContentObs, if provided, will merge with the existing observable and the two objects merged.\n   */\n  merge<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>) {\n    const currentField = this._assertFieldExists(key).field;\n    const mergedConfig: ChecklistItemFieldDataSetBuilderInput<D, T> = {\n      ...currentField,\n      ...config,\n      key\n    } as any;\n\n    if (currentField.displayContentObs && config.displayContentObs) {\n      mergedConfig.displayContentObs = combineLatest([currentField.displayContentObs, config.displayContentObs]).pipe(\n        map(([a, b]) => {\n          const result = {\n            ...a,\n            ...b\n          };\n\n          // console.log('A and b: ', a, b, result);\n          return result;\n        }),\n        shareReplay(1)\n      );\n    }\n\n    // console.log('Merged: ', mergedConfig);\n\n    this.field(mergedConfig);\n  }\n\n  override<T>(key: ChecklistItemFieldDataSetFieldKey<D>, config: Partial<ChecklistItemFieldBuilderInput<T>>) {\n    const currentField = this._assertFieldExists(key);\n\n    this.field({\n      ...currentField.field,\n      ...config,\n      key\n    });\n  }\n\n  _assertFieldExists(key: ChecklistItemFieldDataSetFieldKey<D>): ChecklistItemFieldDataSetItem<D, any> {\n    const currentField = this._fields.get(key);\n\n    if (!currentField) {\n      throw new Error(`Expected field with key \"${key}\" for override() but was unavailable.`);\n    }\n\n    return currentField;\n  }\n\n  showValueFieldArrayCount<T extends ChecklistItemFieldDataSetFieldValueForKey<D> & Array<unknown>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>) {\n    return this.field({\n      displayContentObs: this.contentWithDisplayValueFromData(key, (x: T) => addPlusPrefixToNumber(x?.length)),\n      ...config,\n      key\n    });\n  }\n\n  showValueField<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, config?: Partial<ChecklistItemFieldDataSetBuilderInput<D, T>>, labelFn: (value: T) => Maybe<string> = (x: T) => (x as unknown as object | number | string)?.toString()) {\n    return this.field({\n      displayContentObs: this.contentWithDisplayValueFromData(key, labelFn),\n      ...config,\n      key\n    });\n  }\n\n  field<T>(config: ChecklistItemFieldDataSetBuilderInput<D, T>) {\n    const key = config.key;\n\n    const field: ChecklistItemFieldDataSetItem<D, ChecklistType<D>> = {\n      key,\n      field: config as unknown as ChecklistItemFieldBuilderInput<ChecklistType<D>>\n    };\n\n    this._fields.set(key, field);\n  }\n\n  // MARK: Build/Finish\n  build(): FormlyFieldConfig[] {\n    return Array.from(this._fields.values()).map(({ field }) => {\n      return checklistItemField(field);\n    });\n  }\n\n  // MARK: Utility\n  customContentFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(mapFn: (data: D) => ChecklistItemDisplayContent<T>): ChecklistItemFieldDisplayContentObs<T> {\n    return this.dataObs$.pipe(map(mapFn));\n  }\n\n  contentWithValueFromData<K extends keyof D = keyof D, T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: K, contentFn?: (value: T) => ChecklistItemDisplayContent<T>): ChecklistItemFieldDisplayContentObs<T> {\n    return this.customContentFromData((data) => {\n      const meta = data[key] as unknown as T;\n      const content = contentFn?.(meta);\n\n      return {\n        meta,\n        ...content\n      };\n    });\n  }\n\n  contentWithDisplayValueFromData<T extends ChecklistItemFieldDataSetFieldValueForKey<D> = ChecklistItemFieldDataSetFieldValueForKey<D>>(key: ChecklistItemFieldDataSetFieldKey<D>, labelFn: (value: T) => Maybe<string> = (x: T) => (x as unknown as object | number | string)?.toString()): ChecklistItemFieldDisplayContentObs<T> {\n    function sanitizeLabel(label: Maybe<string>): string {\n      return label ?? 'N/A';\n    }\n\n    return this.contentWithValueFromData(key, (value: T) => ({ label: sanitizeLabel(labelFn(value)) }));\n  }\n}\n"]}

package/esm2020/lib/formly/field/checklist/checklist.item.field.component.mjs

@@ -17,8 +17,8 @@ export class DbxChecklistItemFieldComponent extends FieldType {
         super(...arguments);
         this._displayContent = new BehaviorSubject(undefined);
         this.displayContent$ = this._displayContent.pipe(switchMapMaybeObs(), distinctUntilChanged(), shareReplay(1));
-        this.anchor$ = this.displayContent$.pipe(map(x => x.anchor), shareReplay(1));
-        this.rippleDisabled$ = this.displayContent$.pipe(map(x => x.ripple === false || (x.ripple !== true && !x.anchor)), distinctUntilChanged(), shareReplay(1));
+        this.anchor$ = this.displayContent$.pipe(map((x) => x.anchor), shareReplay(1));
+        this.rippleDisabled$ = this.displayContent$.pipe(map((x) => x.ripple === false || (x.ripple !== true && !x.anchor)), distinctUntilChanged(), shareReplay(1));
     }
     get formGroup() {
         return this.form;
@@ -76,12 +76,16 @@ export class DbxChecklistItemContentComponent extends AbstractSubscriptionDirect
     }
 }
 DbxChecklistItemContentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxChecklistItemContentComponent, deps: [{ token: DbxChecklistItemFieldComponent }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
-DbxChecklistItemContentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: DbxChecklistItemContentComponent, selector: "dbx-checklist-item-content-component", usesInheritance: true, ngImport: i0, template: `<dbx-injection [config]="config"></dbx-injection>`, isInline: true, components: [{ type: i7.DbxInjectionComponent, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: ["config", "template"] }] });
+DbxChecklistItemContentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: DbxChecklistItemContentComponent, selector: "dbx-checklist-item-content-component", usesInheritance: true, ngImport: i0, template: `
+    <dbx-injection [config]="config"></dbx-injection>
+  `, isInline: true, components: [{ type: i7.DbxInjectionComponent, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: ["config", "template"] }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxChecklistItemContentComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'dbx-checklist-item-content-component',
-                    template: `<dbx-injection [config]="config"></dbx-injection>`
+                    template: `
+    <dbx-injection [config]="config"></dbx-injection>
+  `
                 }]
         }], ctorParameters: function () { return [{ type: DbxChecklistItemFieldComponent }, { type: i0.ChangeDetectorRef }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checklist.item.field.component.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-form/src/lib/formly/field/checklist/checklist.item.field.component.ts","../../../../../../../../packages/dbx-form/src/lib/formly/field/checklist/checklist.item.field.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EACxB,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAA+B,6BAA6B,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAClH,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,GAAG,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAE/E,OAAO,EAAE,SAAS,EAAsC,MAAM,kBAAkB,CAAC;AAEjF,OAAO,EAAE,4CAA4C,EAAE,MAAM,kDAAkD,CAAC;;;;;;;;;AAqBhH,MAAM,OAAO,8BAA4C,SAAQ,SAA8D;IAH/H;;QAKU,oBAAe,GAAG,IAAI,eAAe,CAAgD,SAAS,CAAC,CAAC;QAE/F,oBAAe,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAClD,iBAAiB,EAAE,EACnB,oBAAoB,EAAE,EACtB,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;QAEO,YAAO,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAC1C,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,EAClB,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;QAEO,oBAAe,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAClD,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAChE,oBAAoB,EAAE,EACtB,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;KA0CH;IAxCC,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,IAAiB,CAAC;IAChC,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,GAAa,CAAC;IAC5B,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,KAAK,CAAC;IAC3C,CAAC;IAED,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,WAAW,CAAC;IACjD,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,QAAQ,CAAC;IAC9C,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC;IACnC,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,MAAM,CAAC;IACxC,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,cAAc,CAAC,cAAc,IAAI,4CAA4C,CAAC;IAC5F,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;IACnE,CAAC;IAED,WAAW;QACT,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;;2HA3DU,8BAA8B;+GAA9B,8BAA8B,2EC9B3C,65BAkBA,8hBD+Ea,gCAAgC;2FAnEhC,8BAA8B;kBAH1C,SAAS;;;AAsEV,MAAM,OAAO,gCAA8C,SAAQ,6BAA6B;IAI9F,YACW,2BAA8D,EAC9D,KAAwB;QAEjC,KAAK,EAAE,CAAC;QAHC,gCAA2B,GAA3B,2BAA2B,CAAmC;QAC9D,UAAK,GAAL,KAAK,CAAmB;IAGnC,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,MAAM,GAAG;YACZ,cAAc,EAAE,IAAI,CAAC,2BAA2B,CAAC,cAAc;YAC/D,IAAI,EAAE,CAAC,QAAQ,EAAE,EAAE;gBACjB,IAAI,CAAC,2BAA2B,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;oBAC/D,QAAQ,CAAC,cAAc,GAAG,CAAC,CAAC;oBAC5B,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBAChC,CAAC,CAAC,CAAC;YACL,CAAC;SACF,CAAC;IACJ,CAAC;;6HArBU,gCAAgC,kBAKH,8BAA8B;iHAL3D,gCAAgC,mGAFjC,mDAAmD;2FAElD,gCAAgC;kBAJ5C,SAAS;mBAAC;oBACT,QAAQ,EAAE,sCAAsC;oBAChD,QAAQ,EAAE,mDAAmD;iBAC9D;0DAMyC,8BAA8B","sourcesContent":["import { ChangeDetectorRef ,\n  Component, OnDestroy, OnInit, Type\n} from '@angular/core';\nimport { DbxInjectionComponentConfig, AbstractSubscriptionDirective, safeDetectChanges } from '@dereekb/dbx-core';\nimport { switchMapMaybeObs } from '@dereekb/rxjs';\nimport { shareReplay, distinctUntilChanged, map, BehaviorSubject } from 'rxjs';\nimport { ValidationErrors, FormGroup } from '@angular/forms';\nimport { FieldType, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';\nimport { ChecklistItemFieldDisplayComponent, ChecklistItemFieldDisplayContentObs } from './checklist.item';\nimport { DbxDefaultChecklistItemFieldDisplayComponent } from './checklist.item.field.content.default.component';\nimport { Maybe } from '@dereekb/util';\n\nexport interface DbxChecklistItemFieldConfig<T = unknown> {\n  /**\n   * Observable used to retrieve content to display for the item.\n   */\n  displayContentObs: ChecklistItemFieldDisplayContentObs<T>;\n  /**\n   * Custom component class to use by default.\n   */\n  componentClass?: Type<ChecklistItemFieldDisplayComponent<T>>;\n}\n\nexport interface ChecklistItemFormlyFieldConfig<T = unknown> extends FormlyFieldConfig {\n  checklistField: DbxChecklistItemFieldConfig<T>;\n}\n\n@Component({\n  templateUrl: 'checklist.item.field.component.html'\n})\nexport class DbxChecklistItemFieldComponent<T = unknown> extends FieldType<ChecklistItemFormlyFieldConfig<T> & FieldTypeConfig> implements OnInit, OnDestroy {\n\n  private _displayContent = new BehaviorSubject<Maybe<ChecklistItemFieldDisplayContentObs<T>>>(undefined);\n\n  readonly displayContent$ = this._displayContent.pipe(\n    switchMapMaybeObs(),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly anchor$ = this.displayContent$.pipe(\n    map(x => x.anchor),\n    shareReplay(1)\n  );\n\n  readonly rippleDisabled$ = this.displayContent$.pipe(\n    map(x => x.ripple === false || (x.ripple !== true && !x.anchor)),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  get formGroup(): FormGroup {\n    return this.form as FormGroup;\n  }\n\n  get formControlName(): string {\n    return this.key as string;\n  }\n\n  get label(): Maybe<string> {\n    return this.field.templateOptions?.label;\n  }\n\n  get description(): Maybe<string> {\n    return this.field.templateOptions?.description;\n  }\n\n  get required(): Maybe<boolean> {\n    return this.field.templateOptions?.required;\n  }\n\n  get checklistField(): DbxChecklistItemFieldConfig<T> {\n    return this.field.checklistField;\n  }\n\n  get errors(): Maybe<ValidationErrors> {\n    return this.field.formControl?.errors;\n  }\n\n  get componentClass(): Type<ChecklistItemFieldDisplayComponent<T>> {\n    return this.checklistField.componentClass ?? DbxDefaultChecklistItemFieldDisplayComponent;\n  }\n\n  ngOnInit() {\n    this._displayContent.next(this.checklistField.displayContentObs);\n  }\n\n  ngOnDestroy() {\n    this._displayContent.complete();\n  }\n\n}\n\n@Component({\n  selector: 'dbx-checklist-item-content-component',\n  template: `<dbx-injection [config]=\"config\"></dbx-injection>`\n})\nexport class DbxChecklistItemContentComponent<T = unknown> extends AbstractSubscriptionDirective implements OnInit {\n\n  config?: DbxInjectionComponentConfig<ChecklistItemFieldDisplayComponent<T>>;\n\n  constructor(\n    readonly checklistItemFieldComponent: DbxChecklistItemFieldComponent<T>,\n    readonly cdRef: ChangeDetectorRef\n  ) {\n    super();\n  }\n\n  ngOnInit(): void {\n    this.config = {\n      componentClass: this.checklistItemFieldComponent.componentClass,\n      init: (instance) => {\n        this.checklistItemFieldComponent.displayContent$.subscribe((x) => {\n          instance.displayContent = x;\n          safeDetectChanges(this.cdRef);\n        });\n      }\n    };\n  }\n\n}\n","<div class=\"dbx-checklist-item-wrapper\" [formGroup]=\"formGroup\">\n  <div *ngIf=\"label\" class=\"dbx-checklist-item-label\">{{ label }}</div>\n  <div class=\"dbx-checklist-item\">\n    <div class=\"dbx-checklist-item-check\">\n      <mat-checkbox [formControlName]=\"formControlName\"></mat-checkbox>\n    </div>\n    <div class=\"dbx-checklist-item-content-wrapper\">\n      <dbx-anchor [block]=\"true\" [anchor]=\"anchor$ | async\">\n        <div class=\"dbx-checklist-item-content\" matRipple [matRippleDisabled]=\"(rippleDisabled$ | async) ?? false\">\n          <dbx-checklist-item-content-component></dbx-checklist-item-content-component>\n          <span class=\"spacer\"></span>\n          <mat-icon *ngIf=\"(rippleDisabled$ | async) !== true\">navigate_next</mat-icon>\n        </div>\n      </dbx-anchor>\n    </div>\n  </div>\n  <div *ngIf=\"description\" class=\"dbx-hint\">{{ description }}</div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checklist.item.field.component.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-form/src/lib/formly/field/checklist/checklist.item.field.component.ts","../../../../../../../../packages/dbx-form/src/lib/formly/field/checklist/checklist.item.field.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Component, OnDestroy, OnInit, Type } from '@angular/core';\nimport { DbxInjectionComponentConfig, AbstractSubscriptionDirective, safeDetectChanges } from '@dereekb/dbx-core';\nimport { switchMapMaybeObs } from '@dereekb/rxjs';\nimport { shareReplay, distinctUntilChanged, map, BehaviorSubject } from 'rxjs';\nimport { ValidationErrors, FormGroup } from '@angular/forms';\nimport { FieldType, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';\nimport { ChecklistItemFieldDisplayComponent, ChecklistItemFieldDisplayContentObs } from './checklist.item';\nimport { DbxDefaultChecklistItemFieldDisplayComponent } from './checklist.item.field.content.default.component';\nimport { Maybe } from '@dereekb/util';\n\nexport interface DbxChecklistItemFieldConfig<T = unknown> {\n  /**\n   * Observable used to retrieve content to display for the item.\n   */\n  displayContentObs: ChecklistItemFieldDisplayContentObs<T>;\n  /**\n   * Custom component class to use by default.\n   */\n  componentClass?: Type<ChecklistItemFieldDisplayComponent<T>>;\n}\n\nexport interface ChecklistItemFormlyFieldConfig<T = unknown> extends FormlyFieldConfig {\n  checklistField: DbxChecklistItemFieldConfig<T>;\n}\n\n@Component({\n  templateUrl: 'checklist.item.field.component.html'\n})\nexport class DbxChecklistItemFieldComponent<T = unknown> extends FieldType<ChecklistItemFormlyFieldConfig<T> & FieldTypeConfig> implements OnInit, OnDestroy {\n  private _displayContent = new BehaviorSubject<Maybe<ChecklistItemFieldDisplayContentObs<T>>>(undefined);\n\n  readonly displayContent$ = this._displayContent.pipe(switchMapMaybeObs(), distinctUntilChanged(), shareReplay(1));\n\n  readonly anchor$ = this.displayContent$.pipe(\n    map((x) => x.anchor),\n    shareReplay(1)\n  );\n\n  readonly rippleDisabled$ = this.displayContent$.pipe(\n    map((x) => x.ripple === false || (x.ripple !== true && !x.anchor)),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  get formGroup(): FormGroup {\n    return this.form as FormGroup;\n  }\n\n  get formControlName(): string {\n    return this.key as string;\n  }\n\n  get label(): Maybe<string> {\n    return this.field.templateOptions?.label;\n  }\n\n  get description(): Maybe<string> {\n    return this.field.templateOptions?.description;\n  }\n\n  get required(): Maybe<boolean> {\n    return this.field.templateOptions?.required;\n  }\n\n  get checklistField(): DbxChecklistItemFieldConfig<T> {\n    return this.field.checklistField;\n  }\n\n  get errors(): Maybe<ValidationErrors> {\n    return this.field.formControl?.errors;\n  }\n\n  get componentClass(): Type<ChecklistItemFieldDisplayComponent<T>> {\n    return this.checklistField.componentClass ?? DbxDefaultChecklistItemFieldDisplayComponent;\n  }\n\n  ngOnInit() {\n    this._displayContent.next(this.checklistField.displayContentObs);\n  }\n\n  ngOnDestroy() {\n    this._displayContent.complete();\n  }\n}\n\n@Component({\n  selector: 'dbx-checklist-item-content-component',\n  template: `\n    <dbx-injection [config]=\"config\"></dbx-injection>\n  `\n})\nexport class DbxChecklistItemContentComponent<T = unknown> extends AbstractSubscriptionDirective implements OnInit {\n  config?: DbxInjectionComponentConfig<ChecklistItemFieldDisplayComponent<T>>;\n\n  constructor(readonly checklistItemFieldComponent: DbxChecklistItemFieldComponent<T>, readonly cdRef: ChangeDetectorRef) {\n    super();\n  }\n\n  ngOnInit(): void {\n    this.config = {\n      componentClass: this.checklistItemFieldComponent.componentClass,\n      init: (instance) => {\n        this.checklistItemFieldComponent.displayContent$.subscribe((x) => {\n          instance.displayContent = x;\n          safeDetectChanges(this.cdRef);\n        });\n      }\n    };\n  }\n}\n","<div class=\"dbx-checklist-item-wrapper\" [formGroup]=\"formGroup\">\n  <div *ngIf=\"label\" class=\"dbx-checklist-item-label\">{{ label }}</div>\n  <div class=\"dbx-checklist-item\">\n    <div class=\"dbx-checklist-item-check\">\n      <mat-checkbox [formControlName]=\"formControlName\"></mat-checkbox>\n    </div>\n    <div class=\"dbx-checklist-item-content-wrapper\">\n      <dbx-anchor [block]=\"true\" [anchor]=\"anchor$ | async\">\n        <div class=\"dbx-checklist-item-content\" matRipple [matRippleDisabled]=\"(rippleDisabled$ | async) ?? false\">\n          <dbx-checklist-item-content-component></dbx-checklist-item-content-component>\n          <span class=\"spacer\"></span>\n          <mat-icon *ngIf=\"(rippleDisabled$ | async) !== true\">navigate_next</mat-icon>\n        </div>\n      </dbx-anchor>\n    </div>\n  </div>\n  <div *ngIf=\"description\" class=\"dbx-hint\">{{ description }}</div>\n</div>\n"]}

package/esm2020/lib/formly/field/checklist/checklist.item.field.content.default.component.mjs

@@ -35,4 +35,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImpor
         }], propDecorators: { displayContent: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tsaXN0Lml0ZW0uZmllbGQuY29udGVudC5kZWZhdWx0LmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1mb3JtL3NyYy9saWIvZm9ybWx5L2ZpZWxkL2NoZWNrbGlzdC9jaGVja2xpc3QuaXRlbS5maWVsZC5jb250ZW50LmRlZmF1bHQuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFHakQsZ0JBQWdCO0FBVWhCLE1BQU0sT0FBTyw0Q0FBNEM7SUFJdkQsSUFBSSxLQUFLO1FBQ1AsT0FBTyxJQUFJLENBQUMsY0FBYyxFQUFFLEtBQUssQ0FBQztJQUNwQyxDQUFDO0lBRUQsSUFBSSxRQUFRO1FBQ1YsT0FBTyxJQUFJLENBQUMsY0FBYyxFQUFFLFFBQVEsQ0FBQztJQUN2QyxDQUFDO0lBRUQsSUFBSSxXQUFXO1FBQ2IsT0FBTyxJQUFJLENBQUMsY0FBYyxFQUFFLFdBQVcsQ0FBQztJQUMxQyxDQUFDOzt5SUFkVSw0Q0FBNEM7NkhBQTVDLDRDQUE0QyxrR0FSN0M7Ozs7OztHQU1UOzJGQUVVLDRDQUE0QztrQkFUeEQsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUU7Ozs7OztHQU1UO2lCQUNGOzhCQUdDLGNBQWM7c0JBRGIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENoZWNrbGlzdEl0ZW1EaXNwbGF5Q29udGVudCwgQ2hlY2tsaXN0SXRlbUZpZWxkRGlzcGxheUNvbXBvbmVudCB9IGZyb20gJy4vY2hlY2tsaXN0Lml0ZW0nO1xuXG4vLyBNQVJLOiBEZWZhdWx0XG5AQ29tcG9uZW50KHtcbiAgdGVtcGxhdGU6IGBcbiAgICA8ZGl2ICpuZ0lmPVwiZGlzcGxheUNvbnRlbnRcIiBjbGFzcz1cImRieC1kZWZhdWx0LWNoZWNrbGlzdC1pdGVtLWZpZWxkXCI+XG4gICAgICA8ZGl2ICpuZ0lmPVwibGFiZWxcIiBjbGFzcz1cIml0ZW0tbGFiZWxcIj57eyBsYWJlbCB9fTwvZGl2PlxuICAgICAgPGRpdiAqbmdJZj1cInN1YmxhYmVsXCIgY2xhc3M9XCJpdGVtLXN1YmxhYmVsXCI+e3sgc3VibGFiZWwgfX08L2Rpdj5cbiAgICAgIDxkaXYgKm5nSWY9XCJkZXNjcmlwdGlvblwiIGNsYXNzPVwiZGJ4LWhpbnQgaXRlbS1kZXNjcmlwdGlvblwiPnt7IGRlc2NyaXB0aW9uIH19PC9kaXY+XG4gICAgPC9kaXY+XG4gIGBcbn0pXG5leHBvcnQgY2xhc3MgRGJ4RGVmYXVsdENoZWNrbGlzdEl0ZW1GaWVsZERpc3BsYXlDb21wb25lbnQ8VCA9IHVua25vd24+IGltcGxlbWVudHMgQ2hlY2tsaXN0SXRlbUZpZWxkRGlzcGxheUNvbXBvbmVudDxUPiB7XG4gIEBJbnB1dCgpXG4gIGRpc3BsYXlDb250ZW50ITogQ2hlY2tsaXN0SXRlbURpc3BsYXlDb250ZW50PFQ+O1xuXG4gIGdldCBsYWJlbCgpIHtcbiAgICByZXR1cm4gdGhpcy5kaXNwbGF5Q29udGVudD8ubGFiZWw7XG4gIH1cblxuICBnZXQgc3VibGFiZWwoKSB7XG4gICAgcmV0dXJuIHRoaXMuZGlzcGxheUNvbnRlbnQ/LnN1YmxhYmVsO1xuICB9XG5cbiAgZ2V0IGRlc2NyaXB0aW9uKCkge1xuICAgIHJldHVybiB0aGlzLmRpc3BsYXlDb250ZW50Py5kZXNjcmlwdGlvbjtcbiAgfVxufVxuIl19

package/esm2020/lib/formly/field/checklist/checklist.item.field.mjs

@@ -12,4 +12,4 @@ export function checklistItemField(config) {
     });
     return fieldConfig;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/formly/field/checklist/checklist.item.field.module.mjs

@@ -16,9 +16,7 @@ import * as i1 from "@ngx-formly/core";
 export class DbxFormFormlyChecklistItemFieldModule {
 }
 DbxFormFormlyChecklistItemFieldModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyChecklistItemFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-DbxFormFormlyChecklistItemFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyChecklistItemFieldModule, declarations: [DbxChecklistItemFieldComponent,
-        DbxChecklistItemContentComponent,
-        DbxDefaultChecklistItemFieldDisplayComponent], imports: [CommonModule,
+DbxFormFormlyChecklistItemFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyChecklistItemFieldModule, declarations: [DbxChecklistItemFieldComponent, DbxChecklistItemContentComponent, DbxDefaultChecklistItemFieldDisplayComponent], imports: [CommonModule,
         DbxTextModule,
         FormsModule,
         ReactiveFormsModule,
@@ -42,9 +40,7 @@ DbxFormFormlyChecklistItemFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVers
             DbxInjectionComponentModule,
             DbxFormFormlyWrapperModule,
             FormlyModule.forChild({
-                types: [
-                    { name: 'checklistitem', component: DbxChecklistItemFieldComponent }
-                ]
+                types: [{ name: 'checklistitem', component: DbxChecklistItemFieldComponent }]
             })
         ], DbxFormFormlyWrapperModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyChecklistItemFieldModule, decorators: [{
@@ -63,19 +59,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImpor
                         DbxInjectionComponentModule,
                         DbxFormFormlyWrapperModule,
                         FormlyModule.forChild({
-                            types: [
-                                { name: 'checklistitem', component: DbxChecklistItemFieldComponent }
-                            ]
+                            types: [{ name: 'checklistitem', component: DbxChecklistItemFieldComponent }]
                         })
                     ],
-                    declarations: [
-                        DbxChecklistItemFieldComponent,
-                        DbxChecklistItemContentComponent,
-                        DbxDefaultChecklistItemFieldDisplayComponent
-                    ],
-                    exports: [
-                        DbxFormFormlyWrapperModule
-                    ]
+                    declarations: [DbxChecklistItemFieldComponent, DbxChecklistItemContentComponent, DbxDefaultChecklistItemFieldDisplayComponent],
+                    exports: [DbxFormFormlyWrapperModule]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/formly/field/checklist/checklist.item.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tsaXN0Lml0ZW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZm9ybS9zcmMvbGliL2Zvcm1seS9maWVsZC9jaGVja2xpc3QvY2hlY2tsaXN0Lml0ZW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENsaWNrYWJsZUFuY2hvciB9IGZyb20gXCJAZGVyZWVrYi9kYngtY29yZVwiO1xuaW1wb3J0IHsgTWF5YmUgfSBmcm9tIFwiQGRlcmVla2IvdXRpbFwiO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gXCJyeGpzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2hlY2tsaXN0SXRlbURpc3BsYXlDb250ZW50PFQgPSB1bmtub3duPiB7XG4gIC8qKlxuICAgKiBMYWJlbCB0byBkaXNwbGF5LlxuICAgKi9cbiAgbGFiZWw/OiBNYXliZTxzdHJpbmc+O1xuICAvKipcbiAgICogU2Vjb25kYXJ5IGxhYmVsL3ZhbHVlIHRvIGRpc3BsYXkuIE1heSBiZSB1c2VkIGFzIHRoZSBzdHJpbmcgdmFsdWUuXG4gICAqL1xuICBzdWJsYWJlbD86IE1heWJlPHN0cmluZz47XG4gIC8qKlxuICAqIEhpbnQvZGVzY3JpcHRpb24gdG8gZGlzcGxheS5cbiAgKi9cbiAgZGVzY3JpcHRpb24/OiBNYXliZTxzdHJpbmc+O1xuICAvKipcbiAgICogV2hldGhlciBvciBub3QgdG8gZGlzcGxheSB0aGUgcmlwcGxlLiBJcyB0cnVlIGJ5IGRlZmF1bHQgaWYgdGhlIGFuY2hvciBpcyBwcmVzZW50LlxuICAgKi9cbiAgcmlwcGxlPzogTWF5YmU8Ym9vbGVhbj47XG4gIC8qKlxuICAgKiBPcHRpb25hbCBhbmNob3IgdG8gYXBwbHkgb24gdGhlIHZpc2libGUgY29udGVudC5cbiAgICovXG4gIGFuY2hvcj86IE1heWJlPENsaWNrYWJsZUFuY2hvcj47XG4gIC8qKlxuICAgKiBWYWx1ZSBtZXRhZGF0YS4gSG93IGl0IGlzIHVzZWQgZGVwZW5kcyBvbiB0aGUgZGlzcGxheSBjb21wb25lbnQgdXNlZC5cbiAgICovXG4gIG1ldGE/OiBNYXliZTxUPjtcbn1cblxuLyoqXG4gKiBDb21wb25lbnQgdXNlZCBmb3IgcmVuZGVyaW5nIGNoZWNrbGlzdCBjb250ZW50LlxuICogXG4gKiBDb250ZW50IGlzIGluamVjdGVkLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIENoZWNrbGlzdEl0ZW1GaWVsZERpc3BsYXlDb21wb25lbnQ8VCA9IHVua25vd24+IHtcbiAgZGlzcGxheUNvbnRlbnQ/OiBDaGVja2xpc3RJdGVtRGlzcGxheUNvbnRlbnQ8VD47XG59XG5cbmV4cG9ydCB0eXBlIENoZWNrbGlzdEl0ZW1GaWVsZERpc3BsYXlDb250ZW50T2JzPFQgPSB1bmtub3duPiA9IE9ic2VydmFibGU8Q2hlY2tsaXN0SXRlbURpc3BsYXlDb250ZW50PFQ+PjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tsaXN0Lml0ZW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZm9ybS9zcmMvbGliL2Zvcm1seS9maWVsZC9jaGVja2xpc3QvY2hlY2tsaXN0Lml0ZW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENsaWNrYWJsZUFuY2hvciB9IGZyb20gJ0BkZXJlZWtiL2RieC1jb3JlJztcbmltcG9ydCB7IE1heWJlIH0gZnJvbSAnQGRlcmVla2IvdXRpbCc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2hlY2tsaXN0SXRlbURpc3BsYXlDb250ZW50PFQgPSB1bmtub3duPiB7XG4gIC8qKlxuICAgKiBMYWJlbCB0byBkaXNwbGF5LlxuICAgKi9cbiAgbGFiZWw/OiBNYXliZTxzdHJpbmc+O1xuICAvKipcbiAgICogU2Vjb25kYXJ5IGxhYmVsL3ZhbHVlIHRvIGRpc3BsYXkuIE1heSBiZSB1c2VkIGFzIHRoZSBzdHJpbmcgdmFsdWUuXG4gICAqL1xuICBzdWJsYWJlbD86IE1heWJlPHN0cmluZz47XG4gIC8qKlxuICAgKiBIaW50L2Rlc2NyaXB0aW9uIHRvIGRpc3BsYXkuXG4gICAqL1xuICBkZXNjcmlwdGlvbj86IE1heWJlPHN0cmluZz47XG4gIC8qKlxuICAgKiBXaGV0aGVyIG9yIG5vdCB0byBkaXNwbGF5IHRoZSByaXBwbGUuIElzIHRydWUgYnkgZGVmYXVsdCBpZiB0aGUgYW5jaG9yIGlzIHByZXNlbnQuXG4gICAqL1xuICByaXBwbGU/OiBNYXliZTxib29sZWFuPjtcbiAgLyoqXG4gICAqIE9wdGlvbmFsIGFuY2hvciB0byBhcHBseSBvbiB0aGUgdmlzaWJsZSBjb250ZW50LlxuICAgKi9cbiAgYW5jaG9yPzogTWF5YmU8Q2xpY2thYmxlQW5jaG9yPjtcbiAgLyoqXG4gICAqIFZhbHVlIG1ldGFkYXRhLiBIb3cgaXQgaXMgdXNlZCBkZXBlbmRzIG9uIHRoZSBkaXNwbGF5IGNvbXBvbmVudCB1c2VkLlxuICAgKi9cbiAgbWV0YT86IE1heWJlPFQ+O1xufVxuXG4vKipcbiAqIENvbXBvbmVudCB1c2VkIGZvciByZW5kZXJpbmcgY2hlY2tsaXN0IGNvbnRlbnQuXG4gKlxuICogQ29udGVudCBpcyBpbmplY3RlZC5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDaGVja2xpc3RJdGVtRmllbGREaXNwbGF5Q29tcG9uZW50PFQgPSB1bmtub3duPiB7XG4gIGRpc3BsYXlDb250ZW50PzogQ2hlY2tsaXN0SXRlbURpc3BsYXlDb250ZW50PFQ+O1xufVxuXG5leHBvcnQgdHlwZSBDaGVja2xpc3RJdGVtRmllbGREaXNwbGF5Q29udGVudE9iczxUID0gdW5rbm93bj4gPSBPYnNlcnZhYmxlPENoZWNrbGlzdEl0ZW1EaXNwbGF5Q29udGVudDxUPj47XG4iXX0=

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

@@ -19,4 +19,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImpor
   `
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LmZpZWxkLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1mb3JtL3NyYy9saWIvZm9ybWx5L2ZpZWxkL2NvbXBvbmVudC9jb21wb25lbnQuZmllbGQuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFMUMsT0FBTyxFQUFFLFNBQVMsRUFBcUIsTUFBTSxrQkFBa0IsQ0FBQzs7O0FBYWhFLE1BQU0sT0FBTyw4QkFBNEMsU0FBUSxTQUErQztJQUU5RyxJQUFJLE1BQU07UUFDUixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsY0FBYyxDQUFDO0lBQ25DLENBQUM7OzJIQUpVLDhCQUE4QjsrR0FBOUIsOEJBQThCLDJFQUovQjs7R0FFVDsyRkFFVSw4QkFBOEI7a0JBTDFDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFOztHQUVUO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEYnhJbmplY3Rpb25Db21wb25lbnRDb25maWcgfSBmcm9tICdAZGVyZWVrYi9kYngtY29yZSc7XG5pbXBvcnQgeyBGaWVsZFR5cGUsIEZvcm1seUZpZWxkQ29uZmlnIH0gZnJvbSAnQG5neC1mb3JtbHkvY29yZSc7XG5cbmV4cG9ydCB0eXBlIERieEZvcm1Db21wb25lbnRGaWVsZENvbmZpZzxUPiA9IERieEluamVjdGlvbkNvbXBvbmVudENvbmZpZzxUPlxuXG5leHBvcnQgaW50ZXJmYWNlIERieEZvcm1Db21wb25lbnRGb3JtbHlGaWVsZENvbmZpZzxUID0gdW5rbm93bj4gZXh0ZW5kcyBGb3JtbHlGaWVsZENvbmZpZyB7XG4gIGNvbXBvbmVudEZpZWxkOiBEYnhGb3JtQ29tcG9uZW50RmllbGRDb25maWc8VD47XG59XG5cbkBDb21wb25lbnQoe1xuICB0ZW1wbGF0ZTogYFxuICAgIDxkaXYgY2xhc3M9XCJkYngtZm9ybS1jb21wb25lbnRcIiBkYngtaW5qZWN0aW9uIFtjb25maWddPVwiY29uZmlnXCI+PC9kaXY+XG4gIGBcbn0pXG5leHBvcnQgY2xhc3MgRGJ4Rm9ybUNvbXBvbmVudEZpZWxkQ29tcG9uZW50PFQgPSB1bmtub3duPiBleHRlbmRzIEZpZWxkVHlwZTxEYnhGb3JtQ29tcG9uZW50Rm9ybWx5RmllbGRDb25maWc8VD4+IHtcblxuICBnZXQgY29uZmlnKCk6IERieEluamVjdGlvbkNvbXBvbmVudENvbmZpZzxUPiB7XG4gICAgcmV0dXJuIHRoaXMuZmllbGQuY29tcG9uZW50RmllbGQ7XG4gIH1cblxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LmZpZWxkLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1mb3JtL3NyYy9saWIvZm9ybWx5L2ZpZWxkL2NvbXBvbmVudC9jb21wb25lbnQuZmllbGQuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFMUMsT0FBTyxFQUFFLFNBQVMsRUFBcUIsTUFBTSxrQkFBa0IsQ0FBQzs7O0FBYWhFLE1BQU0sT0FBTyw4QkFBNEMsU0FBUSxTQUErQztJQUM5RyxJQUFJLE1BQU07UUFDUixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsY0FBYyxDQUFDO0lBQ25DLENBQUM7OzJIQUhVLDhCQUE4QjsrR0FBOUIsOEJBQThCLDJFQUovQjs7R0FFVDsyRkFFVSw4QkFBOEI7a0JBTDFDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFOztHQUVUO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEYnhJbmplY3Rpb25Db21wb25lbnRDb25maWcgfSBmcm9tICdAZGVyZWVrYi9kYngtY29yZSc7XG5pbXBvcnQgeyBGaWVsZFR5cGUsIEZvcm1seUZpZWxkQ29uZmlnIH0gZnJvbSAnQG5neC1mb3JtbHkvY29yZSc7XG5cbmV4cG9ydCB0eXBlIERieEZvcm1Db21wb25lbnRGaWVsZENvbmZpZzxUPiA9IERieEluamVjdGlvbkNvbXBvbmVudENvbmZpZzxUPjtcblxuZXhwb3J0IGludGVyZmFjZSBEYnhGb3JtQ29tcG9uZW50Rm9ybWx5RmllbGRDb25maWc8VCA9IHVua25vd24+IGV4dGVuZHMgRm9ybWx5RmllbGRDb25maWcge1xuICBjb21wb25lbnRGaWVsZDogRGJ4Rm9ybUNvbXBvbmVudEZpZWxkQ29uZmlnPFQ+O1xufVxuXG5AQ29tcG9uZW50KHtcbiAgdGVtcGxhdGU6IGBcbiAgICA8ZGl2IGNsYXNzPVwiZGJ4LWZvcm0tY29tcG9uZW50XCIgZGJ4LWluamVjdGlvbiBbY29uZmlnXT1cImNvbmZpZ1wiPjwvZGl2PlxuICBgXG59KVxuZXhwb3J0IGNsYXNzIERieEZvcm1Db21wb25lbnRGaWVsZENvbXBvbmVudDxUID0gdW5rbm93bj4gZXh0ZW5kcyBGaWVsZFR5cGU8RGJ4Rm9ybUNvbXBvbmVudEZvcm1seUZpZWxkQ29uZmlnPFQ+PiB7XG4gIGdldCBjb25maWcoKTogRGJ4SW5qZWN0aW9uQ29tcG9uZW50Q29uZmlnPFQ+IHtcbiAgICByZXR1cm4gdGhpcy5maWVsZC5jb21wb25lbnRGaWVsZDtcbiAgfVxufVxuIl19

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

@@ -4,4 +4,4 @@ export function componentField(config) {
         componentField: config
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LmZpZWxkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZvcm0vc3JjL2xpYi9mb3JtbHkvZmllbGQvY29tcG9uZW50L2NvbXBvbmVudC5maWVsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLFVBQVUsY0FBYyxDQUFjLE1BQStCO0lBQ3pFLE9BQU87UUFDTCxJQUFJLEVBQUUsV0FBVztRQUNqQixjQUFjLEVBQUUsTUFBTTtLQUN2QixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERieEZvcm1Db21wb25lbnRGaWVsZENvbmZpZywgRGJ4Rm9ybUNvbXBvbmVudEZvcm1seUZpZWxkQ29uZmlnIH0gZnJvbSBcIi4vY29tcG9uZW50LmZpZWxkLmNvbXBvbmVudFwiO1xuXG5leHBvcnQgdHlwZSBDb21wb25lbnRGaWVsZENvbmZpZzxUID0gdW5rbm93bj4gPSBEYnhGb3JtQ29tcG9uZW50RmllbGRDb25maWc8VD5cblxuZXhwb3J0IGZ1bmN0aW9uIGNvbXBvbmVudEZpZWxkPFQgPSB1bmtub3duPihjb25maWc6IENvbXBvbmVudEZpZWxkQ29uZmlnPFQ+KTogRGJ4Rm9ybUNvbXBvbmVudEZvcm1seUZpZWxkQ29uZmlnPFQ+IHtcbiAgcmV0dXJuIHtcbiAgICB0eXBlOiAnY29tcG9uZW50JyxcbiAgICBjb21wb25lbnRGaWVsZDogY29uZmlnXG4gIH07XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LmZpZWxkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZvcm0vc3JjL2xpYi9mb3JtbHkvZmllbGQvY29tcG9uZW50L2NvbXBvbmVudC5maWVsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLFVBQVUsY0FBYyxDQUFjLE1BQStCO0lBQ3pFLE9BQU87UUFDTCxJQUFJLEVBQUUsV0FBVztRQUNqQixjQUFjLEVBQUUsTUFBTTtLQUN2QixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERieEZvcm1Db21wb25lbnRGaWVsZENvbmZpZywgRGJ4Rm9ybUNvbXBvbmVudEZvcm1seUZpZWxkQ29uZmlnIH0gZnJvbSAnLi9jb21wb25lbnQuZmllbGQuY29tcG9uZW50JztcblxuZXhwb3J0IHR5cGUgQ29tcG9uZW50RmllbGRDb25maWc8VCA9IHVua25vd24+ID0gRGJ4Rm9ybUNvbXBvbmVudEZpZWxkQ29uZmlnPFQ+O1xuXG5leHBvcnQgZnVuY3Rpb24gY29tcG9uZW50RmllbGQ8VCA9IHVua25vd24+KGNvbmZpZzogQ29tcG9uZW50RmllbGRDb25maWc8VD4pOiBEYnhGb3JtQ29tcG9uZW50Rm9ybWx5RmllbGRDb25maWc8VD4ge1xuICByZXR1cm4ge1xuICAgIHR5cGU6ICdjb21wb25lbnQnLFxuICAgIGNvbXBvbmVudEZpZWxkOiBjb25maWdcbiAgfTtcbn1cbiJdfQ==

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

@@ -14,9 +14,7 @@ DbxFormFormlyComponentFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion:
             CommonModule,
             DbxInjectionComponentModule,
             FormlyModule.forChild({
-                types: [
-                    { name: 'component', component: DbxFormComponentFieldComponent }
-                ]
+                types: [{ name: 'component', component: DbxFormComponentFieldComponent }]
             })
         ]] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyComponentFieldModule, decorators: [{
@@ -26,17 +24,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImpor
                         CommonModule,
                         DbxInjectionComponentModule,
                         FormlyModule.forChild({
-                            types: [
-                                { name: 'component', component: DbxFormComponentFieldComponent }
-                            ]
+                            types: [{ name: 'component', component: DbxFormComponentFieldComponent }]
                         })
                     ],
-                    declarations: [
-                        DbxFormComponentFieldComponent
-                    ],
-                    exports: [
-                        DbxFormComponentFieldComponent
-                    ]
+                    declarations: [DbxFormComponentFieldComponent],
+                    exports: [DbxFormComponentFieldComponent]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -16,7 +16,9 @@ export function templateOptionsForFieldConfig(fieldConfig, override) {
     };
 }
 export function templateOptionsValueForFieldConfig(fieldConfig, override) {
-    const { label, placeholder, required, readonly, description, autocomplete } = mergeObjects([fieldConfig, override], { keysFilter: ['label', 'placeholder', 'required', 'readonly', 'description', 'autocomplete'] });
+    const { label, placeholder, required, readonly, description, autocomplete } = mergeObjects([fieldConfig, override], {
+        keysFilter: ['label', 'placeholder', 'required', 'readonly', 'description', 'autocomplete']
+    });
     const attributes = mergeObjects([fieldConfig.attributes, override?.attributes]);
     const result = filterFromPOJO({
         ...override,
@@ -51,4 +53,4 @@ export function disableFormlyFieldAutofillAttributes() {
         autocomplete: 'off'
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -10,35 +10,14 @@ import * as i0 from "@angular/core";
 export class DbxFormFormlyFieldModule {
 }
 DbxFormFormlyFieldModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-DbxFormFormlyFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyFieldModule, imports: [CommonModule], exports: [DbxFormFormlyChecklistItemFieldModule,
-        DbxFormFormlyComponentFieldModule,
-        DbxFormFormlySelectionModule,
-        DbxFormFormlyTextEditorFieldModule,
-        DbxFormFormlyValueModule,
-        DbxFormFormlyWrapperModule] });
-DbxFormFormlyFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyFieldModule, imports: [[
-            CommonModule
-        ], DbxFormFormlyChecklistItemFieldModule,
-        DbxFormFormlyComponentFieldModule,
-        DbxFormFormlySelectionModule,
-        DbxFormFormlyTextEditorFieldModule,
-        DbxFormFormlyValueModule,
-        DbxFormFormlyWrapperModule] });
+DbxFormFormlyFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyFieldModule, imports: [CommonModule], exports: [DbxFormFormlyChecklistItemFieldModule, DbxFormFormlyComponentFieldModule, DbxFormFormlySelectionModule, DbxFormFormlyTextEditorFieldModule, DbxFormFormlyValueModule, DbxFormFormlyWrapperModule] });
+DbxFormFormlyFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyFieldModule, imports: [[CommonModule], DbxFormFormlyChecklistItemFieldModule, DbxFormFormlyComponentFieldModule, DbxFormFormlySelectionModule, DbxFormFormlyTextEditorFieldModule, DbxFormFormlyValueModule, DbxFormFormlyWrapperModule] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFormFormlyFieldModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [
-                        CommonModule
-                    ],
+                    imports: [CommonModule],
                     declarations: [],
-                    exports: [
-                        DbxFormFormlyChecklistItemFieldModule,
-                        DbxFormFormlyComponentFieldModule,
-                        DbxFormFormlySelectionModule,
-                        DbxFormFormlyTextEditorFieldModule,
-                        DbxFormFormlyValueModule,
-                        DbxFormFormlyWrapperModule
-                    ]
+                    exports: [DbxFormFormlyChecklistItemFieldModule, DbxFormFormlyComponentFieldModule, DbxFormFormlySelectionModule, DbxFormFormlyTextEditorFieldModule, DbxFormFormlyValueModule, DbxFormFormlyWrapperModule]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/formly/field/selection/pickable/index.mjs

@@ -4,4 +4,4 @@ export * from './pickable.field.module';
 export * from './pickable.list.field.component';
 export * from './pickable.field';
 export * from './pickable';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZm9ybS9zcmMvbGliL2Zvcm1seS9maWVsZC9zZWxlY3Rpb24vcGlja2FibGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9waWNrYWJsZS5jaGlwLmZpZWxkLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3BpY2thYmxlLmZpZWxkLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3BpY2thYmxlLmZpZWxkLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3BpY2thYmxlLmxpc3QuZmllbGQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcGlja2FibGUuZmllbGQnO1xuZXhwb3J0ICogZnJvbSAnLi9waWNrYWJsZSc7Il19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZm9ybS9zcmMvbGliL2Zvcm1seS9maWVsZC9zZWxlY3Rpb24vcGlja2FibGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9waWNrYWJsZS5jaGlwLmZpZWxkLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3BpY2thYmxlLmZpZWxkLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3BpY2thYmxlLmZpZWxkLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL3BpY2thYmxlLmxpc3QuZmllbGQuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vcGlja2FibGUuZmllbGQnO1xuZXhwb3J0ICogZnJvbSAnLi9waWNrYWJsZSc7XG4iXX0=

package/esm2020/lib/formly/field/selection/pickable/pickable.chip.field.component.mjs

@@ -1,5 +1,5 @@
-import { Component } from "@angular/core";
-import { AbstractDbxPickableItemFieldDirective } from "./pickable.field.directive";
+import { Component } from '@angular/core';
+import { AbstractDbxPickableItemFieldDirective } from './pickable.field.directive';
 import * as i0 from "@angular/core";
 import * as i1 from "@dereekb/dbx-web";
 import * as i2 from "@angular/material/chips";
@@ -24,9 +24,9 @@ export class DbxPickableChipListFieldComponent extends AbstractDbxPickableItemFi
     }
 }
 DbxPickableChipListFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxPickableChipListFieldComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
-DbxPickableChipListFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: DbxPickableChipListFieldComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: "<div class=\"dbx-pickable-item-field\">\n  <dbx-loading [context]=\"context\" [linear]=\"true\">\n    <ng-container *ngIf=\"showFilterInput\">\n      <ng-container *ngTemplateOutlet=\"filterTemplate\"></ng-container>\n    </ng-container>\n    <!-- Content -->\n    <div class=\"dbx-pickable-item-field-chips\">\n      <mat-chip-list [required]=\"required\" [selectable]=\"!isReadonlyOrDisabled\" #chipList>\n        <mat-chip *ngFor=\"let item of items$ | async\" (click)=\"itemClicked(item)\" [selected]=\"item.selected\"\n          [disabled]=\"isReadonlyOrDisabled || item.disabled\">\n          <span class=\"dbx-chip-label\">{{ item.itemValue.label }}</span>\n          <span class=\"dbx-chip-sublabel\" *ngIf=\"item.itemValue.sublabel\">{{ item.itemValue.sublabel }}</span>\n        </mat-chip>\n      </mat-chip-list>\n      <dbx-injection [config]=\"footerConfig\"></dbx-injection>\n    </div>\n  </dbx-loading>\n</div>\n\n<!-- Filter Input -->\n<ng-template #filterTemplate>\n  <div class=\"dbx-pickable-item-field-filter\">\n    <div class=\"dbx-label\">{{ filterLabel }}</div>\n    <input [name]=\"name\" autocomplete=\"{{ autocomplete }}\" #filterMatInput=\"matInput\" matInput\n      [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\">\n    <mat-divider></mat-divider>\n    <dbx-loading [linear]=\"true\" [context]=\"filterResultsContext\"></dbx-loading>\n    <!-- No items found. -->\n    <p *ngIf=\"noItemsAvailable$ | async\" class=\"dbx-label\">No items match this filter.</p>\n  </div>\n</ng-template>\n", components: [{ type: i1.DbxLoadingComponent, selector: "dbx-loading", inputs: ["show", "text", "mode", "color", "diameter", "linear", "context", "loading", "error"] }, { type: i2.MatChipList, selector: "mat-chip-list", inputs: ["errorStateMatcher", "multiple", "compareWith", "value", "required", "placeholder", "disabled", "aria-orientation", "selectable", "tabIndex"], outputs: ["change", "valueChange"], exportAs: ["matChipList"] }, { type: i3.DbxInjectionComponent, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: ["config", "template"] }, { type: i4.MatDivider, selector: "mat-divider", inputs: ["vertical", "inset"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.MatChip, selector: "mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]", inputs: ["color", "disableRipple", "tabIndex", "selected", "value", "selectable", "disabled", "removable"], outputs: ["selectionChange", "destroyed", "removed"], exportAs: ["matChip"] }, { type: i6.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i7.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i7.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i7.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }], pipes: { "async": i5.AsyncPipe } });
+DbxPickableChipListFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: DbxPickableChipListFieldComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: "<div class=\"dbx-pickable-item-field\">\n  <dbx-loading [context]=\"context\" [linear]=\"true\">\n    <ng-container *ngIf=\"showFilterInput\">\n      <ng-container *ngTemplateOutlet=\"filterTemplate\"></ng-container>\n    </ng-container>\n    <!-- Content -->\n    <div class=\"dbx-pickable-item-field-chips\">\n      <mat-chip-list [required]=\"required\" [selectable]=\"!isReadonlyOrDisabled\" #chipList>\n        <mat-chip *ngFor=\"let item of items$ | async\" (click)=\"itemClicked(item)\" [selected]=\"item.selected\" [disabled]=\"isReadonlyOrDisabled || item.disabled\">\n          <span class=\"dbx-chip-label\">{{ item.itemValue.label }}</span>\n          <span class=\"dbx-chip-sublabel\" *ngIf=\"item.itemValue.sublabel\">{{ item.itemValue.sublabel }}</span>\n        </mat-chip>\n      </mat-chip-list>\n      <dbx-injection [config]=\"footerConfig\"></dbx-injection>\n    </div>\n  </dbx-loading>\n</div>\n\n<!-- Filter Input -->\n<ng-template #filterTemplate>\n  <div class=\"dbx-pickable-item-field-filter\">\n    <div class=\"dbx-label\">{{ filterLabel }}</div>\n    <input [name]=\"name\" autocomplete=\"{{ autocomplete }}\" #filterMatInput=\"matInput\" matInput [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" />\n    <mat-divider></mat-divider>\n    <dbx-loading [linear]=\"true\" [context]=\"filterResultsContext\"></dbx-loading>\n    <!-- No items found. -->\n    <p *ngIf=\"noItemsAvailable$ | async\" class=\"dbx-label\">No items match this filter.</p>\n  </div>\n</ng-template>\n", components: [{ type: i1.DbxLoadingComponent, selector: "dbx-loading", inputs: ["show", "text", "mode", "color", "diameter", "linear", "context", "loading", "error"] }, { type: i2.MatChipList, selector: "mat-chip-list", inputs: ["errorStateMatcher", "multiple", "compareWith", "value", "required", "placeholder", "disabled", "aria-orientation", "selectable", "tabIndex"], outputs: ["change", "valueChange"], exportAs: ["matChipList"] }, { type: i3.DbxInjectionComponent, selector: "dbx-injection, [dbxInjection], [dbx-injection]", inputs: ["config", "template"] }, { type: i4.MatDivider, selector: "mat-divider", inputs: ["vertical", "inset"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.MatChip, selector: "mat-basic-chip, [mat-basic-chip], mat-chip, [mat-chip]", inputs: ["color", "disableRipple", "tabIndex", "selected", "value", "selectable", "disabled", "removable"], outputs: ["selectionChange", "destroyed", "removed"], exportAs: ["matChip"] }, { type: i6.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { type: i7.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i7.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i7.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }], pipes: { "async": i5.AsyncPipe } });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxPickableChipListFieldComponent, decorators: [{
             type: Component,
-            args: [{ template: "<div class=\"dbx-pickable-item-field\">\n  <dbx-loading [context]=\"context\" [linear]=\"true\">\n    <ng-container *ngIf=\"showFilterInput\">\n      <ng-container *ngTemplateOutlet=\"filterTemplate\"></ng-container>\n    </ng-container>\n    <!-- Content -->\n    <div class=\"dbx-pickable-item-field-chips\">\n      <mat-chip-list [required]=\"required\" [selectable]=\"!isReadonlyOrDisabled\" #chipList>\n        <mat-chip *ngFor=\"let item of items$ | async\" (click)=\"itemClicked(item)\" [selected]=\"item.selected\"\n          [disabled]=\"isReadonlyOrDisabled || item.disabled\">\n          <span class=\"dbx-chip-label\">{{ item.itemValue.label }}</span>\n          <span class=\"dbx-chip-sublabel\" *ngIf=\"item.itemValue.sublabel\">{{ item.itemValue.sublabel }}</span>\n        </mat-chip>\n      </mat-chip-list>\n      <dbx-injection [config]=\"footerConfig\"></dbx-injection>\n    </div>\n  </dbx-loading>\n</div>\n\n<!-- Filter Input -->\n<ng-template #filterTemplate>\n  <div class=\"dbx-pickable-item-field-filter\">\n    <div class=\"dbx-label\">{{ filterLabel }}</div>\n    <input [name]=\"name\" autocomplete=\"{{ autocomplete }}\" #filterMatInput=\"matInput\" matInput\n      [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\">\n    <mat-divider></mat-divider>\n    <dbx-loading [linear]=\"true\" [context]=\"filterResultsContext\"></dbx-loading>\n    <!-- No items found. -->\n    <p *ngIf=\"noItemsAvailable$ | async\" class=\"dbx-label\">No items match this filter.</p>\n  </div>\n</ng-template>\n" }]
+            args: [{ template: "<div class=\"dbx-pickable-item-field\">\n  <dbx-loading [context]=\"context\" [linear]=\"true\">\n    <ng-container *ngIf=\"showFilterInput\">\n      <ng-container *ngTemplateOutlet=\"filterTemplate\"></ng-container>\n    </ng-container>\n    <!-- Content -->\n    <div class=\"dbx-pickable-item-field-chips\">\n      <mat-chip-list [required]=\"required\" [selectable]=\"!isReadonlyOrDisabled\" #chipList>\n        <mat-chip *ngFor=\"let item of items$ | async\" (click)=\"itemClicked(item)\" [selected]=\"item.selected\" [disabled]=\"isReadonlyOrDisabled || item.disabled\">\n          <span class=\"dbx-chip-label\">{{ item.itemValue.label }}</span>\n          <span class=\"dbx-chip-sublabel\" *ngIf=\"item.itemValue.sublabel\">{{ item.itemValue.sublabel }}</span>\n        </mat-chip>\n      </mat-chip-list>\n      <dbx-injection [config]=\"footerConfig\"></dbx-injection>\n    </div>\n  </dbx-loading>\n</div>\n\n<!-- Filter Input -->\n<ng-template #filterTemplate>\n  <div class=\"dbx-pickable-item-field-filter\">\n    <div class=\"dbx-label\">{{ filterLabel }}</div>\n    <input [name]=\"name\" autocomplete=\"{{ autocomplete }}\" #filterMatInput=\"matInput\" matInput [placeholder]=\"placeholder\" [formControl]=\"inputCtrl\" />\n    <mat-divider></mat-divider>\n    <dbx-loading [linear]=\"true\" [context]=\"filterResultsContext\"></dbx-loading>\n    <!-- No items found. -->\n    <p *ngIf=\"noItemsAvailable$ | async\" class=\"dbx-label\">No items match this filter.</p>\n  </div>\n</ng-template>\n" }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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