ngx-color 7.2.0 → 7.3.0

package/esm2020/alpha.component.mjs

@@ -0,0 +1,186 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, NgModule, Output, } from '@angular/core';
+import { CheckboardModule } from './checkboard.component';
+import { CoordinatesModule } from './coordinates.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "./checkboard.component";
+import * as i2 from "@angular/common";
+import * as i3 from "./coordinates.directive";
+export class AlphaComponent {
+    constructor() {
+        this.direction = 'horizontal';
+        this.onChange = new EventEmitter();
+    }
+    ngOnChanges() {
+        if (this.direction === 'vertical') {
+            this.pointerLeft = 0;
+            this.pointerTop = this.rgb.a * 100;
+            this.gradient = {
+                background: `linear-gradient(to bottom, rgba(${this.rgb.r},${this.rgb.g},${this.rgb.b}, 0) 0%,
+          rgba(${this.rgb.r},${this.rgb.g},${this.rgb.b}, 1) 100%)`,
+            };
+        }
+        else {
+            this.gradient = {
+                background: `linear-gradient(to right, rgba(${this.rgb.r},${this.rgb.g},${this.rgb.b}, 0) 0%,
+          rgba(${this.rgb.r},${this.rgb.g},${this.rgb.b}, 1) 100%)`,
+            };
+            this.pointerLeft = this.rgb.a * 100;
+        }
+    }
+    handleChange({ top, left, containerHeight, containerWidth, $event }) {
+        let data;
+        if (this.direction === 'vertical') {
+            let a;
+            if (top < 0) {
+                a = 0;
+            }
+            else if (top > containerHeight) {
+                a = 1;
+            }
+            else {
+                a = Math.round(top * 100 / containerHeight) / 100;
+            }
+            if (this.hsl.a !== a) {
+                data = {
+                    h: this.hsl.h,
+                    s: this.hsl.s,
+                    l: this.hsl.l,
+                    a,
+                    source: 'rgb',
+                };
+            }
+        }
+        else {
+            let a;
+            if (left < 0) {
+                a = 0;
+            }
+            else if (left > containerWidth) {
+                a = 1;
+            }
+            else {
+                a = Math.round(left * 100 / containerWidth) / 100;
+            }
+            if (this.hsl.a !== a) {
+                data = {
+                    h: this.hsl.h,
+                    s: this.hsl.s,
+                    l: this.hsl.l,
+                    a,
+                    source: 'rgb',
+                };
+            }
+        }
+        if (!data) {
+            return;
+        }
+        this.onChange.emit({ data, $event });
+    }
+}
+AlphaComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: AlphaComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+AlphaComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: AlphaComponent, selector: "color-alpha", inputs: { hsl: "hsl", rgb: "rgb", pointer: "pointer", shadow: "shadow", radius: "radius", direction: "direction" }, outputs: { onChange: "onChange" }, usesOnChanges: true, ngImport: i0, template: `
+  <div class="alpha" [style.border-radius]="radius">
+    <div class="alpha-checkboard">
+      <color-checkboard></color-checkboard>
+    </div>
+    <div class="alpha-gradient" [ngStyle]="gradient" [style.box-shadow]="shadow" [style.border-radius]="radius"></div>
+    <div ngx-color-coordinates (coordinatesChange)="handleChange($event)" class="alpha-container color-alpha-{{direction}}">
+      <div class="alpha-pointer" [style.left.%]="pointerLeft" [style.top.%]="pointerTop">
+        <div class="alpha-slider" [ngStyle]="pointer"></div>
+      </div>
+    </div>
+  </div>
+  `, isInline: true, styles: [".alpha{position:absolute;top:0;bottom:0;left:0;right:0}.alpha-checkboard{position:absolute;top:0;bottom:0;left:0;right:0;overflow:hidden}.alpha-gradient{position:absolute;top:0;bottom:0;left:0;right:0}.alpha-container{position:relative;height:100%;margin:0 3px}.alpha-pointer{position:absolute}.alpha-slider{width:4px;border-radius:1px;height:8px;box-shadow:0 0 2px #0009;background:#fff;margin-top:1px;transform:translate(-2px)}\n"], components: [{ type: i1.CheckboardComponent, selector: "color-checkboard", inputs: ["white", "size", "grey", "boxShadow", "borderRadius"] }], directives: [{ type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i3.CoordinatesDirective, selector: "[ngx-color-coordinates]", outputs: ["coordinatesChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: AlphaComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'color-alpha',
+                    template: `
+  <div class="alpha" [style.border-radius]="radius">
+    <div class="alpha-checkboard">
+      <color-checkboard></color-checkboard>
+    </div>
+    <div class="alpha-gradient" [ngStyle]="gradient" [style.box-shadow]="shadow" [style.border-radius]="radius"></div>
+    <div ngx-color-coordinates (coordinatesChange)="handleChange($event)" class="alpha-container color-alpha-{{direction}}">
+      <div class="alpha-pointer" [style.left.%]="pointerLeft" [style.top.%]="pointerTop">
+        <div class="alpha-slider" [ngStyle]="pointer"></div>
+      </div>
+    </div>
+  </div>
+  `,
+                    styles: [
+                        `
+    .alpha {
+      position: absolute;
+      top: 0;
+      bottom: 0;
+      left: 0;
+      right: 0;
+    }
+    .alpha-checkboard {
+      position: absolute;
+      top: 0;
+      bottom: 0;
+      left: 0;
+      right: 0;
+      overflow: hidden;
+    }
+    .alpha-gradient {
+      position: absolute;
+      top: 0;
+      bottom: 0;
+      left: 0;
+      right: 0;
+    }
+    .alpha-container {
+      position: relative;
+      height: 100%;
+      margin: 0 3px;
+    }
+    .alpha-pointer {
+      position: absolute;
+    }
+    .alpha-slider {
+      width: 4px;
+      border-radius: 1px;
+      height: 8px;
+      box-shadow: 0 0 2px rgba(0, 0, 0, .6);
+      background: #fff;
+      margin-top: 1px;
+      transform: translateX(-2px);
+    }
+  `,
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    preserveWhitespaces: false,
+                }]
+        }], propDecorators: { hsl: [{
+                type: Input
+            }], rgb: [{
+                type: Input
+            }], pointer: [{
+                type: Input
+            }], shadow: [{
+                type: Input
+            }], radius: [{
+                type: Input
+            }], direction: [{
+                type: Input
+            }], onChange: [{
+                type: Output
+            }] } });
+export class AlphaModule {
+}
+AlphaModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: AlphaModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AlphaModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: AlphaModule, declarations: [AlphaComponent], imports: [CommonModule, CheckboardModule, CoordinatesModule], exports: [AlphaComponent] });
+AlphaModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: AlphaModule, imports: [[CommonModule, CheckboardModule, CoordinatesModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: AlphaModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AlphaComponent],
+                    exports: [AlphaComponent],
+                    imports: [CommonModule, CheckboardModule, CoordinatesModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alpha.component.js","sourceRoot":"","sources":["../../../src/lib/common/alpha.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  NgModule,\n  OnChanges,\n  Output,\n} from '@angular/core';\n\nimport { CheckboardModule } from './checkboard.component';\nimport { CoordinatesModule } from './coordinates.directive';\nimport { HSLA, RGBA } from './helpers/color.interfaces';\n\n\n@Component({\n  selector: 'color-alpha',\n  template: `\n  <div class=\"alpha\" [style.border-radius]=\"radius\">\n    <div class=\"alpha-checkboard\">\n      <color-checkboard></color-checkboard>\n    </div>\n    <div class=\"alpha-gradient\" [ngStyle]=\"gradient\" [style.box-shadow]=\"shadow\" [style.border-radius]=\"radius\"></div>\n    <div ngx-color-coordinates (coordinatesChange)=\"handleChange($event)\" class=\"alpha-container color-alpha-{{direction}}\">\n      <div class=\"alpha-pointer\" [style.left.%]=\"pointerLeft\" [style.top.%]=\"pointerTop\">\n        <div class=\"alpha-slider\" [ngStyle]=\"pointer\"></div>\n      </div>\n    </div>\n  </div>\n  `,\n  styles: [\n    `\n    .alpha {\n      position: absolute;\n      top: 0;\n      bottom: 0;\n      left: 0;\n      right: 0;\n    }\n    .alpha-checkboard {\n      position: absolute;\n      top: 0;\n      bottom: 0;\n      left: 0;\n      right: 0;\n      overflow: hidden;\n    }\n    .alpha-gradient {\n      position: absolute;\n      top: 0;\n      bottom: 0;\n      left: 0;\n      right: 0;\n    }\n    .alpha-container {\n      position: relative;\n      height: 100%;\n      margin: 0 3px;\n    }\n    .alpha-pointer {\n      position: absolute;\n    }\n    .alpha-slider {\n      width: 4px;\n      border-radius: 1px;\n      height: 8px;\n      box-shadow: 0 0 2px rgba(0, 0, 0, .6);\n      background: #fff;\n      margin-top: 1px;\n      transform: translateX(-2px);\n    }\n  `,\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  preserveWhitespaces: false,\n})\nexport class AlphaComponent implements OnChanges {\n  @Input() hsl!: HSLA;\n  @Input() rgb!: RGBA;\n  @Input() pointer!: Record<string, string>;\n  @Input() shadow!: string;\n  @Input() radius!: number | string;\n  @Input() direction: 'horizontal' | 'vertical' = 'horizontal';\n  @Output() onChange = new EventEmitter<any>();\n  gradient!: Record<string, string>;\n  pointerLeft!: number;\n  pointerTop!: number;\n\n  ngOnChanges() {\n    if (this.direction === 'vertical') {\n      this.pointerLeft = 0;\n      this.pointerTop = this.rgb.a * 100;\n      this.gradient = {\n        background: `linear-gradient(to bottom, rgba(${this.rgb.r},${\n          this.rgb.g\n        },${this.rgb.b}, 0) 0%,\n          rgba(${this.rgb.r},${this.rgb.g},${this.rgb.b}, 1) 100%)`,\n      };\n    } else {\n      this.gradient = {\n        background: `linear-gradient(to right, rgba(${this.rgb.r},${\n          this.rgb.g\n        },${this.rgb.b}, 0) 0%,\n          rgba(${this.rgb.r},${this.rgb.g},${this.rgb.b}, 1) 100%)`,\n      };\n      this.pointerLeft = this.rgb.a * 100;\n    }\n  }\n  handleChange({ top, left, containerHeight, containerWidth, $event }): void {\n    let data: any;\n    if (this.direction === 'vertical') {\n      let a: number;\n      if (top < 0) {\n        a = 0;\n      } else if (top > containerHeight) {\n        a = 1;\n      } else {\n        a = Math.round(top * 100 / containerHeight) / 100;\n      }\n\n      if (this.hsl.a !== a) {\n        data = {\n          h: this.hsl.h,\n          s: this.hsl.s,\n          l: this.hsl.l,\n          a,\n          source: 'rgb',\n        };\n      }\n    } else {\n      let a: number;\n      if (left < 0) {\n        a = 0;\n      } else if (left > containerWidth) {\n        a = 1;\n      } else {\n        a = Math.round(left * 100 / containerWidth) / 100;\n      }\n\n      if (this.hsl.a !== a) {\n        data = {\n          h: this.hsl.h,\n          s: this.hsl.s,\n          l: this.hsl.l,\n          a,\n          source: 'rgb',\n        };\n      }\n    }\n\n    if (!data) {\n      return;\n    }\n\n    this.onChange.emit({ data, $event });\n  }\n}\n\n@NgModule({\n  declarations: [AlphaComponent],\n  exports: [AlphaComponent],\n  imports: [CommonModule, CheckboardModule, CoordinatesModule],\n})\nexport class AlphaModule {}\n"]}

package/esm2020/checkboard.component.mjs

@@ -0,0 +1,66 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Input, NgModule, } from '@angular/core';
+import { getCheckerboard } from './helpers/checkboard';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class CheckboardComponent {
+    constructor() {
+        this.white = 'transparent';
+        this.size = 8;
+        this.grey = 'rgba(0,0,0,.08)';
+    }
+    ngOnInit() {
+        const background = getCheckerboard(this.white, this.grey, this.size);
+        this.gridStyles = {
+            borderRadius: this.borderRadius,
+            boxShadow: this.boxShadow,
+            background: `url(${background}) center left`,
+        };
+    }
+}
+CheckboardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CheckboardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CheckboardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: CheckboardComponent, selector: "color-checkboard", inputs: { white: "white", size: "size", grey: "grey", boxShadow: "boxShadow", borderRadius: "borderRadius" }, ngImport: i0, template: `<div class="grid" [ngStyle]="gridStyles"></div>`, isInline: true, styles: [".grid{top:0px;right:0px;bottom:0px;left:0px;position:absolute}\n"], directives: [{ type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CheckboardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'color-checkboard',
+                    template: `<div class="grid" [ngStyle]="gridStyles"></div>`,
+                    styles: [
+                        `
+  .grid {
+    top: 0px;
+    right: 0px;
+    bottom: 0px;
+    left: 0px;
+    position: absolute;
+  }
+  `,
+                    ],
+                    preserveWhitespaces: false,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], propDecorators: { white: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], grey: [{
+                type: Input
+            }], boxShadow: [{
+                type: Input
+            }], borderRadius: [{
+                type: Input
+            }] } });
+export class CheckboardModule {
+}
+CheckboardModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CheckboardModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CheckboardModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CheckboardModule, declarations: [CheckboardComponent], imports: [CommonModule], exports: [CheckboardComponent] });
+CheckboardModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CheckboardModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CheckboardModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [CheckboardComponent],
+                    exports: [CheckboardComponent],
+                    imports: [CommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/color-wrap.component.mjs

@@ -0,0 +1,163 @@
+import { CommonModule } from '@angular/common';
+import { Component, EventEmitter, forwardRef, Input, isDevMode, NgModule, Output, } from '@angular/core';
+import { Subscription } from 'rxjs';
+import { debounceTime, tap } from 'rxjs/operators';
+import { simpleCheckForValidColor, toState } from './helpers/color';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+export var ColorMode;
+(function (ColorMode) {
+    ColorMode["HEX"] = "hex";
+    ColorMode["HSL"] = "hsl";
+    ColorMode["HSV"] = "hsv";
+    ColorMode["RGB"] = "rgb";
+})(ColorMode || (ColorMode = {}));
+export class ColorWrap {
+    constructor() {
+        /**
+         * Descriptors the return color format if the component is used with two-way binding
+         */
+        this.mode = ColorMode.HEX;
+        this.color = {
+            h: 250,
+            s: 0.5,
+            l: 0.2,
+            a: 1,
+        };
+        this.colorChange = new EventEmitter();
+        this.onChange = new EventEmitter();
+        this.onChangeComplete = new EventEmitter();
+        this.onSwatchHover = new EventEmitter();
+        this._onChangeCompleteSubscription = new Subscription();
+        this._onSwatchHoverSubscription = new Subscription();
+    }
+    ngOnInit() {
+        this.changes = this.onChange
+            .pipe(debounceTime(100), tap(event => {
+            this.onChangeComplete.emit(event);
+            switch (this.mode) {
+                case ColorMode.HEX:
+                    this.colorChange.emit(event.color.hex);
+                    break;
+                case ColorMode.HSL:
+                    this.colorChange.emit(event.color.hsl);
+                    break;
+                case ColorMode.HSV:
+                    this.colorChange.emit(event.color.hsv);
+                    break;
+                case ColorMode.RGB:
+                    this.colorChange.emit(event.color.rgb);
+                    break;
+                default:
+                    const msg = `The mode '${this.mode}' is not supported`;
+                    if (isDevMode()) {
+                        throw new Error(msg);
+                    }
+                    else {
+                        console.warn(msg);
+                    }
+                    break;
+            }
+        }))
+            .subscribe();
+        this.setState(toState(this.color, 0));
+        this.currentColor = this.hex;
+    }
+    ngOnChanges() {
+        this.setState(toState(this.color, this.oldHue));
+    }
+    ngOnDestroy() {
+        this.changes?.unsubscribe();
+        this._onChangeCompleteSubscription.unsubscribe();
+        this._onSwatchHoverSubscription.unsubscribe();
+    }
+    setState(data) {
+        this.oldHue = data.oldHue;
+        this.hsl = data.hsl;
+        this.hsv = data.hsv;
+        this.rgb = data.rgb;
+        this.hex = data.hex;
+        this.source = data.source;
+        this.afterValidChange();
+    }
+    handleChange(data, $event) {
+        const isValidColor = simpleCheckForValidColor(data);
+        if (isValidColor) {
+            const color = toState(data, data.h || this.oldHue, this.disableAlpha);
+            this.setState(color);
+            this.onChange.emit({ color, $event });
+            this.afterValidChange();
+        }
+    }
+    /** hook for components after a complete change */
+    afterValidChange() { }
+    handleSwatchHover(data, $event) {
+        const isValidColor = simpleCheckForValidColor(data);
+        if (isValidColor) {
+            const color = toState(data, data.h || this.oldHue);
+            this.setState(color);
+            this.onSwatchHover.emit({ color, $event });
+        }
+    }
+    registerOnChange(fn) {
+        this._onChangeCompleteSubscription.add(this.onChangeComplete.pipe(tap(event => fn(event.color.hex))).subscribe());
+    }
+    registerOnTouched(fn) {
+        this._onSwatchHoverSubscription.add(this.onSwatchHover.pipe(tap(() => fn())).subscribe());
+    }
+    setDisabledState(isDisabled) { }
+    writeValue(hex) {
+        this.color = hex;
+    }
+}
+ColorWrap.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrap, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ColorWrap.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ColorWrap, selector: "color-wrap", inputs: { className: "className", mode: "mode", color: "color" }, outputs: { colorChange: "colorChange", onChange: "onChange", onChangeComplete: "onChangeComplete", onSwatchHover: "onSwatchHover" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => ColorWrap),
+            multi: true,
+        }
+    ], usesOnChanges: true, ngImport: i0, template: ``, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrap, decorators: [{
+            type: Component,
+            args: [{
+                    // create seletor base for test override property
+                    selector: 'color-wrap',
+                    template: ``,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => ColorWrap),
+                            multi: true,
+                        }
+                    ]
+                }]
+        }], propDecorators: { className: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], colorChange: [{
+                type: Output
+            }], onChange: [{
+                type: Output
+            }], onChangeComplete: [{
+                type: Output
+            }], onSwatchHover: [{
+                type: Output
+            }] } });
+export class ColorWrapModule {
+}
+ColorWrapModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrapModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ColorWrapModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrapModule, declarations: [ColorWrap], imports: [CommonModule], exports: [ColorWrap] });
+ColorWrapModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrapModule, imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorWrapModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ColorWrap],
+                    exports: [ColorWrap],
+                    imports: [CommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"color-wrap.component.js","sourceRoot":"","sources":["../../../src/lib/common/color-wrap.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  Component,\n  EventEmitter,\n  forwardRef,\n  Input,\n  isDevMode,\n  NgModule,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n} from '@angular/core';\n\nimport { Subscription } from 'rxjs';\nimport { debounceTime, tap } from 'rxjs/operators';\n\nimport { simpleCheckForValidColor, toState } from './helpers/color';\nimport { Color, HSLA, HSVA, RGBA } from './helpers/color.interfaces';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nexport interface ColorEvent {\n  $event: Event;\n  color: Color;\n}\n\nexport enum ColorMode {\n  HEX = 'hex',\n  HSL = 'hsl',\n  HSV = 'hsv',\n  RGB = 'rgb'\n}\n\n@Component({\n  // create seletor base for test override property\n  selector: 'color-wrap',\n  template: ``,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => ColorWrap),\n      multi: true,\n    }\n  ]\n})\nexport class ColorWrap implements OnInit, OnChanges, OnDestroy, ControlValueAccessor {\n  @Input() className?: string;\n\n  /**\n   * Descriptors the return color format if the component is used with two-way binding\n   */\n  @Input() mode: ColorMode = ColorMode.HEX;\n\n  @Input() color: HSLA | HSVA | RGBA | string = {\n    h: 250,\n    s: 0.5,\n    l: 0.2,\n    a: 1,\n  };\n  @Output() colorChange = new EventEmitter<HSLA | HSVA | RGBA | string>();\n  @Output() onChange = new EventEmitter<ColorEvent>();\n  @Output() onChangeComplete = new EventEmitter<ColorEvent>();\n  @Output() onSwatchHover = new EventEmitter<ColorEvent>();\n  oldHue!: number;\n  hsl!: HSLA;\n  hsv!: HSVA;\n  rgb!: RGBA;\n  hex!: string;\n  source!: string;\n  currentColor!: string;\n  changes?: Subscription;\n  disableAlpha?: boolean;\n\n  private _onChangeCompleteSubscription = new Subscription();\n  private _onSwatchHoverSubscription = new Subscription();\n\n  ngOnInit() {\n    this.changes = this.onChange\n      .pipe(\n        debounceTime(100),\n        tap(event => {\n          this.onChangeComplete.emit(event);\n          switch (this.mode) {\n            case ColorMode.HEX:\n              this.colorChange.emit(event.color.hex);\n              break;\n            case ColorMode.HSL:\n              this.colorChange.emit(event.color.hsl);\n              break;\n            case ColorMode.HSV:\n              this.colorChange.emit(event.color.hsv);\n              break;\n            case ColorMode.RGB:\n              this.colorChange.emit(event.color.rgb);\n              break;\n            default:\n              const msg = `The mode '${this.mode}' is not supported`;\n              if (isDevMode()) {\n                throw new Error(msg);\n              } else {\n                console.warn(msg);\n              }\n              break;\n          }\n        })\n      )\n      .subscribe();\n    this.setState(toState(this.color, 0));\n    this.currentColor = this.hex;\n  }\n  ngOnChanges() {\n    this.setState(toState(this.color, this.oldHue));\n  }\n  ngOnDestroy() {\n    this.changes?.unsubscribe();\n    this._onChangeCompleteSubscription.unsubscribe();\n    this._onSwatchHoverSubscription.unsubscribe();\n  }\n  setState(data) {\n    this.oldHue = data.oldHue;\n    this.hsl = data.hsl;\n    this.hsv = data.hsv;\n    this.rgb = data.rgb;\n    this.hex = data.hex;\n    this.source = data.source;\n    this.afterValidChange();\n  }\n  handleChange(data, $event) {\n    const isValidColor = simpleCheckForValidColor(data);\n    if (isValidColor) {\n      const color = toState(data, data.h || this.oldHue, this.disableAlpha);\n      this.setState(color);\n      this.onChange.emit({ color, $event });\n      this.afterValidChange();\n    }\n  }\n  /** hook for components after a complete change */\n  afterValidChange() {}\n\n  handleSwatchHover(data, $event) {\n    const isValidColor = simpleCheckForValidColor(data);\n    if (isValidColor) {\n      const color = toState(data, data.h || this.oldHue);\n      this.setState(color);\n      this.onSwatchHover.emit({ color, $event });\n    }\n  }\n\n  registerOnChange(fn: (hex: string) => void): void {\n    this._onChangeCompleteSubscription.add(this.onChangeComplete.pipe(\n      tap(event => fn(event.color.hex)),\n    ).subscribe());\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this._onSwatchHoverSubscription.add(this.onSwatchHover.pipe(\n      tap(() => fn()),\n    ).subscribe());\n  }\n\n  setDisabledState(isDisabled: boolean): void {}\n\n  writeValue(hex: string): void {\n    this.color = hex;\n  }\n\n}\n\n@NgModule({\n  declarations: [ColorWrap],\n  exports: [ColorWrap],\n  imports: [CommonModule],\n})\nexport class ColorWrapModule {}\n"]}

