@ng-matero/extensions 15.5.0 → 16.0.0

package/esm2022/checkbox-group/checkbox-group.mjs

@@ -0,0 +1,234 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, forwardRef, Input, Output, ViewEncapsulation, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MatCheckbox } from '@angular/material/checkbox';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/checkbox";
+import * as i5 from "@ng-matero/extensions/core";
+export class MtxCheckboxBase {
+    constructor(label, value) {
+        this.label = label;
+        this.value = value;
+    }
+}
+class MtxCheckboxGroup {
+    get items() {
+        return this._items;
+    }
+    set items(value) {
+        // store the original data with deep clone
+        this._originalItems = JSON.parse(JSON.stringify(value));
+        this._items = value.map(option => {
+            return option instanceof Object ? option : new MtxCheckboxBase(option, option);
+        });
+    }
+    get showSelectAll() {
+        return this._showSelectAll;
+    }
+    set showSelectAll(value) {
+        this._showSelectAll = coerceBooleanProperty(value);
+    }
+    get compareWith() {
+        return this._compareWith;
+    }
+    set compareWith(fn) {
+        if (fn != null && typeof fn !== 'function') {
+            throw Error('`compareWith` must be a function.');
+        }
+        this._compareWith = fn;
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._changeDetectorRef.markForCheck();
+    }
+    constructor(_changeDetectorRef, _focusMonitor, _elementRef) {
+        this._changeDetectorRef = _changeDetectorRef;
+        this._focusMonitor = _focusMonitor;
+        this._elementRef = _elementRef;
+        this._items = [];
+        this._originalItems = [];
+        this.bindLabel = 'label';
+        this.bindValue = 'value';
+        this._showSelectAll = false;
+        this.selectAllLabel = 'Select All';
+        this._disabled = false;
+        this.change = new EventEmitter();
+        this.selectAll = false;
+        this.selectAllIndeterminate = false;
+        this.selectedItems = [];
+        this._onChange = () => null;
+        this._onTouched = () => null;
+    }
+    ngAfterViewInit() {
+        this._focusMonitor.monitor(this._elementRef, true).subscribe(focusOrigin => {
+            if (!focusOrigin) {
+                // When a focused element becomes disabled, the browser *immediately* fires a blur event.
+                // Angular does not expect events to be raised during change detection, so any state change
+                // (such as a form control's 'ng-touched') will cause a changed-after-checked error.
+                // See https://github.com/angular/angular/issues/17793. To work around this, we defer
+                // telling the form control it has been touched until the next tick.
+                Promise.resolve().then(() => {
+                    this._onTouched();
+                    this._changeDetectorRef.markForCheck();
+                });
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._focusMonitor.stopMonitoring(this._elementRef);
+    }
+    /**
+     * Finds and selects and option based on its value.
+     * @returns Option that has the corresponding value.
+     */
+    _selectValue(value) {
+        const correspondingOption = this.items.find(option => {
+            try {
+                const compareValue = option[this.bindValue] === value;
+                return this._compareWith ? this._compareWith(option, value) : compareValue;
+            }
+            catch (error) {
+                console.warn(error);
+                return false;
+            }
+        });
+        if (correspondingOption) {
+            correspondingOption.checked = true;
+        }
+        return correspondingOption;
+    }
+    /**
+     * Sets the model value. Implemented as part of ControlValueAccessor.
+     * @param value New value to be written to the model.
+     */
+    writeValue(value) {
+        if (value) {
+            if (!Array.isArray(value)) {
+                throw Error('Value must be an array.');
+            }
+            value.forEach((currentValue) => this._selectValue(currentValue));
+            this.selectedItems = value;
+        }
+        this._checkMasterCheckboxState();
+        this._changeDetectorRef.markForCheck();
+    }
+    /**
+     * Registers a callback to be triggered when the model value changes.
+     * Implemented as part of ControlValueAccessor.
+     * @param fn Callback to be registered.
+     */
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    /**
+     * Registers a callback to be triggered when the control is touched.
+     * Implemented as part of ControlValueAccessor.
+     * @param fn Callback to be registered.
+     */
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    /**
+     * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.
+     * @param isDisabled Whether the control should be disabled.
+     */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    _checkMasterCheckboxState() {
+        if (this.items
+            .filter(option => option.checked || !option.disabled)
+            .every(option => !option.checked)) {
+            this.selectAll = false;
+            this.selectAllIndeterminate = false;
+        }
+        else if (this.items
+            .filter(option => option.checked || !option.disabled)
+            .every(option => option.checked)) {
+            this.selectAll = true;
+            this.selectAllIndeterminate = false;
+        }
+        else {
+            this.selectAllIndeterminate = true;
+        }
+    }
+    _getSelectedItems(index) {
+        this.selectedItems = this.items.filter(option => option.checked);
+        if (this._compareWith) {
+            this.selectedItems = this._originalItems.filter(option => this.selectedItems.find(selectedOption => this._compareWith(option, selectedOption)));
+        }
+        else {
+            this.selectedItems = this.selectedItems.map(option => option[this.bindValue]);
+        }
+        this._onChange(this.selectedItems);
+        this.change.emit({ model: this.selectedItems, index });
+    }
+    /** Handle normal checkbox toggle */
+    _updateNormalCheckboxState(e, index) {
+        this._checkMasterCheckboxState();
+        this._getSelectedItems(index);
+    }
+    /** Handle master checkbox toggle */
+    _updateMasterCheckboxState(e, index) {
+        this.selectAll = !this.selectAll;
+        this.selectAllIndeterminate = false;
+        if (this.selectAll) {
+            this.items
+                .filter(option => option.checked || !option.disabled)
+                .forEach(option => (option.checked = true));
+        }
+        else {
+            this.items
+                .filter(option => option.checked || !option.disabled)
+                .forEach(option => (option.checked = !!option.disabled));
+        }
+        this._getSelectedItems(index);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxCheckboxGroup, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.FocusMonitor }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.3", type: MtxCheckboxGroup, selector: "mtx-checkbox-group", inputs: { items: "items", bindLabel: "bindLabel", bindValue: "bindValue", showSelectAll: "showSelectAll", selectAllLabel: "selectAllLabel", compareWith: "compareWith", disabled: "disabled" }, outputs: { change: "change" }, host: { classAttribute: "mtx-checkbox-group" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef((() => MtxCheckboxGroup)),
+                multi: true,
+            },
+        ], queries: [{ propertyName: "_checkboxes", predicate: i0.forwardRef(function () { return MatCheckbox; }), descendants: true }], exportAs: ["mtxCheckboxGroup"], ngImport: i0, template: "<mat-checkbox class=\"mtx-checkbox-master\"\n              *ngIf=\"showSelectAll\"\n              [checked]=\"selectAll\"\n              [(indeterminate)]=\"selectAllIndeterminate\"\n              [disabled]=\"disabled\"\n              (change)=\"_updateMasterCheckboxState($event, -1)\">\n  {{selectAllLabel}}\n</mat-checkbox>\n\n<mat-checkbox class=\"mtx-checkbox-normal\"\n              *ngFor=\"let option of items; let i = index;\"\n              [(ngModel)]=\"option.checked\"\n              [ngModelOptions]=\"{standalone: true}\"\n              [aria-describedby]=\"option.ariaDescribedby\"\n              [aria-label]=\"option.ariaLabel\"\n              [aria-labelledby]=\"option.ariaLabelledby\"\n              [color]=\"option.color\"\n              [disabled]=\"option.disabled || disabled\"\n              [disableRipple]=\"option.disableRipple\"\n              [labelPosition]=\"option.labelPosition\"\n              [required]=\"option.required\"\n              (change)=\"_updateNormalCheckboxState($event, i)\">\n  {{option[bindLabel] | toObservable | async}}\n</mat-checkbox>\n", styles: [""], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.MatCheckbox, selector: "mat-checkbox", inputs: ["disableRipple", "color", "tabIndex"], exportAs: ["matCheckbox"] }, { kind: "directive", type: i4.MatCheckboxRequiredValidator, selector: "mat-checkbox[required][formControlName],             mat-checkbox[required][formControl], mat-checkbox[required][ngModel]" }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }, { kind: "pipe", type: i5.MtxToObservablePipe, name: "toObservable" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { MtxCheckboxGroup };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxCheckboxGroup, decorators: [{
+            type: Component,
+            args: [{ selector: 'mtx-checkbox-group', exportAs: 'mtxCheckboxGroup', host: {
+                        class: 'mtx-checkbox-group',
+                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => MtxCheckboxGroup)),
+                            multi: true,
+                        },
+                    ], template: "<mat-checkbox class=\"mtx-checkbox-master\"\n              *ngIf=\"showSelectAll\"\n              [checked]=\"selectAll\"\n              [(indeterminate)]=\"selectAllIndeterminate\"\n              [disabled]=\"disabled\"\n              (change)=\"_updateMasterCheckboxState($event, -1)\">\n  {{selectAllLabel}}\n</mat-checkbox>\n\n<mat-checkbox class=\"mtx-checkbox-normal\"\n              *ngFor=\"let option of items; let i = index;\"\n              [(ngModel)]=\"option.checked\"\n              [ngModelOptions]=\"{standalone: true}\"\n              [aria-describedby]=\"option.ariaDescribedby\"\n              [aria-label]=\"option.ariaLabel\"\n              [aria-labelledby]=\"option.ariaLabelledby\"\n              [color]=\"option.color\"\n              [disabled]=\"option.disabled || disabled\"\n              [disableRipple]=\"option.disableRipple\"\n              [labelPosition]=\"option.labelPosition\"\n              [required]=\"option.required\"\n              (change)=\"_updateNormalCheckboxState($event, i)\">\n  {{option[bindLabel] | toObservable | async}}\n</mat-checkbox>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.FocusMonitor }, { type: i0.ElementRef }]; }, propDecorators: { _checkboxes: [{
+                type: ContentChildren,
+                args: [forwardRef(() => MatCheckbox), { descendants: true }]
+            }], items: [{
+                type: Input
+            }], bindLabel: [{
+                type: Input
+            }], bindValue: [{
+                type: Input
+            }], showSelectAll: [{
+                type: Input
+            }], selectAllLabel: [{
+                type: Input
+            }], compareWith: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkbox-group.js","sourceRoot":"","sources":["../../../../projects/extensions/checkbox-group/checkbox-group.ts","../../../../projects/extensions/checkbox-group/checkbox-group.html"],"names":[],"mappings":"AACA,OAAO,EAAgB,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EAEL,uBAAuB,EAEvB,SAAS,EACT,eAAe,EAEf,YAAY,EACZ,UAAU,EACV,KAAK,EAEL,MAAM,EAEN,iBAAiB,GAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,WAAW,EAAqB,MAAM,4BAA4B,CAAC;;;;;;;AAG5E,MAAM,OAAO,eAAe;IAC1B,YAAmB,KAAW,EAAS,KAAW;QAA/B,UAAK,GAAL,KAAK,CAAM;QAAS,UAAK,GAAL,KAAK,CAAM;IAAG,CAAC;CACvD;AAED,MAkBa,gBAAgB;IAI3B,IACI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,KAAY;QACpB,0CAA0C;QAC1C,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YAC/B,OAAO,MAAM,YAAY,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACjF,CAAC,CAAC,CAAC;IACL,CAAC;IAQD,IACI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IACD,IAAI,aAAa,CAAC,KAAc;QAC9B,IAAI,CAAC,cAAc,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC;IAKD,IACI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IACD,IAAI,WAAW,CAAC,EAA+C;QAC7D,IAAI,EAAE,IAAI,IAAI,IAAI,OAAO,EAAE,KAAK,UAAU,EAAE;YAC1C,MAAM,KAAK,CAAC,mCAAmC,CAAC,CAAC;SAClD;QAED,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;IACzB,CAAC;IAGD,IACI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAAc;QACzB,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAaD,YACU,kBAAqC,EACrC,aAA2B,EAC3B,WAAoC;QAFpC,uBAAkB,GAAlB,kBAAkB,CAAmB;QACrC,kBAAa,GAAb,aAAa,CAAc;QAC3B,gBAAW,GAAX,WAAW,CAAyB;QAtDtC,WAAM,GAAU,EAAE,CAAC;QACnB,mBAAc,GAAU,EAAE,CAAC;QAE1B,cAAS,GAAG,OAAO,CAAC;QAEpB,cAAS,GAAG,OAAO,CAAC;QASrB,mBAAc,GAAG,KAAK,CAAC;QAEtB,mBAAc,GAAG,YAAY,CAAC;QAuB/B,cAAS,GAAG,KAAK,CAAC;QAEhB,WAAM,GAAG,IAAI,YAAY,EAAsD,CAAC;QAE1F,cAAS,GAAG,KAAK,CAAC;QAClB,2BAAsB,GAAG,KAAK,CAAC;QAE/B,kBAAa,GAA6B,EAAE,CAAC;QAE7C,cAAS,GAA8C,GAAG,EAAE,CAAC,IAAI,CAAC;QAClE,eAAU,GAAe,GAAG,EAAE,CAAC,IAAI,CAAC;IAMjC,CAAC;IAEJ,eAAe;QACb,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE;YACzE,IAAI,CAAC,WAAW,EAAE;gBAChB,yFAAyF;gBACzF,2FAA2F;gBAC3F,oFAAoF;gBACpF,qFAAqF;gBACrF,oEAAoE;gBACpE,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;oBAC1B,IAAI,CAAC,UAAU,EAAE,CAAC;oBAClB,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;gBACzC,CAAC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACK,YAAY,CAAC,KAA6B;QAChD,MAAM,mBAAmB,GAAI,IAAI,CAAC,KAAkC,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACjF,IAAI;gBACF,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,KAAK,CAAC;gBACtD,OAAO,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC;aAC5E;YAAC,OAAO,KAAK,EAAE;gBACd,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACpB,OAAO,KAAK,CAAC;aACd;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,mBAAmB,EAAE;YACvB,mBAAmB,CAAC,OAAO,GAAG,IAAI,CAAC;SACpC;QAED,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,KAAY;QACrB,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACzB,MAAM,KAAK,CAAC,yBAAyB,CAAC,CAAC;aACxC;YAED,KAAK,CAAC,OAAO,CAAC,CAAC,YAAiB,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC;YACtE,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;SAC5B;QAED,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,IAAI,CAAC,kBAAkB,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACH,gBAAgB,CAAC,EAAgE;QAC/E,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACH,iBAAiB,CAAC,EAAiC;QACjD,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,gBAAgB,CAAC,UAAmB;QAClC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;IAC7B,CAAC;IAEO,yBAAyB;QAC/B,IACG,IAAI,CAAC,KAAkC;aACrC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;aACpD,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EACnC;YACA,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;YACvB,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;SACrC;aAAM,IACJ,IAAI,CAAC,KAAkC;aACrC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;aACpD,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,EAClC;YACA,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;YACtB,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;SACrC;aAAM;YACL,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;SACpC;IACH,CAAC;IAEO,iBAAiB,CAAC,KAAa;QACrC,IAAI,CAAC,aAAa,GAAI,IAAI,CAAC,KAAkC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAE/F,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,IAAI,CAAC,aAAa,GAAI,IAAI,CAAC,cAA2C,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CACrF,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,IAAI,CAAC,YAAa,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CACtF,CAAC;SACH;aAAM;YACL,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;SAC/E;QAED,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAEnC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,EAAE,CAAC,CAAC;IACzD,CAAC;IAED,oCAAoC;IACpC,0BAA0B,CAAC,CAAoB,EAAE,KAAa;QAC5D,IAAI,CAAC,yBAAyB,EAAE,CAAC;QACjC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAED,oCAAoC;IACpC,0BAA0B,CAAC,CAAoB,EAAE,KAAa;QAC5D,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC;QACjC,IAAI,CAAC,sBAAsB,GAAG,KAAK,CAAC;QAEpC,IAAI,IAAI,CAAC,SAAS,EAAE;YACjB,IAAI,CAAC,KAAkC;iBACrC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;iBACpD,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC;SAC/C;aAAM;YACJ,IAAI,CAAC,KAAkC;iBACrC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC;iBACpD,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;SAC5D;QAED,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;iIAxNU,gBAAgB;qHAAhB,gBAAgB,4TARhB;YACT;gBACE,OAAO,EAAE,iBAAiB;gBAC1B,WAAW,EAAE,UAAU,EAAC,GAAG,EAAE,CAAC,gBAAgB,EAAC;gBAC/C,KAAK,EAAE,IAAI;aACZ;SACF,yFAGiC,WAAW,oFC5C/C,0kCAwBA;;SDmBa,gBAAgB;2FAAhB,gBAAgB;kBAlB5B,SAAS;+BACE,oBAAoB,YACpB,kBAAkB,QACtB;wBACJ,KAAK,EAAE,oBAAoB;qBAC5B,iBAGc,iBAAiB,CAAC,IAAI,mBACpB,uBAAuB,CAAC,MAAM,aACpC;wBACT;4BACE,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,EAAC,GAAG,EAAE,iBAAiB,EAAC;4BAC/C,KAAK,EAAE,IAAI;yBACZ;qBACF;4JAID,WAAW;sBADV,eAAe;uBAAC,UAAU,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE;gBAIjE,KAAK;sBADR,KAAK;gBAcG,SAAS;sBAAjB,KAAK;gBAEG,SAAS;sBAAjB,KAAK;gBAGF,aAAa;sBADhB,KAAK;gBASG,cAAc;sBAAtB,KAAK;gBAGF,WAAW;sBADd,KAAK;gBAcF,QAAQ;sBADX,KAAK;gBAUI,MAAM;sBAAf,MAAM","sourcesContent":["import { FocusMonitor } from '@angular/cdk/a11y';\nimport { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { MatCheckbox, MatCheckboxChange } from '@angular/material/checkbox';\nimport { MtxCheckboxGroupOption } from './interfaces';\n\nexport class MtxCheckboxBase {\n  constructor(public label?: any, public value?: any) {}\n}\n\n@Component({\n  selector: 'mtx-checkbox-group',\n  exportAs: 'mtxCheckboxGroup',\n  host: {\n    class: 'mtx-checkbox-group',\n  },\n  templateUrl: './checkbox-group.html',\n  styleUrls: ['./checkbox-group.scss'],\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => MtxCheckboxGroup),\n      multi: true,\n    },\n  ],\n})\nexport class MtxCheckboxGroup implements AfterViewInit, OnDestroy, ControlValueAccessor {\n  @ContentChildren(forwardRef(() => MatCheckbox), { descendants: true })\n  _checkboxes!: QueryList<MatCheckbox>;\n\n  @Input()\n  get items() {\n    return this._items;\n  }\n  set items(value: any[]) {\n    // store the original data with deep clone\n    this._originalItems = JSON.parse(JSON.stringify(value));\n    this._items = value.map(option => {\n      return option instanceof Object ? option : new MtxCheckboxBase(option, option);\n    });\n  }\n  private _items: any[] = [];\n  private _originalItems: any[] = [];\n\n  @Input() bindLabel = 'label';\n\n  @Input() bindValue = 'value';\n\n  @Input()\n  get showSelectAll(): boolean {\n    return this._showSelectAll;\n  }\n  set showSelectAll(value: boolean) {\n    this._showSelectAll = coerceBooleanProperty(value);\n  }\n  private _showSelectAll = false;\n\n  @Input() selectAllLabel = 'Select All';\n\n  @Input()\n  get compareWith() {\n    return this._compareWith;\n  }\n  set compareWith(fn: ((o1: any, o2: any) => boolean) | undefined) {\n    if (fn != null && typeof fn !== 'function') {\n      throw Error('`compareWith` must be a function.');\n    }\n\n    this._compareWith = fn;\n  }\n  private _compareWith?: (o1: any, o2: any) => boolean;\n\n  @Input()\n  get disabled(): boolean {\n    return this._disabled;\n  }\n  set disabled(value: boolean) {\n    this._disabled = coerceBooleanProperty(value);\n    this._changeDetectorRef.markForCheck();\n  }\n  private _disabled = false;\n\n  @Output() change = new EventEmitter<{ model: MtxCheckboxGroupOption[]; index: number }>();\n\n  selectAll = false;\n  selectAllIndeterminate = false;\n\n  selectedItems: MtxCheckboxGroupOption[] = [];\n\n  _onChange: (value: MtxCheckboxGroupOption[]) => void = () => null;\n  _onTouched: () => void = () => null;\n\n  constructor(\n    private _changeDetectorRef: ChangeDetectorRef,\n    private _focusMonitor: FocusMonitor,\n    private _elementRef: ElementRef<HTMLElement>\n  ) {}\n\n  ngAfterViewInit() {\n    this._focusMonitor.monitor(this._elementRef, true).subscribe(focusOrigin => {\n      if (!focusOrigin) {\n        // When a focused element becomes disabled, the browser *immediately* fires a blur event.\n        // Angular does not expect events to be raised during change detection, so any state change\n        // (such as a form control's 'ng-touched') will cause a changed-after-checked error.\n        // See https://github.com/angular/angular/issues/17793. To work around this, we defer\n        // telling the form control it has been touched until the next tick.\n        Promise.resolve().then(() => {\n          this._onTouched();\n          this._changeDetectorRef.markForCheck();\n        });\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this._elementRef);\n  }\n\n  /**\n   * Finds and selects and option based on its value.\n   * @returns Option that has the corresponding value.\n   */\n  private _selectValue(value: MtxCheckboxGroupOption) {\n    const correspondingOption = (this.items as MtxCheckboxGroupOption[]).find(option => {\n      try {\n        const compareValue = option[this.bindValue] === value;\n        return this._compareWith ? this._compareWith(option, value) : compareValue;\n      } catch (error) {\n        console.warn(error);\n        return false;\n      }\n    });\n\n    if (correspondingOption) {\n      correspondingOption.checked = true;\n    }\n\n    return correspondingOption;\n  }\n\n  /**\n   * Sets the model value. Implemented as part of ControlValueAccessor.\n   * @param value New value to be written to the model.\n   */\n  writeValue(value: any[]): void {\n    if (value) {\n      if (!Array.isArray(value)) {\n        throw Error('Value must be an array.');\n      }\n\n      value.forEach((currentValue: any) => this._selectValue(currentValue));\n      this.selectedItems = value;\n    }\n\n    this._checkMasterCheckboxState();\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /**\n   * Registers a callback to be triggered when the model value changes.\n   * Implemented as part of ControlValueAccessor.\n   * @param fn Callback to be registered.\n   */\n  registerOnChange(fn: (value: MtxCheckboxGroupOption[]) => Record<string, unknown>): void {\n    this._onChange = fn;\n  }\n\n  /**\n   * Registers a callback to be triggered when the control is touched.\n   * Implemented as part of ControlValueAccessor.\n   * @param fn Callback to be registered.\n   */\n  registerOnTouched(fn: () => Record<string, unknown>): void {\n    this._onTouched = fn;\n  }\n\n  /**\n   * Sets the disabled state of the control. Implemented as a part of ControlValueAccessor.\n   * @param isDisabled Whether the control should be disabled.\n   */\n  setDisabledState(isDisabled: boolean) {\n    this.disabled = isDisabled;\n  }\n\n  private _checkMasterCheckboxState() {\n    if (\n      (this.items as MtxCheckboxGroupOption[])\n        .filter(option => option.checked || !option.disabled)\n        .every(option => !option.checked)\n    ) {\n      this.selectAll = false;\n      this.selectAllIndeterminate = false;\n    } else if (\n      (this.items as MtxCheckboxGroupOption[])\n        .filter(option => option.checked || !option.disabled)\n        .every(option => option.checked)\n    ) {\n      this.selectAll = true;\n      this.selectAllIndeterminate = false;\n    } else {\n      this.selectAllIndeterminate = true;\n    }\n  }\n\n  private _getSelectedItems(index: number) {\n    this.selectedItems = (this.items as MtxCheckboxGroupOption[]).filter(option => option.checked);\n\n    if (this._compareWith) {\n      this.selectedItems = (this._originalItems as MtxCheckboxGroupOption[]).filter(option =>\n        this.selectedItems.find(selectedOption => this._compareWith!(option, selectedOption))\n      );\n    } else {\n      this.selectedItems = this.selectedItems.map(option => option[this.bindValue]);\n    }\n\n    this._onChange(this.selectedItems);\n\n    this.change.emit({ model: this.selectedItems, index });\n  }\n\n  /** Handle normal checkbox toggle */\n  _updateNormalCheckboxState(e: MatCheckboxChange, index: number): void {\n    this._checkMasterCheckboxState();\n    this._getSelectedItems(index);\n  }\n\n  /** Handle master checkbox toggle */\n  _updateMasterCheckboxState(e: MatCheckboxChange, index: number): void {\n    this.selectAll = !this.selectAll;\n    this.selectAllIndeterminate = false;\n\n    if (this.selectAll) {\n      (this.items as MtxCheckboxGroupOption[])\n        .filter(option => option.checked || !option.disabled)\n        .forEach(option => (option.checked = true));\n    } else {\n      (this.items as MtxCheckboxGroupOption[])\n        .filter(option => option.checked || !option.disabled)\n        .forEach(option => (option.checked = !!option.disabled));\n    }\n\n    this._getSelectedItems(index);\n  }\n\n  static ngAcceptInputType_showSelectAll: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n","<mat-checkbox class=\"mtx-checkbox-master\"\n              *ngIf=\"showSelectAll\"\n              [checked]=\"selectAll\"\n              [(indeterminate)]=\"selectAllIndeterminate\"\n              [disabled]=\"disabled\"\n              (change)=\"_updateMasterCheckboxState($event, -1)\">\n  {{selectAllLabel}}\n</mat-checkbox>\n\n<mat-checkbox class=\"mtx-checkbox-normal\"\n              *ngFor=\"let option of items; let i = index;\"\n              [(ngModel)]=\"option.checked\"\n              [ngModelOptions]=\"{standalone: true}\"\n              [aria-describedby]=\"option.ariaDescribedby\"\n              [aria-label]=\"option.ariaLabel\"\n              [aria-labelledby]=\"option.ariaLabelledby\"\n              [color]=\"option.color\"\n              [disabled]=\"option.disabled || disabled\"\n              [disableRipple]=\"option.disableRipple\"\n              [labelPosition]=\"option.labelPosition\"\n              [required]=\"option.required\"\n              (change)=\"_updateNormalCheckboxState($event, i)\">\n  {{option[bindLabel] | toObservable | async}}\n</mat-checkbox>\n"]}

package/esm2022/colorpicker/colorpicker-input.mjs

@@ -0,0 +1,229 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { DOWN_ARROW } from '@angular/cdk/keycodes';
+import { Directive, EventEmitter, forwardRef, Input, Optional, Output, } from '@angular/core';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR, Validators, } from '@angular/forms';
+import { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/form-field";
+export class MtxColorPickerInputEvent {
+    constructor(
+    /** Reference to the colorpicker input component that emitted the event. */
+    target, 
+    /** Reference to the native input element associated with the colorpicker input. */
+    targetElement) {
+        this.target = target;
+        this.targetElement = targetElement;
+        this.value = this.target.value;
+    }
+}
+export const MTX_COLORPICKER_VALUE_ACCESSOR = {
+    provide: NG_VALUE_ACCESSOR,
+    useExisting: forwardRef(() => MtxColorpickerInput),
+    multi: true,
+};
+export const MTX_COLORPICKER_VALIDATORS = {
+    provide: NG_VALIDATORS,
+    useExisting: forwardRef(() => MtxColorpickerInput),
+    multi: true,
+};
+class MtxColorpickerInput {
+    set mtxColorpicker(value) {
+        if (!value) {
+            return;
+        }
+        this._picker = value;
+        this._picker.registerInput(this);
+        this._pickerSubscription.unsubscribe();
+        this._pickerSubscription = this._picker._selectedChanged.subscribe((selected) => {
+            this.value = selected;
+            this._cvaOnChange(selected);
+            this._onTouched();
+            this.colorInput.emit(new MtxColorPickerInputEvent(this, this._elementRef.nativeElement));
+            this.colorChange.emit(new MtxColorPickerInputEvent(this, this._elementRef.nativeElement));
+        });
+    }
+    /** Whether the colorpicker-input is disabled. */
+    get disabled() {
+        return !!this._disabled;
+    }
+    set disabled(value) {
+        const newValue = coerceBooleanProperty(value);
+        const element = this._elementRef.nativeElement;
+        if (this._disabled !== newValue) {
+            this._disabled = newValue;
+            this._disabledChange.emit(newValue);
+        }
+        // We need to null check the `blur` method, because it's undefined during SSR.
+        // In Ivy static bindings are invoked earlier, before the element is attached to the DOM.
+        // This can cause an error to be thrown in some browsers (IE/Edge) which assert that the
+        // element has been inserted.
+        if (newValue && this._isInitialized && element.blur) {
+            // Normally, native input elements automatically blur if they turn disabled. This behavior
+            // is problematic, because it would mean that it triggers another change detection cycle,
+            // which then causes a changed after checked error if the input element was focused before.
+            element.blur();
+        }
+    }
+    /** The value of the input. */
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        const oldValue = this.value;
+        this._value = value;
+        this._formatValue(value);
+        this._valueChange.emit(value);
+    }
+    constructor(_elementRef, _formField) {
+        this._elementRef = _elementRef;
+        this._formField = _formField;
+        /** The input and output color format. */
+        this.format = 'hex';
+        /** Emits when a `change` event is fired on this `<input>`. */
+        this.colorChange = new EventEmitter();
+        /** Emits when an `input` event is fired on this `<input>`. */
+        this.colorInput = new EventEmitter();
+        /** Emits when the disabled state has changed */
+        this._disabledChange = new EventEmitter();
+        /** Emits when the value changes (either due to user input or programmatic change). */
+        this._valueChange = new EventEmitter();
+        this._onTouched = () => { };
+        this._validatorOnChange = () => { };
+        this._cvaOnChange = () => { };
+        this._pickerSubscription = Subscription.EMPTY;
+        /** The combined form control validator for this input. */
+        this._validator = Validators.compose([]);
+        /** Whether the last value set on the input was valid. */
+        this._lastValueValid = false;
+    }
+    ngAfterViewInit() {
+        this._isInitialized = true;
+    }
+    ngOnDestroy() {
+        this._pickerSubscription.unsubscribe();
+        this._valueChange.complete();
+        this._disabledChange.complete();
+    }
+    registerOnValidatorChange(fn) {
+        this._validatorOnChange = fn;
+    }
+    /** @docs-private */
+    validate(c) {
+        return this._validator ? this._validator(c) : null;
+    }
+    /**
+     * @deprecated
+     * @breaking-change 8.0.0 Use `getConnectedOverlayOrigin` instead
+     */
+    getPopupConnectionElementRef() {
+        return this.getConnectedOverlayOrigin();
+    }
+    /**
+     * Gets the element that the colorpicker popup should be connected to.
+     * @return The element to connect the popup to.
+     */
+    getConnectedOverlayOrigin() {
+        return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;
+    }
+    /** Gets the ID of an element that should be used a description for the overlay. */
+    getOverlayLabelId() {
+        if (this._formField) {
+            return this._formField.getLabelId();
+        }
+        return this._elementRef.nativeElement.getAttribute('aria-labelledby');
+    }
+    // Implemented as part of ControlValueAccessor.
+    writeValue(value) {
+        this.value = value;
+    }
+    // Implemented as part of ControlValueAccessor.
+    registerOnChange(fn) {
+        this._cvaOnChange = fn;
+    }
+    // Implemented as part of ControlValueAccessor.
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    // Implemented as part of ControlValueAccessor.
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    _onKeydown(event) {
+        const isAltDownArrow = event.altKey && event.keyCode === DOWN_ARROW;
+        if (this._picker && isAltDownArrow && !this._elementRef.nativeElement.readOnly) {
+            this._picker.open();
+            event.preventDefault();
+        }
+    }
+    /** Handles blur events on the input. */
+    _onBlur() {
+        // Reformat the input only if we have a valid value.
+        if (this.value) {
+            this._formatValue(this.value);
+        }
+        this._onTouched();
+    }
+    _onInput(value) {
+        const nextValue = value;
+        this._value = nextValue;
+        this._cvaOnChange(nextValue);
+        this._valueChange.emit(nextValue);
+        this.colorInput.emit(new MtxColorPickerInputEvent(this, this._elementRef.nativeElement));
+    }
+    _onChange() {
+        this.colorChange.emit(new MtxColorPickerInputEvent(this, this._elementRef.nativeElement));
+    }
+    /** Returns the palette used by the input's form field, if any. */
+    getThemePalette() {
+        return this._formField ? this._formField.color : undefined;
+    }
+    /** TODO: Formats a value and sets it on the input element. */
+    _formatValue(value) {
+        this._elementRef.nativeElement.value = value ? value : '';
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxColorpickerInput, deps: [{ token: i0.ElementRef }, { token: i1.MatFormField, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.3", type: MtxColorpickerInput, selector: "input[mtxColorpicker]", inputs: { mtxColorpicker: "mtxColorpicker", disabled: "disabled", value: "value", format: "format" }, outputs: { colorChange: "colorChange", colorInput: "colorInput" }, host: { listeners: { "input": "_onInput($event.target.value)", "change": "_onChange()", "blur": "_onBlur()", "keydown": "_onKeydown($event)" }, properties: { "attr.aria-haspopup": "_picker ? \"dialog\" : null", "attr.aria-owns": "(_picker?.opened && _picker.id) || null", "disabled": "disabled" }, classAttribute: "mtx-colorpicker-input" }, providers: [
+            MTX_COLORPICKER_VALUE_ACCESSOR,
+            MTX_COLORPICKER_VALIDATORS,
+            { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MtxColorpickerInput },
+        ], exportAs: ["mtxColorpickerInput"], ngImport: i0 }); }
+}
+export { MtxColorpickerInput };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxColorpickerInput, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[mtxColorpicker]',
+                    providers: [
+                        MTX_COLORPICKER_VALUE_ACCESSOR,
+                        MTX_COLORPICKER_VALIDATORS,
+                        { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MtxColorpickerInput },
+                    ],
+                    host: {
+                        'class': 'mtx-colorpicker-input',
+                        '[attr.aria-haspopup]': '_picker ? "dialog" : null',
+                        '[attr.aria-owns]': '(_picker?.opened && _picker.id) || null',
+                        '[disabled]': 'disabled',
+                        '(input)': '_onInput($event.target.value)',
+                        '(change)': '_onChange()',
+                        '(blur)': '_onBlur()',
+                        '(keydown)': '_onKeydown($event)',
+                    },
+                    exportAs: 'mtxColorpickerInput',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.MatFormField, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { mtxColorpicker: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], format: [{
+                type: Input
+            }], colorChange: [{
+                type: Output
+            }], colorInput: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"colorpicker-input.js","sourceRoot":"","sources":["../../../../projects/extensions/colorpicker/colorpicker-input.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { DOWN_ARROW } from '@angular/cdk/keycodes';\nimport {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Input,\n  OnDestroy,\n  Optional,\n  Output,\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NG_VALIDATORS,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors,\n  ValidatorFn,\n  Validators,\n} from '@angular/forms';\nimport { ThemePalette } from '@angular/material/core';\nimport { MatFormField } from '@angular/material/form-field';\nimport { MAT_INPUT_VALUE_ACCESSOR } from '@angular/material/input';\nimport { Subscription } from 'rxjs';\nimport { MtxColorpicker } from './colorpicker';\n\nexport class MtxColorPickerInputEvent {\n  /** The new value for the target colorpicker input. */\n  value: string | null;\n\n  constructor(\n    /** Reference to the colorpicker input component that emitted the event. */\n    public target: MtxColorpickerInput,\n    /** Reference to the native input element associated with the colorpicker input. */\n    public targetElement: HTMLElement\n  ) {\n    this.value = this.target.value;\n  }\n}\n\nexport const MTX_COLORPICKER_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => MtxColorpickerInput),\n  multi: true,\n};\n\nexport const MTX_COLORPICKER_VALIDATORS: any = {\n  provide: NG_VALIDATORS,\n  useExisting: forwardRef(() => MtxColorpickerInput),\n  multi: true,\n};\n\nexport type ColorFormat = 'hex' | 'rgb' | 'hsl' | 'hsv';\n\n@Directive({\n  selector: 'input[mtxColorpicker]',\n  providers: [\n    MTX_COLORPICKER_VALUE_ACCESSOR,\n    MTX_COLORPICKER_VALIDATORS,\n    { provide: MAT_INPUT_VALUE_ACCESSOR, useExisting: MtxColorpickerInput },\n  ],\n  host: {\n    'class': 'mtx-colorpicker-input',\n    '[attr.aria-haspopup]': '_picker ? \"dialog\" : null',\n    '[attr.aria-owns]': '(_picker?.opened && _picker.id) || null',\n    '[disabled]': 'disabled',\n    '(input)': '_onInput($event.target.value)',\n    '(change)': '_onChange()',\n    '(blur)': '_onBlur()',\n    '(keydown)': '_onKeydown($event)',\n  },\n  exportAs: 'mtxColorpickerInput',\n})\nexport class MtxColorpickerInput implements ControlValueAccessor, AfterViewInit, OnDestroy {\n  /** Whether the component has been initialized. */\n  private _isInitialized!: boolean;\n\n  @Input()\n  set mtxColorpicker(value: MtxColorpicker) {\n    if (!value) {\n      return;\n    }\n\n    this._picker = value;\n    this._picker.registerInput(this);\n    this._pickerSubscription.unsubscribe();\n\n    this._pickerSubscription = this._picker._selectedChanged.subscribe((selected: string) => {\n      this.value = selected;\n      this._cvaOnChange(selected);\n      this._onTouched();\n      this.colorInput.emit(new MtxColorPickerInputEvent(this, this._elementRef.nativeElement));\n      this.colorChange.emit(new MtxColorPickerInputEvent(this, this._elementRef.nativeElement));\n    });\n  }\n  _picker!: MtxColorpicker;\n\n  /** Whether the colorpicker-input is disabled. */\n  @Input()\n  get disabled(): boolean {\n    return !!this._disabled;\n  }\n  set disabled(value: boolean) {\n    const newValue = coerceBooleanProperty(value);\n    const element = this._elementRef.nativeElement;\n\n    if (this._disabled !== newValue) {\n      this._disabled = newValue;\n      this._disabledChange.emit(newValue);\n    }\n\n    // We need to null check the `blur` method, because it's undefined during SSR.\n    // In Ivy static bindings are invoked earlier, before the element is attached to the DOM.\n    // This can cause an error to be thrown in some browsers (IE/Edge) which assert that the\n    // element has been inserted.\n    if (newValue && this._isInitialized && element.blur) {\n      // Normally, native input elements automatically blur if they turn disabled. This behavior\n      // is problematic, because it would mean that it triggers another change detection cycle,\n      // which then causes a changed after checked error if the input element was focused before.\n      element.blur();\n    }\n  }\n  private _disabled!: boolean;\n\n  /** The value of the input. */\n  @Input()\n  get value(): string | null {\n    return this._value;\n  }\n  set value(value: string | null) {\n    const oldValue = this.value;\n    this._value = value;\n    this._formatValue(value);\n\n    this._valueChange.emit(value);\n  }\n  private _value!: string | null;\n\n  /** The input and output color format. */\n  @Input() format: ColorFormat = 'hex';\n\n  /** Emits when a `change` event is fired on this `<input>`. */\n  @Output() readonly colorChange: EventEmitter<MtxColorPickerInputEvent> =\n    new EventEmitter<MtxColorPickerInputEvent>();\n\n  /** Emits when an `input` event is fired on this `<input>`. */\n  @Output() readonly colorInput: EventEmitter<MtxColorPickerInputEvent> =\n    new EventEmitter<MtxColorPickerInputEvent>();\n\n  /** Emits when the disabled state has changed */\n  _disabledChange = new EventEmitter<boolean>();\n\n  /** Emits when the value changes (either due to user input or programmatic change). */\n  _valueChange = new EventEmitter<string | null>();\n\n  _onTouched = () => {};\n\n  _validatorOnChange = () => {};\n\n  private _cvaOnChange: (value: any) => void = () => {};\n\n  private _pickerSubscription = Subscription.EMPTY;\n\n  /** The combined form control validator for this input. */\n  private _validator: ValidatorFn | null = Validators.compose([]);\n\n  /** Whether the last value set on the input was valid. */\n  private _lastValueValid = false;\n\n  constructor(\n    private _elementRef: ElementRef<HTMLInputElement>,\n    @Optional() private _formField: MatFormField\n  ) {}\n\n  ngAfterViewInit() {\n    this._isInitialized = true;\n  }\n\n  ngOnDestroy() {\n    this._pickerSubscription.unsubscribe();\n    this._valueChange.complete();\n    this._disabledChange.complete();\n  }\n\n  registerOnValidatorChange(fn: () => void): void {\n    this._validatorOnChange = fn;\n  }\n\n  /** @docs-private */\n  validate(c: AbstractControl): ValidationErrors | null {\n    return this._validator ? this._validator(c) : null;\n  }\n\n  /**\n   * @deprecated\n   * @breaking-change 8.0.0 Use `getConnectedOverlayOrigin` instead\n   */\n  getPopupConnectionElementRef(): ElementRef {\n    return this.getConnectedOverlayOrigin();\n  }\n\n  /**\n   * Gets the element that the colorpicker popup should be connected to.\n   * @return The element to connect the popup to.\n   */\n  getConnectedOverlayOrigin(): ElementRef {\n    return this._formField ? this._formField.getConnectedOverlayOrigin() : this._elementRef;\n  }\n\n  /** Gets the ID of an element that should be used a description for the overlay. */\n  getOverlayLabelId(): string | null {\n    if (this._formField) {\n      return this._formField.getLabelId();\n    }\n\n    return this._elementRef.nativeElement.getAttribute('aria-labelledby');\n  }\n\n  // Implemented as part of ControlValueAccessor.\n  writeValue(value: string): void {\n    this.value = value;\n  }\n\n  // Implemented as part of ControlValueAccessor.\n  registerOnChange(fn: (value: any) => void): void {\n    this._cvaOnChange = fn;\n  }\n\n  // Implemented as part of ControlValueAccessor.\n  registerOnTouched(fn: () => void): void {\n    this._onTouched = fn;\n  }\n\n  // Implemented as part of ControlValueAccessor.\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  _onKeydown(event: KeyboardEvent) {\n    const isAltDownArrow = event.altKey && event.keyCode === DOWN_ARROW;\n\n    if (this._picker && isAltDownArrow && !this._elementRef.nativeElement.readOnly) {\n      this._picker.open();\n      event.preventDefault();\n    }\n  }\n\n  /** Handles blur events on the input. */\n  _onBlur() {\n    // Reformat the input only if we have a valid value.\n    if (this.value) {\n      this._formatValue(this.value);\n    }\n\n    this._onTouched();\n  }\n\n  _onInput(value: string) {\n    const nextValue = value;\n\n    this._value = nextValue;\n    this._cvaOnChange(nextValue);\n    this._valueChange.emit(nextValue);\n    this.colorInput.emit(new MtxColorPickerInputEvent(this, this._elementRef.nativeElement));\n  }\n\n  _onChange() {\n    this.colorChange.emit(new MtxColorPickerInputEvent(this, this._elementRef.nativeElement));\n  }\n\n  /** Returns the palette used by the input's form field, if any. */\n  getThemePalette(): ThemePalette {\n    return this._formField ? this._formField.color : undefined;\n  }\n\n  /** TODO: Formats a value and sets it on the input element. */\n  private _formatValue(value: string | null) {\n    this._elementRef.nativeElement.value = value ? value : '';\n  }\n\n  // Accept `any` to avoid conflicts with other directives on `<input>` that\n  // may accept different types.\n  static ngAcceptInputType_value: any;\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}

package/esm2022/colorpicker/colorpicker-module.mjs

@@ -0,0 +1,64 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { A11yModule } from '@angular/cdk/a11y';
+import { PortalModule } from '@angular/cdk/portal';
+import { MatButtonModule } from '@angular/material/button';
+import { MtxColorpickerInput } from './colorpicker-input';
+import { MtxColorpickerToggle, MtxColorpickerToggleIcon } from './colorpicker-toggle';
+import { MtxColorpicker, MtxColorpickerContent, MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, } from './colorpicker';
+import { ColorChromeModule } from 'ngx-color/chrome';
+import * as i0 from "@angular/core";
+class MtxColorpickerModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxColorpickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.3", ngImport: i0, type: MtxColorpickerModule, declarations: [MtxColorpicker,
+            MtxColorpickerContent,
+            MtxColorpickerInput,
+            MtxColorpickerToggle,
+            MtxColorpickerToggleIcon], imports: [CommonModule,
+            OverlayModule,
+            A11yModule,
+            PortalModule,
+            MatButtonModule,
+            ColorChromeModule], exports: [MtxColorpicker,
+            MtxColorpickerContent,
+            MtxColorpickerInput,
+            MtxColorpickerToggle,
+            MtxColorpickerToggleIcon] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxColorpickerModule, providers: [MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER], imports: [CommonModule,
+            OverlayModule,
+            A11yModule,
+            PortalModule,
+            MatButtonModule,
+            ColorChromeModule] }); }
+}
+export { MtxColorpickerModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.3", ngImport: i0, type: MtxColorpickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        OverlayModule,
+                        A11yModule,
+                        PortalModule,
+                        MatButtonModule,
+                        ColorChromeModule,
+                    ],
+                    exports: [
+                        MtxColorpicker,
+                        MtxColorpickerContent,
+                        MtxColorpickerInput,
+                        MtxColorpickerToggle,
+                        MtxColorpickerToggleIcon,
+                    ],
+                    declarations: [
+                        MtxColorpicker,
+                        MtxColorpickerContent,
+                        MtxColorpickerInput,
+                        MtxColorpickerToggle,
+                        MtxColorpickerToggleIcon,
+                    ],
+                    providers: [MTX_COLORPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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