novo-elements 7.6.0 → 7.7.0-next.2

package/esm2020/src/elements/field/formats/date-time-format.mjs

@@ -0,0 +1,255 @@
+import { Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, Optional, Renderer2 } from '@angular/core';
+import { COMPOSITION_BUFFER_MODE, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { IMaskDirective, IMaskFactory } from 'angular-imask';
+import { format, isValid, parse } from 'date-fns';
+import * as IMask from 'imask';
+import { NovoLabelService } from '../../../services/novo-label-service';
+import { DATE_FORMATS, NOVO_INPUT_FORMAT } from './base-format';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-imask";
+import * as i2 from "../../../services/novo-label-service";
+export const DATETIMEFORMAT_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => NovoDateTimeFormatDirective),
+    multi: true,
+};
+export class NovoDateTimeFormatDirective extends IMaskDirective {
+    constructor(_element, _renderer, _factory, _compositionMode, labels) {
+        super(_element, _renderer, _factory, _compositionMode);
+        this._element = _element;
+        this.labels = labels;
+        this.valueChange = new EventEmitter();
+        this.military = false;
+        this.dateTimeFormat = DATE_FORMATS.DATE;
+        this.initFormatOptions();
+    }
+    initFormatOptions() {
+        const amFormat = this.labels.timeFormatAM.toUpperCase();
+        const pmFormat = this.labels.timeFormatPM.toUpperCase();
+        this.unmask = 'typed';
+        this.imask = {
+            mask: Date,
+            pattern: this.military ? 'm{/}`d{/}`Y, HH:mm' : 'm{/}`d{/}`Y, HH:mm aa',
+            overwrite: true,
+            autofix: true,
+            lazy: false,
+            min: new Date(1900, 0, 1),
+            max: new Date(2030, 0, 1),
+            prepare: (str) => str.toUpperCase(),
+            format: (date) => {
+                const test1 = this.formatValue(date);
+                return test1;
+            },
+            parse: (str) => {
+                const test = parse(str);
+                return test;
+            },
+            blocks: {
+                d: {
+                    mask: IMask.MaskedRange,
+                    placeholderChar: 'D',
+                    from: 1,
+                    to: 31,
+                    maxLength: 2,
+                },
+                m: {
+                    mask: IMask.MaskedRange,
+                    placeholderChar: 'M',
+                    from: 1,
+                    to: 12,
+                    maxLength: 2,
+                },
+                Y: {
+                    mask: IMask.MaskedRange,
+                    placeholderChar: 'Y',
+                    from: 1900,
+                    to: 9999,
+                },
+                HH: {
+                    mask: IMask.MaskedRange,
+                    placeholderChar: '-',
+                    maxLength: 2,
+                    from: 0,
+                    to: 23,
+                },
+                hh: {
+                    mask: IMask.MaskedRange,
+                    placeholderChar: '-',
+                    maxLength: 2,
+                    from: 1,
+                    to: 12,
+                },
+                mm: {
+                    mask: IMask.MaskedRange,
+                    placeholderChar: '-',
+                    maxLength: 2,
+                    from: 0,
+                    to: 59,
+                },
+                ss: {
+                    mask: IMask.MaskedRange,
+                    placeholderChar: '-',
+                    maxLength: 2,
+                    from: 0,
+                    to: 59,
+                },
+                aa: {
+                    mask: IMask.MaskedEnum,
+                    placeholderChar: '-',
+                    enum: ['AM', 'PM', 'am', 'pm', amFormat, pmFormat],
+                },
+            },
+        };
+    }
+    ngOnChanges(changes) {
+        if (Object.keys(changes).some((key) => ['military', 'dateFormat'].includes(key))) {
+            this.initFormatOptions();
+        }
+    }
+    _checkInput(event) {
+        if (document.activeElement === event.target) {
+            const text = event.target.value;
+            const dateTime = text.split(', ');
+            const hour = dateTime[1].slice(0, 2);
+            if ((this.military && Number(dateTime[1][0]) > 2) || (!this.military && Number(dateTime[1][0]) > 1)) {
+                event.preventDefault();
+                const value = `0${dateTime[1]}`;
+                event.target.value = value;
+                // this.onChange(value);
+            }
+            if (!this.military) {
+                const input = dateTime[1].substr(5, 4).replace(/\-/g, '').trim().slice(0, 2);
+                const timePeriod = this.imask.blocks.aa.enum.find((it) => it[0] === input[0]);
+                if (timePeriod) {
+                    event.target.value = `${dateTime[0]}, ${dateTime[1].slice(0, 5)} ${timePeriod}`;
+                }
+                if (event.target.selectionStart >= 3 && this.hourOneFormatRequired(hour)) {
+                    event.target.value = `${dateTime[0]}, 01:${event.target.value.slice(3, event.target.value.length)}`;
+                }
+            }
+        }
+    }
+    _handleBlur(event) {
+        const text = event.target.value;
+        const dateTime = text.split(', ');
+        const hour = dateTime[1].slice(0, 2);
+        if (!this.military) {
+            const input = dateTime[1].substr(17, 4).replace(/\-/g, '').trim().slice(0, 2);
+            const timePeriod = this.imask.blocks.aa.enum.find((it) => it[0] === input[0]);
+            if (this.hourOneFormatRequired(hour)) {
+                event.target.value = `${dateTime[0]}, 01:${dateTime[1].slice(3, dateTime[1].length)}`;
+            }
+            if (!timePeriod) {
+                event.target.value = `${dateTime[0]}, ${dateTime[1].slice(0, 5)} --`;
+            }
+        }
+    }
+    _handleKeydown(event) {
+        const input = event.target;
+        const dateTime = input.value.split(', ');
+        const hour = dateTime[1].slice(0, 2);
+        if (event.key === "Backspace" /* Backspace */ && input.selectionStart === dateTime[1].length) {
+            event.target.value = `${dateTime[1].slice(0, 5)} --`;
+        }
+        else if (event.key === "Tab" /* Tab */ && input.selectionStart <= 2 && this.hourOneFormatRequired(hour)) {
+            event.preventDefault();
+            event.stopPropagation();
+            event.stopImmediatePropagation();
+            input.value = `${dateTime[0]}, 01:${dateTime[1].slice(3, dateTime[1].length)}`;
+            input.setSelectionRange(15, 15);
+        }
+        else if (event.key === "ArrowRight" /* ArrowRight */ && input.selectionStart >= 2 && this.hourOneFormatRequired(hour)) {
+            input.value = `${dateTime[0]}, 01:${dateTime[1].slice(3, dateTime[1].length)}`;
+            input.setSelectionRange(14, 14);
+        }
+    }
+    normalize(value) {
+        const pattern = this.labels.dateFormat.toUpperCase();
+        return format(parse(value), pattern);
+    }
+    formatAsIso(date) {
+        if (date && isValid(date)) {
+            return date.toISOString();
+        }
+        return null;
+    }
+    convertTime12to24(time12h) {
+        const pmFormat = this.labels.timeFormatPM.toUpperCase();
+        const [time, meridian] = time12h.split(' ');
+        let [hours, minutes] = time.split(':');
+        if (hours === '12') {
+            hours = '00';
+        }
+        if (['PM', pmFormat].includes(meridian)) {
+            hours = `${parseInt(hours, 10) + 12}`.padStart(2, '0');
+        }
+        return `${hours}:${minutes}`;
+    }
+    convertTime24to12(time24h) {
+        if (time24h.length === 5) {
+            const date = parse(`2020-01-01T${time24h}`);
+            return format(date, 'hh:mm A');
+        }
+        return time24h;
+    }
+    formatValue(value) {
+        if (value == null)
+            return '';
+        // Use `parse` because it keeps dates in locale
+        const date = parse(value);
+        if (isValid(date)) {
+            const dateFormat = `${this.labels.dateFormat.toUpperCase()}, ${this.military ? 'HH:mm' : 'hh:mm A'}`;
+            return format(date, dateFormat);
+        }
+        return this.normalize(value);
+    }
+    writeValue(value) {
+        super.writeValue(this.formatValue(value));
+    }
+    registerOnChange(fn) {
+        this.onChange = (date) => {
+            let formatted = date;
+            switch (this.dateTimeFormat) {
+                case DATE_FORMATS.ISO8601:
+                    formatted = this.formatAsIso(date);
+                    break;
+                case DATE_FORMATS.STRING:
+                    formatted = this.formatValue(date);
+                    break;
+                default:
+                    formatted = date;
+                    break;
+            }
+            this.valueChange.emit(date);
+            fn(formatted);
+        };
+    }
+    hourOneFormatRequired(hourInput) {
+        return hourInput === '-1' || hourInput === '1-';
+    }
+}
+NovoDateTimeFormatDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoDateTimeFormatDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.IMaskFactory }, { token: COMPOSITION_BUFFER_MODE, optional: true }, { token: i2.NovoLabelService }], target: i0.ɵɵFactoryTarget.Directive });
+NovoDateTimeFormatDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: NovoDateTimeFormatDirective, selector: "input[dateTimeFormat]", inputs: { military: "military", dateTimeFormat: "dateTimeFormat" }, host: { listeners: { "input": "_checkInput($event)", "blur": "_handleBlur($event)", "keydown": "_handleKeydown($event)" }, classAttribute: "novo-date-time-format" }, providers: [DATETIMEFORMAT_VALUE_ACCESSOR, { provide: NOVO_INPUT_FORMAT, useExisting: NovoDateTimeFormatDirective }], usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: NovoDateTimeFormatDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[dateTimeFormat]',
+                    host: {
+                        class: 'novo-date-time-format',
+                        '(input)': '_checkInput($event)',
+                        '(blur)': '_handleBlur($event)',
+                        '(keydown)': '_handleKeydown($event)',
+                    },
+                    providers: [DATETIMEFORMAT_VALUE_ACCESSOR, { provide: NOVO_INPUT_FORMAT, useExisting: NovoDateTimeFormatDirective }],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.IMaskFactory }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [COMPOSITION_BUFFER_MODE]
+                }] }, { type: i2.NovoLabelService }]; }, propDecorators: { military: [{
+                type: Input
+            }], dateTimeFormat: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time-format.js","sourceRoot":"","sources":["../../../../../../../projects/novo-elements/src/elements/field/formats/date-time-format.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, EventEmitter, forwardRef, Inject, Input, Optional, Renderer2, SimpleChanges, OnChanges, LOCALE_ID } from '@angular/core';\nimport { COMPOSITION_BUFFER_MODE, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { IMaskDirective, IMaskFactory } from 'angular-imask';\nimport { format, isValid, parse } from 'date-fns';\nimport * as IMask from 'imask';\nimport { NovoLabelService } from '../../../services/novo-label-service';\nimport { NovoInputFormat, DATE_FORMATS, NOVO_INPUT_FORMAT } from './base-format';\nimport { Key } from '../../../utils';\n\nexport const DATETIMEFORMAT_VALUE_ACCESSOR = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => NovoDateTimeFormatDirective),\n  multi: true,\n};\n\n@Directive({\n  selector: 'input[dateTimeFormat]',\n  host: {\n    class: 'novo-date-time-format',\n    '(input)': '_checkInput($event)',\n    '(blur)': '_handleBlur($event)',\n    '(keydown)': '_handleKeydown($event)',\n  },\n  providers: [DATETIMEFORMAT_VALUE_ACCESSOR, { provide: NOVO_INPUT_FORMAT, useExisting: NovoDateTimeFormatDirective }],\n})\nexport class NovoDateTimeFormatDirective extends IMaskDirective<any> implements NovoInputFormat, OnChanges {\n  valueChange: EventEmitter<any> = new EventEmitter();\n\n  @Input() military: boolean = false;\n  @Input() dateTimeFormat: DATE_FORMATS = DATE_FORMATS.DATE;\n\n  constructor(\n    private _element: ElementRef,\n    _renderer: Renderer2,\n    _factory: IMaskFactory,\n    @Optional() @Inject(COMPOSITION_BUFFER_MODE) _compositionMode: boolean,\n    private labels: NovoLabelService,\n  ) {\n    super(_element, _renderer, _factory, _compositionMode);\n    this.initFormatOptions();\n    \n  }\n\n  initFormatOptions() {\n    const amFormat = this.labels.timeFormatAM.toUpperCase();\n    const pmFormat = this.labels.timeFormatPM.toUpperCase();\n\n    this.unmask = 'typed';\n    this.imask = {\n      mask: Date,\n      pattern: this.military ? 'm{/}`d{/}`Y, HH:mm' : 'm{/}`d{/}`Y, HH:mm aa',\n      overwrite: true,\n      autofix: true,\n      lazy: false,\n      min: new Date(1900, 0, 1),\n      max: new Date(2030, 0, 1),\n      prepare: (str) => str.toUpperCase(),\n      format: (date) => {\n        const test1 = this.formatValue(date)\n        return test1;\n    },\n      parse: (str) => {\n        const test = parse(str);\n\n        return test;\n      },\n      blocks: {\n        d: {\n          mask: IMask.MaskedRange,\n          placeholderChar: 'D',\n          from: 1,\n          to: 31,\n          maxLength: 2,\n        },\n        m: {\n          mask: IMask.MaskedRange,\n          placeholderChar: 'M',\n          from: 1,\n          to: 12,\n          maxLength: 2,\n        },\n        Y: {\n          mask: IMask.MaskedRange,\n          placeholderChar: 'Y',\n          from: 1900,\n          to: 9999,\n        },\n        HH: {\n            mask: IMask.MaskedRange,\n            placeholderChar: '-',\n            maxLength: 2,\n            from: 0,\n            to: 23,\n          },\n          hh: {\n            mask: IMask.MaskedRange,\n            placeholderChar: '-',\n            maxLength: 2,\n            from: 1,\n            to: 12,\n          },\n          mm: {\n            mask: IMask.MaskedRange,\n            placeholderChar: '-',\n            maxLength: 2,\n            from: 0,\n            to: 59,\n          },\n          ss: {\n            mask: IMask.MaskedRange,\n            placeholderChar: '-',\n            maxLength: 2,\n            from: 0,\n            to: 59,\n          },\n          aa: {\n            mask: IMask.MaskedEnum,\n            placeholderChar: '-',\n            enum: ['AM', 'PM', 'am', 'pm', amFormat, pmFormat],\n          },\n      },\n    };\n  }\n  \n  ngOnChanges(changes: SimpleChanges): void {\n    if (Object.keys(changes).some((key) => ['military', 'dateFormat'].includes(key))) {\n      this.initFormatOptions();\n    }\n  }\n\n  _checkInput(event: InputEvent): void {\n    if (document.activeElement === event.target) {\n      const text = (event.target as HTMLInputElement).value;\n      const dateTime =  text.split(', ');\n      const hour = dateTime[1].slice(0, 2);\n      if ((this.military && Number(dateTime[1][0]) > 2) || (!this.military && Number(dateTime[1][0]) > 1)) {\n        event.preventDefault();\n        const value = `0${dateTime[1]}`;\n        (event.target as HTMLInputElement).value = value;\n        // this.onChange(value);\n      }\n      if (!this.military) {\n        const input = dateTime[1].substr(5, 4).replace(/\\-/g, '').trim().slice(0, 2);\n        const timePeriod = this.imask.blocks.aa.enum.find((it) => it[0] === input[0]);\n        if (timePeriod) {\n          (event.target as HTMLInputElement).value = `${dateTime[0]}, ${dateTime[1].slice(0, 5)} ${timePeriod}`;\n        }\n        if ((event.target as HTMLInputElement).selectionStart >= 3 && this.hourOneFormatRequired(hour)) {\n          (event.target as HTMLInputElement).value = `${dateTime[0]}, 01:${(event.target as HTMLInputElement).value.slice(\n            3,\n            (event.target as HTMLInputElement).value.length,\n          )}`;\n        }\n      }\n    }\n  }\n\n  _handleBlur(event: FocusEvent): void {\n    const text = (event.target as HTMLInputElement).value;\n    const dateTime =  text.split(', ');\n    const hour: string = dateTime[1].slice(0, 2);\n    if (!this.military) {\n      const input = dateTime[1].substr(17, 4).replace(/\\-/g, '').trim().slice(0, 2);\n      const timePeriod = this.imask.blocks.aa.enum.find((it) => it[0] === input[0]);\n      if (this.hourOneFormatRequired(hour)) {\n        (event.target as HTMLInputElement).value = `${dateTime[0]}, 01:${dateTime[1].slice(3, dateTime[1].length)}`;\n      }\n      if (!timePeriod) {\n        (event.target as HTMLInputElement).value = `${dateTime[0]}, ${dateTime[1].slice(0, 5)} --`;\n      }\n    }\n  }\n\n  _handleKeydown(event: KeyboardEvent): void {\n    const input = event.target as HTMLInputElement;\n    const dateTime =  input.value.split(', ');\n    const hour: string = dateTime[1].slice(0, 2);\n\n    if (event.key === Key.Backspace && input.selectionStart === dateTime[1].length) {\n      (event.target as HTMLInputElement).value = `${dateTime[1].slice(0, 5)} --`;\n    } else if (event.key === Key.Tab && input.selectionStart <= 2 && this.hourOneFormatRequired(hour)) {\n      event.preventDefault();\n      event.stopPropagation();\n      event.stopImmediatePropagation();\n      input.value = `${dateTime[0]}, 01:${dateTime[1].slice(3, dateTime[1].length)}`;\n      input.setSelectionRange(15, 15);\n    } else if (event.key === Key.ArrowRight && input.selectionStart >= 2 && this.hourOneFormatRequired(hour)) {\n      input.value = `${dateTime[0]}, 01:${dateTime[1].slice(3, dateTime[1].length)}`;\n      input.setSelectionRange(14, 14);\n    }\n  }\n\n  normalize(value: string) {\n    const pattern = this.labels.dateFormat.toUpperCase();\n    return format(parse(value), pattern);\n  }\n\n  formatAsIso(date: Date): string {\n    if (date && isValid(date)) {\n      return date.toISOString();\n    }\n    return null;\n  }\n\n  convertTime12to24(time12h: string) {\n    const pmFormat = this.labels.timeFormatPM.toUpperCase();\n    const [time, meridian] = time12h.split(' ');\n    let [hours, minutes] = time.split(':');\n    if (hours === '12') {\n      hours = '00';\n    }\n    if (['PM', pmFormat].includes(meridian)) {\n      hours = `${parseInt(hours, 10) + 12}`.padStart(2, '0');\n    }\n    return `${hours}:${minutes}`;\n  }\n\n  convertTime24to12(time24h: string) {\n    if (time24h.length === 5) {\n      const date = parse(`2020-01-01T${time24h}`);\n      return format(date, 'hh:mm A');\n    }\n    return time24h;\n  }\n\n  formatValue(value: any): string {\n    if (value == null) return '';\n    // Use `parse` because it keeps dates in locale\n    const date = parse(value);\n    if (isValid(date)) {\n      const dateFormat = `${this.labels.dateFormat.toUpperCase()}, ${this.military ? 'HH:mm' : 'hh:mm A'}`;\n      return format(date, dateFormat);\n    }\n    return this.normalize(value);\n  }\n\n  writeValue(value: any) {\n    super.writeValue(this.formatValue(value));\n  }\n\n  registerOnChange(fn: (_: any) => void): void {\n    this.onChange = (date: any) => {\n      let formatted = date;\n      switch (this.dateTimeFormat) {\n        case DATE_FORMATS.ISO8601:\n          formatted = this.formatAsIso(date);\n          break;\n        case DATE_FORMATS.STRING:\n          formatted = this.formatValue(date);\n          break;\n        default:\n          formatted = date;\n          break;\n      }\n      this.valueChange.emit(date);\n      fn(formatted);\n    };\n  }\n\n  hourOneFormatRequired(hourInput: string): boolean {\n    return hourInput === '-1' || hourInput === '1-';\n  }\n}\n"]}

package/esm2020/src/elements/field/index.mjs

@@ -8,8 +8,9 @@ export * from './formats/base-format';
 export * from './formats/date-format';
 export * from './formats/date-range-format';
 export * from './formats/time-format';
+export * from './formats/date-time-format';
 export * from './hint';
 export * from './input';
 export * from './picker.directive';
 export * from './toggle/picker-toggle.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ub3ZvLWVsZW1lbnRzL3NyYy9lbGVtZW50cy9maWVsZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxrQ0FBa0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXV0b2NvbXBsZXRlL2F1dG9jb21wbGV0ZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9lcnJvcic7XG5leHBvcnQgKiBmcm9tICcuL2ZpZWxkJztcbmV4cG9ydCAqIGZyb20gJy4vZmllbGQtY29udHJvbCc7XG5leHBvcnQgKiBmcm9tICcuL2ZpZWxkLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZpZWxkc2V0JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybWF0cy9iYXNlLWZvcm1hdCc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm1hdHMvZGF0ZS1mb3JtYXQnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtYXRzL2RhdGUtcmFuZ2UtZm9ybWF0JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybWF0cy90aW1lLWZvcm1hdCc7XG5leHBvcnQgKiBmcm9tICcuL2hpbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnB1dCc7XG5leHBvcnQgKiBmcm9tICcuL3BpY2tlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi90b2dnbGUvcGlja2VyLXRvZ2dsZS5jb21wb25lbnQnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ub3ZvLWVsZW1lbnRzL3NyYy9lbGVtZW50cy9maWVsZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtDQUFrQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdXRvY29tcGxldGUvYXV0b2NvbXBsZXRlLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2Vycm9yJztcbmV4cG9ydCAqIGZyb20gJy4vZmllbGQnO1xuZXhwb3J0ICogZnJvbSAnLi9maWVsZC1jb250cm9sJztcbmV4cG9ydCAqIGZyb20gJy4vZmllbGQubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZmllbGRzZXQnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtYXRzL2Jhc2UtZm9ybWF0JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybWF0cy9kYXRlLWZvcm1hdCc7XG5leHBvcnQgKiBmcm9tICcuL2Zvcm1hdHMvZGF0ZS1yYW5nZS1mb3JtYXQnO1xuZXhwb3J0ICogZnJvbSAnLi9mb3JtYXRzL3RpbWUtZm9ybWF0JztcbmV4cG9ydCAqIGZyb20gJy4vZm9ybWF0cy9kYXRlLXRpbWUtZm9ybWF0JztcbmV4cG9ydCAqIGZyb20gJy4vaGludCc7XG5leHBvcnQgKiBmcm9tICcuL2lucHV0JztcbmV4cG9ydCAqIGZyb20gJy4vcGlja2VyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3RvZ2dsZS9waWNrZXItdG9nZ2xlLmNvbXBvbmVudCc7XG4iXX0=

package/esm2020/src/elements/form/Form.module.mjs

@@ -59,6 +59,7 @@ NovoFormModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version:
         NovoChipsModule,
         NovoDatePickerModule,
         NovoTimePickerModule,
+        NovoDateTimePickerModule,
         NovoNovoCKEditorModule,
         NovoFormExtrasModule,
         NovoQuickNoteModule,
@@ -94,6 +95,7 @@ NovoFormModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version:
             NovoChipsModule,
             NovoDatePickerModule,
             NovoTimePickerModule,
+            NovoDateTimePickerModule,
             NovoNovoCKEditorModule,
             NovoFormExtrasModule,
             NovoQuickNoteModule,
@@ -127,6 +129,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
                         NovoChipsModule,
                         NovoDatePickerModule,
                         NovoTimePickerModule,
+                        NovoDateTimePickerModule,
                         NovoNovoCKEditorModule,
                         NovoFormExtrasModule,
                         NovoQuickNoteModule,
@@ -170,4 +173,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
                     providers: [NovoTemplateService],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Form.module.js","sourceRoot":"","sources":["../../../../../../projects/novo-elements/src/elements/form/Form.module.ts"],"names":[],"mappings":"AAAA,MAAM;AACN,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrD,SAAS;AACT,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,+CAA+C,CAAC;AACpF,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,wBAAwB,EAAE,MAAM,6CAA6C,CAAC;AACvF,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,MAAM;AACN,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AACvG,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;;AAwDzC,MAAM,OAAO,cAAc;;4GAAd,cAAc;6GAAd,cAAc,iBAtBvB,YAAY;QACZ,kBAAkB;QAClB,sBAAsB;QACtB,eAAe;QACf,mBAAmB;QACnB,yBAAyB;QACzB,mBAAmB;QACnB,kBAAkB;QAClB,gBAAgB;QAChB,oBAAoB,aAvCpB,YAAY;QACZ,aAAa;QACb,mBAAmB;QACnB,eAAe;QACf,eAAe;QACf,gBAAgB;QAChB,gBAAgB;QAChB,eAAe;QACf,oBAAoB;QACpB,oBAAoB;QACpB,sBAAsB;QACtB,oBAAoB;QACpB,mBAAmB;QACnB,wBAAwB;QACxB,gBAAgB;QAChB,iBAAiB;QACjB,iBAAiB;QACjB,oBAAoB;QACpB,cAAc;QACd,iBAAiB;QACjB,eAAe;QACf,gBAAgB;QAChB,mBAAmB;QACnB,gBAAgB;QAChB,kBAAkB;QAClB,cAAc;QACd,eAAe;QACf,gBAAgB,aAehB,YAAY;QACZ,sBAAsB;QACtB,kBAAkB;QAClB,eAAe;QACf,yBAAyB;QACzB,gBAAgB;QAChB,oBAAoB;6GAIX,cAAc,aAFd,CAAC,mBAAmB,CAAC,YAnDvB;YACP,YAAY;YACZ,aAAa;YACb,mBAAmB;YACnB,eAAe;YACf,eAAe;YACf,gBAAgB;YAChB,gBAAgB;YAChB,eAAe;YACf,oBAAoB;YACpB,oBAAoB;YACpB,sBAAsB;YACtB,oBAAoB;YACpB,mBAAmB;YACnB,wBAAwB;YACxB,gBAAgB;YAChB,iBAAiB;YACjB,iBAAiB;YACjB,oBAAoB;YACpB,cAAc;YACd,iBAAiB;YACjB,eAAe;YACf,gBAAgB;YAChB,mBAAmB;YACnB,gBAAgB;YAChB,kBAAkB;YAClB,cAAc;YACd,eAAe;YACf,gBAAgB;SACjB;4FAwBU,cAAc;kBAtD1B,QAAQ;mBAAC;oBACR,OAAO,EAAE;wBACP,YAAY;wBACZ,aAAa;wBACb,mBAAmB;wBACnB,eAAe;wBACf,eAAe;wBACf,gBAAgB;wBAChB,gBAAgB;wBAChB,eAAe;wBACf,oBAAoB;wBACpB,oBAAoB;wBACpB,sBAAsB;wBACtB,oBAAoB;wBACpB,mBAAmB;wBACnB,wBAAwB;wBACxB,gBAAgB;wBAChB,iBAAiB;wBACjB,iBAAiB;wBACjB,oBAAoB;wBACpB,cAAc;wBACd,iBAAiB;wBACjB,eAAe;wBACf,gBAAgB;wBAChB,mBAAmB;wBACnB,gBAAgB;wBAChB,kBAAkB;wBAClB,cAAc;wBACd,eAAe;wBACf,gBAAgB;qBACjB;oBACD,YAAY,EAAE;wBACZ,YAAY;wBACZ,kBAAkB;wBAClB,sBAAsB;wBACtB,eAAe;wBACf,mBAAmB;wBACnB,yBAAyB;wBACzB,mBAAmB;wBACnB,kBAAkB;wBAClB,gBAAgB;wBAChB,oBAAoB;qBACrB;oBACD,OAAO,EAAE;wBACP,YAAY;wBACZ,sBAAsB;wBACtB,kBAAkB;wBAClB,eAAe;wBACf,yBAAyB;wBACzB,gBAAgB;wBAChB,oBAAoB;qBACrB;oBACD,SAAS,EAAE,CAAC,mBAAmB,CAAC;iBACjC","sourcesContent":["// NG2\nimport { OverlayModule } from '@angular/cdk/overlay';\nimport { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { IMaskDirectiveModule } from 'angular-imask';\n// Vendor\nimport { TextMaskModule } from 'angular2-text-mask';\nimport { NovoCheckboxModule } from '../checkbox';\nimport { NovoCommonModule } from '../common/common.module';\nimport { NovoIconModule } from '../icon';\nimport { NovoSwitchModule } from '../switch/Switch.module';\nimport { NovoTemplateService } from './../../services/template/NovoTemplateService';\nimport { NovoAceEditorModule } from './../ace-editor/AceEditor.module';\nimport { NovoButtonModule } from './../button/Button.module';\nimport { NovoChipsModule } from './../chips/Chips.module';\nimport { NovoNovoCKEditorModule } from './../ckeditor/CKEditor.module';\nimport { NovoDatePickerModule } from './../date-picker/DatePicker.module';\nimport { NovoDateTimePickerModule } from './../date-time-picker/DateTimePicker.module';\nimport { NovoDragulaModule } from './../dragula/Dragula.module';\nimport { NovoHeaderModule } from './../header/Header.module';\nimport { NovoModalModule } from './../modal/modal.module';\nimport { NovoPickerModule } from './../picker/Picker.module';\nimport { NovoQuickNoteModule } from './../quick-note/QuickNote.module';\n// APP\nimport { NovoRadioModule } from './../radio/Radio.module';\nimport { NovoSelectModule } from './../select/Select.module';\nimport { NovoTilesModule } from './../tiles/Tiles.module';\nimport { NovoTimePickerModule } from './../time-picker/TimePicker.module';\nimport { NovoTipWellModule } from './../tip-well/TipWell.module';\nimport { NovoTooltipModule } from './../tooltip/Tooltip.module';\nimport { NovoAutoSize, NovoControlElement } from './Control';\nimport { NovoControlGroup } from './ControlGroup';\nimport { NovoControlTemplates } from './ControlTemplates';\nimport { NovoDynamicFormElement, NovoFieldsetElement, NovoFieldsetHeaderElement } from './DynamicForm';\nimport { NovoFormExtrasModule } from './extras/FormExtras.module';\nimport { ControlConfirmModal, ControlPromptModal } from './FieldInteractionModals';\nimport { NovoFormElement } from './Form';\n\n@NgModule({\n  imports: [\n    CommonModule,\n    OverlayModule,\n    ReactiveFormsModule,\n    NovoRadioModule,\n    NovoTilesModule,\n    NovoSelectModule,\n    NovoPickerModule,\n    NovoChipsModule,\n    NovoDatePickerModule,\n    NovoTimePickerModule,\n    NovoNovoCKEditorModule,\n    NovoFormExtrasModule,\n    NovoQuickNoteModule,\n    NovoDateTimePickerModule,\n    NovoHeaderModule,\n    NovoTooltipModule,\n    NovoDragulaModule,\n    IMaskDirectiveModule,\n    TextMaskModule,\n    NovoTipWellModule,\n    NovoModalModule,\n    NovoButtonModule,\n    NovoAceEditorModule,\n    NovoCommonModule,\n    NovoCheckboxModule,\n    NovoIconModule,\n    NovoRadioModule,\n    NovoSwitchModule,\n  ],\n  declarations: [\n    NovoAutoSize,\n    NovoControlElement,\n    NovoDynamicFormElement,\n    NovoFormElement,\n    NovoFieldsetElement,\n    NovoFieldsetHeaderElement,\n    ControlConfirmModal,\n    ControlPromptModal,\n    NovoControlGroup,\n    NovoControlTemplates,\n  ],\n  exports: [\n    NovoAutoSize,\n    NovoDynamicFormElement,\n    NovoControlElement,\n    NovoFormElement,\n    NovoFieldsetHeaderElement,\n    NovoControlGroup,\n    NovoControlTemplates,\n  ],\n  providers: [NovoTemplateService],\n})\nexport class NovoFormModule {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Form.module.js","sourceRoot":"","sources":["../../../../../../projects/novo-elements/src/elements/form/Form.module.ts"],"names":[],"mappings":"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","sourcesContent":["// NG2\nimport { OverlayModule } from '@angular/cdk/overlay';\nimport { CommonModule } from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { ReactiveFormsModule } from '@angular/forms';\nimport { IMaskDirectiveModule } from 'angular-imask';\n// Vendor\nimport { TextMaskModule } from 'angular2-text-mask';\nimport { NovoCheckboxModule } from '../checkbox';\nimport { NovoCommonModule } from '../common/common.module';\nimport { NovoIconModule } from '../icon';\nimport { NovoSwitchModule } from '../switch/Switch.module';\nimport { NovoTemplateService } from './../../services/template/NovoTemplateService';\nimport { NovoAceEditorModule } from './../ace-editor/AceEditor.module';\nimport { NovoButtonModule } from './../button/Button.module';\nimport { NovoChipsModule } from './../chips/Chips.module';\nimport { NovoNovoCKEditorModule } from './../ckeditor/CKEditor.module';\nimport { NovoDatePickerModule } from './../date-picker/DatePicker.module';\nimport { NovoDateTimePickerModule } from './../date-time-picker/DateTimePicker.module';\nimport { NovoDragulaModule } from './../dragula/Dragula.module';\nimport { NovoHeaderModule } from './../header/Header.module';\nimport { NovoModalModule } from './../modal/modal.module';\nimport { NovoPickerModule } from './../picker/Picker.module';\nimport { NovoQuickNoteModule } from './../quick-note/QuickNote.module';\n// APP\nimport { NovoRadioModule } from './../radio/Radio.module';\nimport { NovoSelectModule } from './../select/Select.module';\nimport { NovoTilesModule } from './../tiles/Tiles.module';\nimport { NovoTimePickerModule } from './../time-picker/TimePicker.module';\nimport { NovoTipWellModule } from './../tip-well/TipWell.module';\nimport { NovoTooltipModule } from './../tooltip/Tooltip.module';\nimport { NovoAutoSize, NovoControlElement } from './Control';\nimport { NovoControlGroup } from './ControlGroup';\nimport { NovoControlTemplates } from './ControlTemplates';\nimport { NovoDynamicFormElement, NovoFieldsetElement, NovoFieldsetHeaderElement } from './DynamicForm';\nimport { NovoFormExtrasModule } from './extras/FormExtras.module';\nimport { ControlConfirmModal, ControlPromptModal } from './FieldInteractionModals';\nimport { NovoFormElement } from './Form';\n\n@NgModule({\n  imports: [\n    CommonModule,\n    OverlayModule,\n    ReactiveFormsModule,\n    NovoRadioModule,\n    NovoTilesModule,\n    NovoSelectModule,\n    NovoPickerModule,\n    NovoChipsModule,\n    NovoDatePickerModule,\n    NovoTimePickerModule,\n    NovoDateTimePickerModule,\n    NovoNovoCKEditorModule,\n    NovoFormExtrasModule,\n    NovoQuickNoteModule,\n    NovoDateTimePickerModule,\n    NovoHeaderModule,\n    NovoTooltipModule,\n    NovoDragulaModule,\n    IMaskDirectiveModule,\n    TextMaskModule,\n    NovoTipWellModule,\n    NovoModalModule,\n    NovoButtonModule,\n    NovoAceEditorModule,\n    NovoCommonModule,\n    NovoCheckboxModule,\n    NovoIconModule,\n    NovoRadioModule,\n    NovoSwitchModule,\n  ],\n  declarations: [\n    NovoAutoSize,\n    NovoControlElement,\n    NovoDynamicFormElement,\n    NovoFormElement,\n    NovoFieldsetElement,\n    NovoFieldsetHeaderElement,\n    ControlConfirmModal,\n    ControlPromptModal,\n    NovoControlGroup,\n    NovoControlTemplates,\n  ],\n  exports: [\n    NovoAutoSize,\n    NovoDynamicFormElement,\n    NovoControlElement,\n    NovoFormElement,\n    NovoFieldsetHeaderElement,\n    NovoControlGroup,\n    NovoControlTemplates,\n  ],\n  providers: [NovoTemplateService],\n})\nexport class NovoFormModule {}\n"]}

package/esm2020/src/elements/query-builder/condition-builder/condition-builder.component.mjs

@@ -169,10 +169,10 @@ export class ConditionBuilderComponent {
     }
 }
 ConditionBuilderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ConditionBuilderComponent, deps: [{ token: i1.NovoLabelService }, { token: i0.ChangeDetectorRef }, { token: i2.QueryBuilderService }, { token: i3.ControlContainer }], target: i0.ɵɵFactoryTarget.Component });
-ConditionBuilderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: ConditionBuilderComponent, selector: "novo-condition-builder", inputs: { label: "label", isFirst: "isFirst", andIndex: "andIndex", groupIndex: "groupIndex" }, providers: [{ provide: NOVO_CONDITION_BUILDER, useExisting: ConditionBuilderComponent }], viewQueries: [{ propertyName: "_operatorOutlet", first: true, predicate: ConditionOperatorOutlet, descendants: true, static: true }, { propertyName: "_inputOutlet", first: true, predicate: ConditionInputOutlet, descendants: true, static: true }], ngImport: i0, template: "<form [formGroup]=\"parentForm\">\n  <novo-grid gap=\"1rem\" [columns]=\"isFirst ? '20rem 13rem 1fr' : '16rem 13rem 1fr'\" align=\"end\">\n    <novo-field class=\"condition-field\">\n      <novo-select\n        [placeholder]=\"labels.chooseAField\"\n        formControlName=\"field\"\n        (onSelect)=\"onFieldSelect()\"\n        overlayWidth=\"24rem\"\n        overlayHeight=\"20rem\"\n        [displayWith]=\"fieldDisplayWith\"\n        [style.minWidth.px]=\"160\"\n        [style.maxWidth.px]=\"isFirst ? 200 : 160\">\n        <novo-optgroup class=\"filter-search-results\">\n          <novo-option>\n            <novo-select-search [formControl]=\"searchTerm\" [clearSearchInput]=\"false\"></novo-select-search>\n          </novo-option>\n          <ng-container *ngIf=\"results$ | async as results; else loading\">\n            <ng-container *ngIf=\"results.length\">\n              <novo-option *ngFor=\"let field of results\" value=\"{{ field.name }}\"\n                [attr.data-automation-id]=\"field.name\">\n                {{ field.label || field.name }}\n              </novo-option>\n            </ng-container>\n          </ng-container>\n        </novo-optgroup>\n      </novo-select>\n    </novo-field>\n\n    <div class=\"condition-operator\">\n      <ng-container conditionOperatorOutlet></ng-container>\n    </div>\n\n    <div class=\"condition-input\">\n      <ng-container conditionInputOutlet></ng-container>\n    </div>\n  </novo-grid>\n  <ng-content></ng-content>\n</form>\n\n<!-- EMPTY STATE TEMPLATE -->\n<!-- <ng-template #empty>\n  <novo-non-ideal-state>\n    <novo-icon size=\"xl\" color=\"grapefruit\">search</novo-icon>\n    <novo-title>No results found.</novo-title>\n    <novo-text>Your search didn't find anything. Try searching for something else.</novo-text>\n  </novo-non-ideal-state>\n</ng-template> -->\n\n<!-- LOADING TEMPLATE -->\n<ng-template #loading>\n  <novo-loading></novo-loading>\n</ng-template>", styles: [":host{position:relative;display:block;width:100%}:host .condition-field{grid-template-columns:minmax(-webkit-fit-content,1fr);grid-template-columns:minmax(fit-content,1fr);width:100%;width:-webkit-fill-available}:host .condition-operator::ng-deep .novo-select{min-width:13rem}:host .condition-input::ng-deep novo-field.novo-field-layout-vertical{grid-template-columns:minmax(-webkit-fit-content,1fr);grid-template-columns:minmax(fit-content,1fr);width:-webkit-fill-available}:host .condition-input::ng-deep novo-field.novo-field-layout-vertical .novo-input-element{width:100%}:host .condition-input::ng-deep novo-field{width:-webkit-fit-content;width:-moz-fit-content;width:fit-content}:host .condition-input::ng-deep .novo-field-infix{white-space:nowrap;overflow:hidden}:host .condition-input::ng-deep novo-chips{border-bottom:none!important}:host .condition-input::ng-deep novo-chips input{padding-left:0!important}:host .and-or-filter-button{box-sizing:border-box;background:#fff;border:1px solid #ddd;color:#5691f5;display:inline-block;position:relative;cursor:pointer;margin:.4rem auto;align-items:center;text-align:center;-webkit-user-select:none;-moz-user-select:none;user-select:none;outline:none;white-space:nowrap;text-transform:uppercase;overflow:hidden;transition:box-shadow .4s cubic-bezier(.25,.8,.25,1),background-color .4s cubic-bezier(.25,.8,.25,1)}\n"], components: [{ type: i4.NovoGridElement, selector: "novo-grid", inputs: ["direction", "align", "justify", "columns"] }, { type: i5.NovoFieldElement, selector: "novo-field", inputs: ["layout", "appearance", "width"], outputs: ["valueChanges", "stateChanges"] }, { type: i6.NovoSelectElement, selector: "novo-select", inputs: ["disabled", "required", "tabIndex", "id", "name", "options", "placeholder", "readonly", "headerConfig", "position", "overlayWidth", "overlayHeight", "displayWith", "compareWith", "value", "multiple"], outputs: ["onSelect", "selectionChange", "valueChange", "openedChange", "opened", "closed"] }, { type: i7.NovoOptgroup, selector: "novo-optgroup", inputs: ["disabled", "label"], exportAs: ["novoOptgroup"] }, { type: i8.NovoOption, selector: "novo-option", inputs: ["selected", "keepOpen", "novoInert", "value", "disabled"], exportAs: ["novoOption"] }, { type: i9.NovoSelectSearchComponent, selector: "novo-select-search", inputs: ["name", "placeholderLabel", "type", "noEntriesFoundLabel", "indexAndLengthScreenReaderText", "clearSearchInput", "searching", "disableInitialFocus", "enableClearOnEscapePressed", "preventHomeEndKeyPropagation", "disableScrollToActiveOnOptionsChanged", "ariaLabel", "showToggleAllCheckbox", "toggleAllCheckboxChecked", "toggleAllCheckboxIndeterminate", "toggleAllCheckboxTooltipMessage", "toogleAllCheckboxTooltipPosition", "hideClearSearchButton", "alwaysRestoreSelectedOptionsMulti"], outputs: ["toggleAll"] }, { type: i10.NovoLoadingElement, selector: "novo-loading", inputs: ["theme", "color", "size"] }], directives: [{ type: i3.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i11.GapDirective, selector: "[gap]", inputs: ["gap"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { type: i3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i12.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i12.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: ConditionOperatorOutlet, selector: "[conditionOperatorOutlet]" }, { type: ConditionInputOutlet, selector: "[conditionInputOutlet]" }], pipes: { "async": i12.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+ConditionBuilderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: ConditionBuilderComponent, selector: "novo-condition-builder", inputs: { label: "label", isFirst: "isFirst", andIndex: "andIndex", groupIndex: "groupIndex" }, providers: [{ provide: NOVO_CONDITION_BUILDER, useExisting: ConditionBuilderComponent }], viewQueries: [{ propertyName: "_operatorOutlet", first: true, predicate: ConditionOperatorOutlet, descendants: true, static: true }, { propertyName: "_inputOutlet", first: true, predicate: ConditionInputOutlet, descendants: true, static: true }], ngImport: i0, template: "<form [formGroup]=\"parentForm\">\n  <novo-grid gap=\"1rem\" [columns]=\"isFirst ? '20rem 13rem 1fr' : '16rem 13rem 1fr'\" align=\"end\">\n    <novo-field class=\"condition-field\">\n      <novo-select\n        [placeholder]=\"labels.chooseAField\"\n        formControlName=\"field\"\n        (onSelect)=\"onFieldSelect()\"\n        overlayWidth=\"24rem\"\n        overlayHeight=\"20rem\"\n        [displayWith]=\"fieldDisplayWith\"\n        [style.minWidth.px]=\"160\"\n        [style.maxWidth.px]=\"isFirst ? 200 : 160\">\n        <novo-optgroup class=\"filter-search-results\">\n          <novo-option>\n            <novo-select-search [formControl]=\"searchTerm\" [clearSearchInput]=\"false\"></novo-select-search>\n          </novo-option>\n          <ng-container *ngIf=\"results$ | async as results; else loading\">\n            <ng-container *ngIf=\"results.length\">\n              <novo-option *ngFor=\"let field of results\" value=\"{{ field.name }}\"\n                [attr.data-automation-id]=\"field.name\">\n                {{ field.label || field.name }}\n              </novo-option>\n            </ng-container>\n          </ng-container>\n        </novo-optgroup>\n      </novo-select>\n    </novo-field>\n\n    <div class=\"condition-operator\">\n      <ng-container conditionOperatorOutlet></ng-container>\n    </div>\n\n    <div class=\"condition-input\">\n      <ng-container conditionInputOutlet></ng-container>\n    </div>\n  </novo-grid>\n  <ng-content></ng-content>\n</form>\n\n<!-- EMPTY STATE TEMPLATE -->\n<!-- <ng-template #empty>\n  <novo-non-ideal-state>\n    <novo-icon size=\"xl\" color=\"grapefruit\">search</novo-icon>\n    <novo-title>No results found.</novo-title>\n    <novo-text>Your search didn't find anything. Try searching for something else.</novo-text>\n  </novo-non-ideal-state>\n</ng-template> -->\n\n<!-- LOADING TEMPLATE -->\n<ng-template #loading>\n  <novo-loading></novo-loading>\n</ng-template>", styles: [":host{position:relative;display:block;width:100%}:host .condition-field{grid-template-columns:minmax(-webkit-fit-content,1fr);grid-template-columns:minmax(fit-content,1fr);width:100%;width:-webkit-fill-available}:host .condition-operator::ng-deep .novo-select{min-width:13rem}:host .condition-input::ng-deep novo-field.novo-field-layout-vertical{grid-template-columns:minmax(-webkit-fit-content,1fr);grid-template-columns:minmax(fit-content,1fr);width:-webkit-fill-available}:host .condition-input::ng-deep novo-field.novo-field-layout-vertical .novo-input-element{width:100%}:host .condition-input::ng-deep novo-field{width:-webkit-fit-content;width:-moz-fit-content;width:fit-content}:host .condition-input::ng-deep .novo-field-infix{white-space:nowrap;overflow:hidden}:host .condition-input::ng-deep novo-chips{border-bottom:none!important}:host .condition-input::ng-deep novo-chips input{padding-left:0!important}:host .condition-input::ng-deep novo-radio-group{padding:0!important}:host .and-or-filter-button{box-sizing:border-box;background:#fff;border:1px solid #ddd;color:#5691f5;display:inline-block;position:relative;cursor:pointer;margin:.4rem auto;align-items:center;text-align:center;-webkit-user-select:none;-moz-user-select:none;user-select:none;outline:none;white-space:nowrap;text-transform:uppercase;overflow:hidden;transition:box-shadow .4s cubic-bezier(.25,.8,.25,1),background-color .4s cubic-bezier(.25,.8,.25,1)}\n"], components: [{ type: i4.NovoGridElement, selector: "novo-grid", inputs: ["direction", "align", "justify", "columns"] }, { type: i5.NovoFieldElement, selector: "novo-field", inputs: ["layout", "appearance", "width"], outputs: ["valueChanges", "stateChanges"] }, { type: i6.NovoSelectElement, selector: "novo-select", inputs: ["disabled", "required", "tabIndex", "id", "name", "options", "placeholder", "readonly", "headerConfig", "position", "overlayWidth", "overlayHeight", "displayWith", "compareWith", "value", "multiple"], outputs: ["onSelect", "selectionChange", "valueChange", "openedChange", "opened", "closed"] }, { type: i7.NovoOptgroup, selector: "novo-optgroup", inputs: ["disabled", "label"], exportAs: ["novoOptgroup"] }, { type: i8.NovoOption, selector: "novo-option", inputs: ["selected", "keepOpen", "novoInert", "value", "disabled"], exportAs: ["novoOption"] }, { type: i9.NovoSelectSearchComponent, selector: "novo-select-search", inputs: ["name", "placeholderLabel", "type", "noEntriesFoundLabel", "indexAndLengthScreenReaderText", "clearSearchInput", "searching", "disableInitialFocus", "enableClearOnEscapePressed", "preventHomeEndKeyPropagation", "disableScrollToActiveOnOptionsChanged", "ariaLabel", "showToggleAllCheckbox", "toggleAllCheckboxChecked", "toggleAllCheckboxIndeterminate", "toggleAllCheckboxTooltipMessage", "toogleAllCheckboxTooltipPosition", "hideClearSearchButton", "alwaysRestoreSelectedOptionsMulti"], outputs: ["toggleAll"] }, { type: i10.NovoLoadingElement, selector: "novo-loading", inputs: ["theme", "color", "size"] }], directives: [{ type: i3.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i11.GapDirective, selector: "[gap]", inputs: ["gap"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { type: i3.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i12.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i12.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: ConditionOperatorOutlet, selector: "[conditionOperatorOutlet]" }, { type: ConditionInputOutlet, selector: "[conditionInputOutlet]" }], pipes: { "async": i12.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: ConditionBuilderComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'novo-condition-builder', providers: [{ provide: NOVO_CONDITION_BUILDER, useExisting: ConditionBuilderComponent }], changeDetection: ChangeDetectionStrategy.OnPush, template: "<form [formGroup]=\"parentForm\">\n  <novo-grid gap=\"1rem\" [columns]=\"isFirst ? '20rem 13rem 1fr' : '16rem 13rem 1fr'\" align=\"end\">\n    <novo-field class=\"condition-field\">\n      <novo-select\n        [placeholder]=\"labels.chooseAField\"\n        formControlName=\"field\"\n        (onSelect)=\"onFieldSelect()\"\n        overlayWidth=\"24rem\"\n        overlayHeight=\"20rem\"\n        [displayWith]=\"fieldDisplayWith\"\n        [style.minWidth.px]=\"160\"\n        [style.maxWidth.px]=\"isFirst ? 200 : 160\">\n        <novo-optgroup class=\"filter-search-results\">\n          <novo-option>\n            <novo-select-search [formControl]=\"searchTerm\" [clearSearchInput]=\"false\"></novo-select-search>\n          </novo-option>\n          <ng-container *ngIf=\"results$ | async as results; else loading\">\n            <ng-container *ngIf=\"results.length\">\n              <novo-option *ngFor=\"let field of results\" value=\"{{ field.name }}\"\n                [attr.data-automation-id]=\"field.name\">\n                {{ field.label || field.name }}\n              </novo-option>\n            </ng-container>\n          </ng-container>\n        </novo-optgroup>\n      </novo-select>\n    </novo-field>\n\n    <div class=\"condition-operator\">\n      <ng-container conditionOperatorOutlet></ng-container>\n    </div>\n\n    <div class=\"condition-input\">\n      <ng-container conditionInputOutlet></ng-container>\n    </div>\n  </novo-grid>\n  <ng-content></ng-content>\n</form>\n\n<!-- EMPTY STATE TEMPLATE -->\n<!-- <ng-template #empty>\n  <novo-non-ideal-state>\n    <novo-icon size=\"xl\" color=\"grapefruit\">search</novo-icon>\n    <novo-title>No results found.</novo-title>\n    <novo-text>Your search didn't find anything. Try searching for something else.</novo-text>\n  </novo-non-ideal-state>\n</ng-template> -->\n\n<!-- LOADING TEMPLATE -->\n<ng-template #loading>\n  <novo-loading></novo-loading>\n</ng-template>", styles: [":host{position:relative;display:block;width:100%}:host .condition-field{grid-template-columns:minmax(-webkit-fit-content,1fr);grid-template-columns:minmax(fit-content,1fr);width:100%;width:-webkit-fill-available}:host .condition-operator::ng-deep .novo-select{min-width:13rem}:host .condition-input::ng-deep novo-field.novo-field-layout-vertical{grid-template-columns:minmax(-webkit-fit-content,1fr);grid-template-columns:minmax(fit-content,1fr);width:-webkit-fill-available}:host .condition-input::ng-deep novo-field.novo-field-layout-vertical .novo-input-element{width:100%}:host .condition-input::ng-deep novo-field{width:-webkit-fit-content;width:-moz-fit-content;width:fit-content}:host .condition-input::ng-deep .novo-field-infix{white-space:nowrap;overflow:hidden}:host .condition-input::ng-deep novo-chips{border-bottom:none!important}:host .condition-input::ng-deep novo-chips input{padding-left:0!important}:host .and-or-filter-button{box-sizing:border-box;background:#fff;border:1px solid #ddd;color:#5691f5;display:inline-block;position:relative;cursor:pointer;margin:.4rem auto;align-items:center;text-align:center;-webkit-user-select:none;-moz-user-select:none;user-select:none;outline:none;white-space:nowrap;text-transform:uppercase;overflow:hidden;transition:box-shadow .4s cubic-bezier(.25,.8,.25,1),background-color .4s cubic-bezier(.25,.8,.25,1)}\n"] }]
+            args: [{ selector: 'novo-condition-builder', providers: [{ provide: NOVO_CONDITION_BUILDER, useExisting: ConditionBuilderComponent }], changeDetection: ChangeDetectionStrategy.OnPush, template: "<form [formGroup]=\"parentForm\">\n  <novo-grid gap=\"1rem\" [columns]=\"isFirst ? '20rem 13rem 1fr' : '16rem 13rem 1fr'\" align=\"end\">\n    <novo-field class=\"condition-field\">\n      <novo-select\n        [placeholder]=\"labels.chooseAField\"\n        formControlName=\"field\"\n        (onSelect)=\"onFieldSelect()\"\n        overlayWidth=\"24rem\"\n        overlayHeight=\"20rem\"\n        [displayWith]=\"fieldDisplayWith\"\n        [style.minWidth.px]=\"160\"\n        [style.maxWidth.px]=\"isFirst ? 200 : 160\">\n        <novo-optgroup class=\"filter-search-results\">\n          <novo-option>\n            <novo-select-search [formControl]=\"searchTerm\" [clearSearchInput]=\"false\"></novo-select-search>\n          </novo-option>\n          <ng-container *ngIf=\"results$ | async as results; else loading\">\n            <ng-container *ngIf=\"results.length\">\n              <novo-option *ngFor=\"let field of results\" value=\"{{ field.name }}\"\n                [attr.data-automation-id]=\"field.name\">\n                {{ field.label || field.name }}\n              </novo-option>\n            </ng-container>\n          </ng-container>\n        </novo-optgroup>\n      </novo-select>\n    </novo-field>\n\n    <div class=\"condition-operator\">\n      <ng-container conditionOperatorOutlet></ng-container>\n    </div>\n\n    <div class=\"condition-input\">\n      <ng-container conditionInputOutlet></ng-container>\n    </div>\n  </novo-grid>\n  <ng-content></ng-content>\n</form>\n\n<!-- EMPTY STATE TEMPLATE -->\n<!-- <ng-template #empty>\n  <novo-non-ideal-state>\n    <novo-icon size=\"xl\" color=\"grapefruit\">search</novo-icon>\n    <novo-title>No results found.</novo-title>\n    <novo-text>Your search didn't find anything. Try searching for something else.</novo-text>\n  </novo-non-ideal-state>\n</ng-template> -->\n\n<!-- LOADING TEMPLATE -->\n<ng-template #loading>\n  <novo-loading></novo-loading>\n</ng-template>", styles: [":host{position:relative;display:block;width:100%}:host .condition-field{grid-template-columns:minmax(-webkit-fit-content,1fr);grid-template-columns:minmax(fit-content,1fr);width:100%;width:-webkit-fill-available}:host .condition-operator::ng-deep .novo-select{min-width:13rem}:host .condition-input::ng-deep novo-field.novo-field-layout-vertical{grid-template-columns:minmax(-webkit-fit-content,1fr);grid-template-columns:minmax(fit-content,1fr);width:-webkit-fill-available}:host .condition-input::ng-deep novo-field.novo-field-layout-vertical .novo-input-element{width:100%}:host .condition-input::ng-deep novo-field{width:-webkit-fit-content;width:-moz-fit-content;width:fit-content}:host .condition-input::ng-deep .novo-field-infix{white-space:nowrap;overflow:hidden}:host .condition-input::ng-deep novo-chips{border-bottom:none!important}:host .condition-input::ng-deep novo-chips input{padding-left:0!important}:host .condition-input::ng-deep novo-radio-group{padding:0!important}:host .and-or-filter-button{box-sizing:border-box;background:#fff;border:1px solid #ddd;color:#5691f5;display:inline-block;position:relative;cursor:pointer;margin:.4rem auto;align-items:center;text-align:center;-webkit-user-select:none;-moz-user-select:none;user-select:none;outline:none;white-space:nowrap;text-transform:uppercase;overflow:hidden;transition:box-shadow .4s cubic-bezier(.25,.8,.25,1),background-color .4s cubic-bezier(.25,.8,.25,1)}\n"] }]
         }], ctorParameters: function () { return [{ type: i1.NovoLabelService }, { type: i0.ChangeDetectorRef }, { type: i2.QueryBuilderService }, { type: i3.ControlContainer }]; }, propDecorators: { _operatorOutlet: [{
                 type: ViewChild,
                 args: [ConditionOperatorOutlet, { static: true }]
@@ -188,4 +188,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
             }], groupIndex: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"condition-builder.component.js","sourceRoot":"","sources":["../../../../../../../projects/novo-elements/src/elements/query-builder/condition-builder/condition-builder.component.ts","../../../../../../../projects/novo-elements/src/elements/query-builder/condition-builder/condition-builder.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Directive,\n  ElementRef,\n  Input,\n  OnDestroy,\n  OnInit,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { AbstractControl, ControlContainer, FormControl } from '@angular/forms';\nimport { Subject, Subscription } from 'rxjs';\nimport { debounceTime, distinctUntilChanged } from 'rxjs/operators';\nimport { BaseConditionFieldDef } from '../query-builder.directives';\nimport { QueryBuilderService } from '../query-builder.service';\nimport { NOVO_CONDITION_BUILDER } from '../query-builder.tokens';\nimport { BaseFieldDef, FieldConfig, QueryFilterOutlet } from '../query-builder.types';\nimport { NovoLabelService } from '../../../services';\n\n/**\n * Provides a handle for the table to grab the view container's ng-container to insert data rows.\n * @docs-private\n */\n@Directive({ selector: '[conditionInputOutlet]' })\nexport class ConditionInputOutlet implements QueryFilterOutlet {\n  constructor(public viewContainer: ViewContainerRef, public elementRef: ElementRef) {}\n}\n\n/**\n * Provides a handle for the table to grab the view container's ng-container to insert data rows.\n * @docs-private\n */\n@Directive({ selector: '[conditionOperatorOutlet]' })\nexport class ConditionOperatorOutlet implements QueryFilterOutlet {\n  constructor(public viewContainer: ViewContainerRef, public elementRef: ElementRef) {}\n}\n\n@Component({\n  selector: 'novo-condition-builder',\n  templateUrl: './condition-builder.component.html',\n  styleUrls: ['./condition-builder.component.scss'],\n  providers: [{ provide: NOVO_CONDITION_BUILDER, useExisting: ConditionBuilderComponent }],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ConditionBuilderComponent implements OnInit, AfterContentInit, AfterViewInit, OnDestroy {\n  @ViewChild(ConditionOperatorOutlet, { static: true }) _operatorOutlet: ConditionOperatorOutlet;\n  @ViewChild(ConditionInputOutlet, { static: true }) _inputOutlet: ConditionInputOutlet;\n\n  @Input() label: any;\n  @Input() isFirst: boolean;\n  @Input() andIndex: number;\n  @Input() groupIndex: number;\n\n  public parentForm: AbstractControl;\n  public fieldConfig: FieldConfig<BaseFieldDef>;\n  public searches!: Subscription;\n  public results$: Promise<any[]>;\n  public searchTerm: FormControl = new FormControl();\n  public fieldDisplayWith;\n\n  private _lastContext: any = {};\n\n  /** Subject that emits when the component has been destroyed. */\n  private readonly _onDestroy = new Subject<void>();\n\n  constructor(\n    public labels: NovoLabelService,\n    private cdr: ChangeDetectorRef,\n    private qbs: QueryBuilderService,\n    private controlContainer: ControlContainer,\n  ) {}\n\n  ngOnInit() {\n    this.parentForm = this.controlContainer.control;\n    this.parentForm.valueChanges.subscribe((value) => {\n      Promise.resolve().then(() => this.onFieldSelect());\n    });\n  }\n\n  ngAfterContentInit() {\n    const { fields = [] } = this.qbs.config || {};\n    fields.length && this.changeFieldOptions(fields[0]);\n    this.searches = this.searchTerm.valueChanges.pipe(debounceTime(300), distinctUntilChanged()).subscribe((term) => {\n      this.results$ = Promise.resolve(\n        this.fieldConfig.options.filter(\n          (f) => f.name.toLowerCase().includes(term.toLowerCase()) || f.label?.toLowerCase().includes(term.toLowerCase()),\n        ),\n      );\n      this.cdr.markForCheck();\n    });\n  }\n\n  ngAfterViewInit() {\n    if (this.parentForm.value?.field !== null) {\n      Promise.resolve().then(() => this.onFieldSelect());\n    }\n  }\n\n  ngOnDestroy() {\n    this.searches.unsubscribe();\n    // Clear all outlets and Maps\n    [this._operatorOutlet.viewContainer, this._inputOutlet.viewContainer].forEach((def) => {\n      def.clear();\n    });\n    this._onDestroy.next();\n    this._onDestroy.complete();\n  }\n\n  /**\n   * Updates the Conditions \"Field\" Options to Change base on new Scope\n   * @param fieldConfig\n   */\n  changeFieldOptions(fieldConfig: FieldConfig<BaseFieldDef>) {\n    this.fieldConfig = fieldConfig;\n    this.searchTerm.setValue('');\n    this.results$ = Promise.resolve(this.fieldConfig.options);\n  }\n\n  getField() {\n    const { field } = this.parentForm?.value;\n    if (!field) return null;\n    return this.fieldConfig.find(field);\n  }\n\n  getDefaultField() {\n    const fields = this.fieldConfig.options;\n    if (fields && fields.length) {\n      return fields[0].name;\n    }\n    return null;\n  }\n\n  onFieldSelect() {\n    const fieldConf = this.getField();\n    if (!fieldConf) {\n      this.parentForm.get('field').setValue(this.getDefaultField());\n      return;\n    } else {\n      this.fieldDisplayWith = () => fieldConf.label || fieldConf.name;\n    }\n    const { field, operator } = this.parentForm.value;\n\n    if (this._lastContext.field !== field) {\n      if (!!this._lastContext.field) {\n        // only clearing operator/value is field was previously defined so we can preload values onto the form\n        this.parentForm.get('value').setValue(null);\n        this.parentForm.get('operator').setValue(null);\n      }\n      this.createFieldTemplates();\n    }\n\n    this._lastContext = { ...this.parentForm.value };\n    this.cdr.markForCheck();\n  }\n\n  private findDefinitionForField(field) {\n    if (!field) return;\n    const editType = this.qbs.editTypeFn(field);\n    // Don't look at dataSpecialization it is no good, this misses currency, and percent\n    const { name, inputType, dataType, type } = field;\n    const fieldDefsByName = this.qbs.getFieldDefsByName();\n    // Check Fields by priority for match Field Definition\n    const key = [name, editType?.toUpperCase(), 'DEFAULT'].find((it) => fieldDefsByName.has(it));\n    return fieldDefsByName.get(key);\n  }\n\n  private createFieldTemplates() {\n    const definition = this.findDefinitionForField(this.getField());\n\n    if (!this.parentForm.get('operator').value) {\n      this.parentForm.get('operator').setValue(definition.defaultOperator);\n    }\n\n    this.createFieldOperators(definition);\n    this.createFieldInput(definition);\n  }\n\n  private createFieldOperators(definition: BaseConditionFieldDef) {\n    this._operatorOutlet.viewContainer.clear();\n    if (definition) {\n      const context = { $implicit: this.parentForm, fieldMeta: this.getField() };\n      this._operatorOutlet.viewContainer.createEmbeddedView(definition.fieldOperators.template, context);\n    }\n    this.cdr.markForCheck();\n  }\n\n  private createFieldInput(definition: BaseConditionFieldDef) {\n    this._inputOutlet.viewContainer.clear();\n    if (definition) {\n      const context = { $implicit: this.parentForm, fieldMeta: this.getField(), viewIndex: this.groupIndex.toString() + this.andIndex.toString() };\n      this._inputOutlet.viewContainer.createEmbeddedView(definition.fieldInput.template, context);\n    }\n    this.cdr.markForCheck();\n  }\n}\n","<form [formGroup]=\"parentForm\">\n  <novo-grid gap=\"1rem\" [columns]=\"isFirst ? '20rem 13rem 1fr' : '16rem 13rem 1fr'\" align=\"end\">\n    <novo-field class=\"condition-field\">\n      <novo-select\n        [placeholder]=\"labels.chooseAField\"\n        formControlName=\"field\"\n        (onSelect)=\"onFieldSelect()\"\n        overlayWidth=\"24rem\"\n        overlayHeight=\"20rem\"\n        [displayWith]=\"fieldDisplayWith\"\n        [style.minWidth.px]=\"160\"\n        [style.maxWidth.px]=\"isFirst ? 200 : 160\">\n        <novo-optgroup class=\"filter-search-results\">\n          <novo-option>\n            <novo-select-search [formControl]=\"searchTerm\" [clearSearchInput]=\"false\"></novo-select-search>\n          </novo-option>\n          <ng-container *ngIf=\"results$ | async as results; else loading\">\n            <ng-container *ngIf=\"results.length\">\n              <novo-option *ngFor=\"let field of results\" value=\"{{ field.name }}\"\n                [attr.data-automation-id]=\"field.name\">\n                {{ field.label || field.name }}\n              </novo-option>\n            </ng-container>\n          </ng-container>\n        </novo-optgroup>\n      </novo-select>\n    </novo-field>\n\n    <div class=\"condition-operator\">\n      <ng-container conditionOperatorOutlet></ng-container>\n    </div>\n\n    <div class=\"condition-input\">\n      <ng-container conditionInputOutlet></ng-container>\n    </div>\n  </novo-grid>\n  <ng-content></ng-content>\n</form>\n\n<!-- EMPTY STATE TEMPLATE -->\n<!-- <ng-template #empty>\n  <novo-non-ideal-state>\n    <novo-icon size=\"xl\" color=\"grapefruit\">search</novo-icon>\n    <novo-title>No results found.</novo-title>\n    <novo-text>Your search didn't find anything. Try searching for something else.</novo-text>\n  </novo-non-ideal-state>\n</ng-template> -->\n\n<!-- LOADING TEMPLATE -->\n<ng-template #loading>\n  <novo-loading></novo-loading>\n</ng-template>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"condition-builder.component.js","sourceRoot":"","sources":["../../../../../../../projects/novo-elements/src/elements/query-builder/condition-builder/condition-builder.component.ts","../../../../../../../projects/novo-elements/src/elements/query-builder/condition-builder/condition-builder.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  Directive,\n  ElementRef,\n  Input,\n  OnDestroy,\n  OnInit,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { AbstractControl, ControlContainer, FormControl } from '@angular/forms';\nimport { Subject, Subscription } from 'rxjs';\nimport { debounceTime, distinctUntilChanged } from 'rxjs/operators';\nimport { BaseConditionFieldDef } from '../query-builder.directives';\nimport { QueryBuilderService } from '../query-builder.service';\nimport { NOVO_CONDITION_BUILDER } from '../query-builder.tokens';\nimport { BaseFieldDef, FieldConfig, QueryFilterOutlet } from '../query-builder.types';\nimport { NovoLabelService } from '../../../services';\n\n/**\n * Provides a handle for the table to grab the view container's ng-container to insert data rows.\n * @docs-private\n */\n@Directive({ selector: '[conditionInputOutlet]' })\nexport class ConditionInputOutlet implements QueryFilterOutlet {\n  constructor(public viewContainer: ViewContainerRef, public elementRef: ElementRef) {}\n}\n\n/**\n * Provides a handle for the table to grab the view container's ng-container to insert data rows.\n * @docs-private\n */\n@Directive({ selector: '[conditionOperatorOutlet]' })\nexport class ConditionOperatorOutlet implements QueryFilterOutlet {\n  constructor(public viewContainer: ViewContainerRef, public elementRef: ElementRef) {}\n}\n\n@Component({\n  selector: 'novo-condition-builder',\n  templateUrl: './condition-builder.component.html',\n  styleUrls: ['./condition-builder.component.scss'],\n  providers: [{ provide: NOVO_CONDITION_BUILDER, useExisting: ConditionBuilderComponent }],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class ConditionBuilderComponent implements OnInit, AfterContentInit, AfterViewInit, OnDestroy {\n  @ViewChild(ConditionOperatorOutlet, { static: true }) _operatorOutlet: ConditionOperatorOutlet;\n  @ViewChild(ConditionInputOutlet, { static: true }) _inputOutlet: ConditionInputOutlet;\n\n  @Input() label: any;\n  @Input() isFirst: boolean;\n  @Input() andIndex: number;\n  @Input() groupIndex: number;\n\n  public parentForm: AbstractControl;\n  public fieldConfig: FieldConfig<BaseFieldDef>;\n  public searches!: Subscription;\n  public results$: Promise<any[]>;\n  public searchTerm: FormControl = new FormControl();\n  public fieldDisplayWith;\n\n  private _lastContext: any = {};\n\n  /** Subject that emits when the component has been destroyed. */\n  private readonly _onDestroy = new Subject<void>();\n\n  constructor(\n    public labels: NovoLabelService,\n    private cdr: ChangeDetectorRef,\n    private qbs: QueryBuilderService,\n    private controlContainer: ControlContainer,\n  ) {}\n\n  ngOnInit() {\n    this.parentForm = this.controlContainer.control;\n    this.parentForm.valueChanges.subscribe((value) => {\n      Promise.resolve().then(() => this.onFieldSelect());\n    });\n  }\n\n  ngAfterContentInit() {\n    const { fields = [] } = this.qbs.config || {};\n    fields.length && this.changeFieldOptions(fields[0]);\n    this.searches = this.searchTerm.valueChanges.pipe(debounceTime(300), distinctUntilChanged()).subscribe((term) => {\n      this.results$ = Promise.resolve(\n        this.fieldConfig.options.filter(\n          (f) => f.name.toLowerCase().includes(term.toLowerCase()) || f.label?.toLowerCase().includes(term.toLowerCase()),\n        ),\n      );\n      this.cdr.markForCheck();\n    });\n  }\n\n  ngAfterViewInit() {\n    if (this.parentForm.value?.field !== null) {\n      Promise.resolve().then(() => this.onFieldSelect());\n    }\n  }\n\n  ngOnDestroy() {\n    this.searches.unsubscribe();\n    // Clear all outlets and Maps\n    [this._operatorOutlet.viewContainer, this._inputOutlet.viewContainer].forEach((def) => {\n      def.clear();\n    });\n    this._onDestroy.next();\n    this._onDestroy.complete();\n  }\n\n  /**\n   * Updates the Conditions \"Field\" Options to Change base on new Scope\n   * @param fieldConfig\n   */\n  changeFieldOptions(fieldConfig: FieldConfig<BaseFieldDef>) {\n    this.fieldConfig = fieldConfig;\n    this.searchTerm.setValue('');\n    this.results$ = Promise.resolve(this.fieldConfig.options);\n  }\n\n  getField() {\n    const { field } = this.parentForm?.value;\n    if (!field) return null;\n    return this.fieldConfig.find(field);\n  }\n\n  getDefaultField() {\n    const fields = this.fieldConfig.options;\n    if (fields && fields.length) {\n      return fields[0].name;\n    }\n    return null;\n  }\n\n  onFieldSelect() {\n    const fieldConf = this.getField();\n    if (!fieldConf) {\n      this.parentForm.get('field').setValue(this.getDefaultField());\n      return;\n    } else {\n      this.fieldDisplayWith = () => fieldConf.label || fieldConf.name;\n    }\n    const { field, operator } = this.parentForm.value;\n\n    if (this._lastContext.field !== field) {\n      if (!!this._lastContext.field) {\n        // only clearing operator/value is field was previously defined so we can preload values onto the form\n        this.parentForm.get('value').setValue(null);\n        this.parentForm.get('operator').setValue(null);\n      }\n      this.createFieldTemplates();\n    }\n\n    this._lastContext = { ...this.parentForm.value };\n    this.cdr.markForCheck();\n  }\n\n  private findDefinitionForField(field) {\n    if (!field) return;\n    const editType = this.qbs.editTypeFn(field);\n    // Don't look at dataSpecialization it is no good, this misses currency, and percent\n    const { name, inputType, dataType, type } = field;\n    const fieldDefsByName = this.qbs.getFieldDefsByName();\n    // Check Fields by priority for match Field Definition\n    const key = [name, editType?.toUpperCase(), 'DEFAULT'].find((it) => fieldDefsByName.has(it));\n    return fieldDefsByName.get(key);\n  }\n\n  private createFieldTemplates() {\n    const definition = this.findDefinitionForField(this.getField());\n\n    if (!this.parentForm.get('operator').value) {\n      this.parentForm.get('operator').setValue(definition.defaultOperator);\n    }\n\n    this.createFieldOperators(definition);\n    this.createFieldInput(definition);\n  }\n\n  private createFieldOperators(definition: BaseConditionFieldDef) {\n    this._operatorOutlet.viewContainer.clear();\n    if (definition) {\n      const context = { $implicit: this.parentForm, fieldMeta: this.getField() };\n      this._operatorOutlet.viewContainer.createEmbeddedView(definition.fieldOperators.template, context);\n    }\n    this.cdr.markForCheck();\n  }\n\n  private createFieldInput(definition: BaseConditionFieldDef) {\n    this._inputOutlet.viewContainer.clear();\n    if (definition) {\n      const context = { $implicit: this.parentForm, fieldMeta: this.getField(), viewIndex: this.groupIndex.toString() + this.andIndex.toString() };\n      this._inputOutlet.viewContainer.createEmbeddedView(definition.fieldInput.template, context);\n    }\n    this.cdr.markForCheck();\n  }\n}\n","<form [formGroup]=\"parentForm\">\n  <novo-grid gap=\"1rem\" [columns]=\"isFirst ? '20rem 13rem 1fr' : '16rem 13rem 1fr'\" align=\"end\">\n    <novo-field class=\"condition-field\">\n      <novo-select\n        [placeholder]=\"labels.chooseAField\"\n        formControlName=\"field\"\n        (onSelect)=\"onFieldSelect()\"\n        overlayWidth=\"24rem\"\n        overlayHeight=\"20rem\"\n        [displayWith]=\"fieldDisplayWith\"\n        [style.minWidth.px]=\"160\"\n        [style.maxWidth.px]=\"isFirst ? 200 : 160\">\n        <novo-optgroup class=\"filter-search-results\">\n          <novo-option>\n            <novo-select-search [formControl]=\"searchTerm\" [clearSearchInput]=\"false\"></novo-select-search>\n          </novo-option>\n          <ng-container *ngIf=\"results$ | async as results; else loading\">\n            <ng-container *ngIf=\"results.length\">\n              <novo-option *ngFor=\"let field of results\" value=\"{{ field.name }}\"\n                [attr.data-automation-id]=\"field.name\">\n                {{ field.label || field.name }}\n              </novo-option>\n            </ng-container>\n          </ng-container>\n        </novo-optgroup>\n      </novo-select>\n    </novo-field>\n\n    <div class=\"condition-operator\">\n      <ng-container conditionOperatorOutlet></ng-container>\n    </div>\n\n    <div class=\"condition-input\">\n      <ng-container conditionInputOutlet></ng-container>\n    </div>\n  </novo-grid>\n  <ng-content></ng-content>\n</form>\n\n<!-- EMPTY STATE TEMPLATE -->\n<!-- <ng-template #empty>\n  <novo-non-ideal-state>\n    <novo-icon size=\"xl\" color=\"grapefruit\">search</novo-icon>\n    <novo-title>No results found.</novo-title>\n    <novo-text>Your search didn't find anything. Try searching for something else.</novo-text>\n  </novo-non-ideal-state>\n</ng-template> -->\n\n<!-- LOADING TEMPLATE -->\n<ng-template #loading>\n  <novo-loading></novo-loading>\n</ng-template>"]}

package/esm2020/src/elements/query-builder/condition-definitions/abstract-condition.definition.mjs

@@ -26,6 +26,9 @@ export class AbstractConditionFieldDef {
     ngOnDestroy() {
         this.fieldDef?.unregister();
     }
+    onOperatorSelect(formGroup) {
+        formGroup.get('value').setValue(null);
+    }
     /** Synchronizes the column definition name with the text column name. */
     _syncFieldDefName() {
         if (this.fieldDef) {
@@ -48,4 +51,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
                 type: ViewChild,
                 args: [NovoConditionFieldDef, { static: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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