package/esm2020/coordinates.directive.mjs

@@ -0,0 +1,104 @@
+import { Directive, HostListener, NgModule, Output, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { distinctUntilChanged } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class CoordinatesDirective {
+    constructor(el) {
+        this.el = el;
+        this.coordinatesChange = new Subject();
+        this.mousechange = new Subject();
+        this.mouseListening = false;
+    }
+    mousemove($event, x, y, isTouch = false) {
+        if (this.mouseListening) {
+            $event.preventDefault();
+            this.mousechange.next({ $event, x, y, isTouch });
+        }
+    }
+    mouseup() {
+        this.mouseListening = false;
+    }
+    mousedown($event, x, y, isTouch = false) {
+        $event.preventDefault();
+        this.mouseListening = true;
+        this.mousechange.next({ $event, x, y, isTouch });
+    }
+    ngOnInit() {
+        this.sub = this.mousechange
+            .pipe(
+        // limit times it is updated for the same area
+        distinctUntilChanged((p, q) => p.x === q.x && p.y === q.y))
+            .subscribe(n => this.handleChange(n.x, n.y, n.$event, n.isTouch));
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+    }
+    handleChange(x, y, $event, isTouch) {
+        const containerWidth = this.el.nativeElement.clientWidth;
+        const containerHeight = this.el.nativeElement.clientHeight;
+        const left = x -
+            (this.el.nativeElement.getBoundingClientRect().left + window.pageXOffset);
+        let top = y - this.el.nativeElement.getBoundingClientRect().top;
+        if (!isTouch) {
+            top = top - window.pageYOffset;
+        }
+        this.coordinatesChange.next({
+            x,
+            y,
+            top,
+            left,
+            containerWidth,
+            containerHeight,
+            $event,
+        });
+    }
+}
+CoordinatesDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CoordinatesDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+CoordinatesDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: CoordinatesDirective, selector: "[ngx-color-coordinates]", outputs: { coordinatesChange: "coordinatesChange" }, host: { listeners: { "window:mousemove": "mousemove($event,$event.pageX,$event.pageY)", "window:touchmove": "mousemove($event,$event.touches[0].clientX,$event.touches[0].clientY,true)", "window:mouseup": "mouseup()", "window:touchend": "mouseup()", "mousedown": "mousedown($event,$event.pageX,$event.pageY)", "touchstart": "mousedown($event,$event.touches[0].clientX,$event.touches[0].clientY,true)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CoordinatesDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[ngx-color-coordinates]' }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { coordinatesChange: [{
+                type: Output
+            }], mousemove: [{
+                type: HostListener,
+                args: ['window:mousemove', ['$event', '$event.pageX', '$event.pageY']]
+            }, {
+                type: HostListener,
+                args: ['window:touchmove', [
+                        '$event',
+                        '$event.touches[0].clientX',
+                        '$event.touches[0].clientY',
+                        'true',
+                    ]]
+            }], mouseup: [{
+                type: HostListener,
+                args: ['window:mouseup']
+            }, {
+                type: HostListener,
+                args: ['window:touchend']
+            }], mousedown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event', '$event.pageX', '$event.pageY']]
+            }, {
+                type: HostListener,
+                args: ['touchstart', [
+                        '$event',
+                        '$event.touches[0].clientX',
+                        '$event.touches[0].clientY',
+                        'true',
+                    ]]
+            }] } });
+export class CoordinatesModule {
+}
+CoordinatesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CoordinatesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CoordinatesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CoordinatesModule, declarations: [CoordinatesDirective], exports: [CoordinatesDirective] });
+CoordinatesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CoordinatesModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: CoordinatesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [CoordinatesDirective],
+                    exports: [CoordinatesDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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