ngx-color 8.0.3 → 9.0.0

package/esm2022/chrome/chrome.component.mjs

@@ -0,0 +1,187 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, forwardRef, Input, NgModule } from '@angular/core';
+import { AlphaModule, CheckboardModule, ColorWrap, EditableInputModule, HueModule, SaturationModule } from 'ngx-color';
+import { ChromeFieldsComponent } from './chrome-fields.component';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "ngx-color";
+class ChromeComponent extends ColorWrap {
+    /** Remove alpha slider and options from picker */
+    disableAlpha = false;
+    circle = {
+        width: '12px',
+        height: '12px',
+        borderRadius: '6px',
+        boxShadow: 'rgb(255, 255, 255) 0px 0px 0px 1px inset',
+        transform: 'translate(-6px, -8px)',
+    };
+    pointer = {
+        width: '12px',
+        height: '12px',
+        borderRadius: '6px',
+        transform: 'translate(-6px, -2px)',
+        backgroundColor: 'rgb(248, 248, 248)',
+        boxShadow: '0 1px 4px 0 rgba(0, 0, 0, 0.37)',
+    };
+    activeBackground;
+    constructor() {
+        super();
+    }
+    afterValidChange() {
+        const alpha = this.disableAlpha ? 1 : this.rgb.a;
+        this.activeBackground = `rgba(${this.rgb.r}, ${this.rgb.g}, ${this.rgb.b}, ${alpha})`;
+    }
+    handleValueChange({ data, $event }) {
+        this.handleChange(data, $event);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ChromeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.1", type: ChromeComponent, selector: "color-chrome", inputs: { disableAlpha: "disableAlpha" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => ChromeComponent),
+                multi: true,
+            },
+            {
+                provide: ColorWrap,
+                useExisting: forwardRef(() => ChromeComponent),
+            },
+        ], usesInheritance: true, ngImport: i0, template: `
+  <div class="chrome-picker {{ className }}">
+    <div class="saturation">
+      <color-saturation
+        [hsl]="hsl"
+        [hsv]="hsv"
+        [circle]="circle"
+        (onChange)="handleValueChange($event)"
+      ></color-saturation>
+    </div>
+    <div class="chrome-body">
+      <div class="chrome-controls">
+        <div class="chrome-color">
+          <div class="chrome-swatch">
+            <div class="chrome-active"
+              [style.background]="activeBackground"
+            ></div>
+            <color-checkboard></color-checkboard>
+          </div>
+        </div>
+        <div class="chrome-toggles">
+          <div class="chrome-hue">
+            <color-hue
+              [radius]="2"
+              [hsl]="hsl"
+              [pointer]="pointer"
+              (onChange)="handleValueChange($event)"
+            ></color-hue>
+          </div>
+          <div class="chrome-alpha" *ngIf="!disableAlpha">
+            <color-alpha
+              [radius]="2" [rgb]="rgb" [hsl]="hsl"
+              [pointer]="pointer" (onChange)="handleValueChange($event)"
+            ></color-alpha>
+          </div>
+        </div>
+      </div>
+      <color-chrome-fields
+        [rgb]="rgb" [hsl]="hsl" [hex]="hex"
+        [disableAlpha]="disableAlpha"
+        (onChange)="handleValueChange($event)"
+      ></color-chrome-fields>
+    </div>
+  </div>
+  `, isInline: true, styles: [".chrome-picker{background:#fff;border-radius:2px;box-shadow:0 0 2px #0000004d,0 4px 8px #0000004d;box-sizing:initial;width:225px;font-family:Menlo}.chrome-controls{display:flex}.chrome-color{width:42px}.chrome-body{padding:14px 14px 12px}.chrome-active{position:absolute;inset:0;border-radius:20px;box-shadow:inset 0 0 0 1px #0000001a;z-index:2}.chrome-swatch{width:28px;height:28px;border-radius:15px;position:relative;overflow:hidden}.saturation{width:100%;padding-bottom:55%;position:relative;border-radius:2px 2px 0 0;overflow:hidden}.chrome-toggles{flex:1}.chrome-hue{height:10px;position:relative;margin-bottom:8px}.chrome-alpha{height:10px;position:relative}\n"], dependencies: [{ kind: "directive", type: i0.forwardRef(function () { return i1.NgIf; }), selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i0.forwardRef(function () { return i2.AlphaComponent; }), selector: "color-alpha", inputs: ["hsl", "rgb", "pointer", "shadow", "radius", "direction"], outputs: ["onChange"] }, { kind: "component", type: i0.forwardRef(function () { return i2.CheckboardComponent; }), selector: "color-checkboard", inputs: ["white", "size", "grey", "boxShadow", "borderRadius"] }, { kind: "component", type: i0.forwardRef(function () { return i2.HueComponent; }), selector: "color-hue", inputs: ["hsl", "pointer", "radius", "shadow", "hidePointer", "direction"], outputs: ["onChange"] }, { kind: "component", type: i0.forwardRef(function () { return i2.SaturationComponent; }), selector: "color-saturation", inputs: ["hsl", "hsv", "radius", "pointer", "circle"], outputs: ["onChange"] }, { kind: "component", type: i0.forwardRef(function () { return ChromeFieldsComponent; }), selector: "color-chrome-fields", inputs: ["disableAlpha", "hsl", "rgb", "hex"], outputs: ["onChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+export { ChromeComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ChromeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'color-chrome', template: `
+  <div class="chrome-picker {{ className }}">
+    <div class="saturation">
+      <color-saturation
+        [hsl]="hsl"
+        [hsv]="hsv"
+        [circle]="circle"
+        (onChange)="handleValueChange($event)"
+      ></color-saturation>
+    </div>
+    <div class="chrome-body">
+      <div class="chrome-controls">
+        <div class="chrome-color">
+          <div class="chrome-swatch">
+            <div class="chrome-active"
+              [style.background]="activeBackground"
+            ></div>
+            <color-checkboard></color-checkboard>
+          </div>
+        </div>
+        <div class="chrome-toggles">
+          <div class="chrome-hue">
+            <color-hue
+              [radius]="2"
+              [hsl]="hsl"
+              [pointer]="pointer"
+              (onChange)="handleValueChange($event)"
+            ></color-hue>
+          </div>
+          <div class="chrome-alpha" *ngIf="!disableAlpha">
+            <color-alpha
+              [radius]="2" [rgb]="rgb" [hsl]="hsl"
+              [pointer]="pointer" (onChange)="handleValueChange($event)"
+            ></color-alpha>
+          </div>
+        </div>
+      </div>
+      <color-chrome-fields
+        [rgb]="rgb" [hsl]="hsl" [hex]="hex"
+        [disableAlpha]="disableAlpha"
+        (onChange)="handleValueChange($event)"
+      ></color-chrome-fields>
+    </div>
+  </div>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, preserveWhitespaces: false, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => ChromeComponent),
+                            multi: true,
+                        },
+                        {
+                            provide: ColorWrap,
+                            useExisting: forwardRef(() => ChromeComponent),
+                        },
+                    ], styles: [".chrome-picker{background:#fff;border-radius:2px;box-shadow:0 0 2px #0000004d,0 4px 8px #0000004d;box-sizing:initial;width:225px;font-family:Menlo}.chrome-controls{display:flex}.chrome-color{width:42px}.chrome-body{padding:14px 14px 12px}.chrome-active{position:absolute;inset:0;border-radius:20px;box-shadow:inset 0 0 0 1px #0000001a;z-index:2}.chrome-swatch{width:28px;height:28px;border-radius:15px;position:relative;overflow:hidden}.saturation{width:100%;padding-bottom:55%;position:relative;border-radius:2px 2px 0 0;overflow:hidden}.chrome-toggles{flex:1}.chrome-hue{height:10px;position:relative;margin-bottom:8px}.chrome-alpha{height:10px;position:relative}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { disableAlpha: [{
+                type: Input
+            }] } });
+class ColorChromeModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ColorChromeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.1", ngImport: i0, type: ColorChromeModule, declarations: [ChromeComponent, ChromeFieldsComponent], imports: [CommonModule,
+            AlphaModule,
+            CheckboardModule,
+            EditableInputModule,
+            HueModule,
+            SaturationModule], exports: [ChromeComponent, ChromeFieldsComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ColorChromeModule, imports: [CommonModule,
+            AlphaModule,
+            CheckboardModule,
+            EditableInputModule,
+            HueModule,
+            SaturationModule] });
+}
+export { ColorChromeModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ColorChromeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ChromeComponent, ChromeFieldsComponent],
+                    exports: [ChromeComponent, ChromeFieldsComponent],
+                    imports: [
+                        CommonModule,
+                        AlphaModule,
+                        CheckboardModule,
+                        EditableInputModule,
+                        HueModule,
+                        SaturationModule,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chrome.component.js","sourceRoot":"","sources":["../../../src/lib/chrome/chrome.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport { ChangeDetectionStrategy, Component, forwardRef, Input, NgModule } from '@angular/core';\n\nimport { AlphaModule, CheckboardModule, ColorWrap, EditableInputModule, HueModule, SaturationModule } from 'ngx-color';\nimport { ChromeFieldsComponent } from './chrome-fields.component';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\n\n@Component({\n  selector: 'color-chrome',\n  template: `\n  <div class=\"chrome-picker {{ className }}\">\n    <div class=\"saturation\">\n      <color-saturation\n        [hsl]=\"hsl\"\n        [hsv]=\"hsv\"\n        [circle]=\"circle\"\n        (onChange)=\"handleValueChange($event)\"\n      ></color-saturation>\n    </div>\n    <div class=\"chrome-body\">\n      <div class=\"chrome-controls\">\n        <div class=\"chrome-color\">\n          <div class=\"chrome-swatch\">\n            <div class=\"chrome-active\"\n              [style.background]=\"activeBackground\"\n            ></div>\n            <color-checkboard></color-checkboard>\n          </div>\n        </div>\n        <div class=\"chrome-toggles\">\n          <div class=\"chrome-hue\">\n            <color-hue\n              [radius]=\"2\"\n              [hsl]=\"hsl\"\n              [pointer]=\"pointer\"\n              (onChange)=\"handleValueChange($event)\"\n            ></color-hue>\n          </div>\n          <div class=\"chrome-alpha\" *ngIf=\"!disableAlpha\">\n            <color-alpha\n              [radius]=\"2\" [rgb]=\"rgb\" [hsl]=\"hsl\"\n              [pointer]=\"pointer\" (onChange)=\"handleValueChange($event)\"\n            ></color-alpha>\n          </div>\n        </div>\n      </div>\n      <color-chrome-fields\n        [rgb]=\"rgb\" [hsl]=\"hsl\" [hex]=\"hex\"\n        [disableAlpha]=\"disableAlpha\"\n        (onChange)=\"handleValueChange($event)\"\n      ></color-chrome-fields>\n    </div>\n  </div>\n  `,\n  styles: [\n    `\n      .chrome-picker {\n        background: #fff;\n        border-radius: 2px;\n        box-shadow: 0 0 2px rgba(0, 0, 0, 0.3), 0 4px 8px rgba(0, 0, 0, 0.3);\n        box-sizing: initial;\n        width: 225px;\n        font-family: 'Menlo';\n      }\n      .chrome-controls {\n        display: flex;\n      }\n      .chrome-color {\n        width: 42px;\n      }\n      .chrome-body {\n        padding: 14px 14px 12px;\n      }\n      .chrome-active {\n        position: absolute;\n        top: 0;\n        bottom: 0;\n        left: 0;\n        right: 0;\n        border-radius: 20px;\n        box-shadow: inset 0 0 0 1px rgba(0, 0, 0, 0.1);\n        z-index: 2;\n      }\n      .chrome-swatch {\n        width: 28px;\n        height: 28px;\n        border-radius: 15px;\n        position: relative;\n        overflow: hidden;\n      }\n      .saturation {\n        width: 100%;\n        padding-bottom: 55%;\n        position: relative;\n        border-radius: 2px 2px 0 0;\n        overflow: hidden;\n      }\n      .chrome-toggles {\n        flex: 1;\n      }\n      .chrome-hue {\n        height: 10px;\n        position: relative;\n        margin-bottom: 8px;\n      }\n      .chrome-alpha {\n        height: 10px;\n        position: relative;\n      }\n    `,\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  preserveWhitespaces: false,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => ChromeComponent),\n      multi: true,\n    },\n    {\n      provide: ColorWrap,\n      useExisting: forwardRef(() => ChromeComponent),\n    },\n  ]\n})\nexport class ChromeComponent extends ColorWrap {\n  /** Remove alpha slider and options from picker */\n  @Input() disableAlpha = false;\n  circle: Record<string, string> = {\n    width: '12px',\n    height: '12px',\n    borderRadius: '6px',\n    boxShadow: 'rgb(255, 255, 255) 0px 0px 0px 1px inset',\n    transform: 'translate(-6px, -8px)',\n  };\n  pointer: Record<string, string> = {\n    width: '12px',\n    height: '12px',\n    borderRadius: '6px',\n    transform: 'translate(-6px, -2px)',\n    backgroundColor: 'rgb(248, 248, 248)',\n    boxShadow: '0 1px 4px 0 rgba(0, 0, 0, 0.37)',\n  };\n  activeBackground!: string;\n\n  constructor() {\n    super();\n  }\n\n  afterValidChange() {\n    const alpha = this.disableAlpha ? 1 : this.rgb.a;\n    this.activeBackground = `rgba(${this.rgb.r}, ${this.rgb.g}, ${this.rgb.b}, ${alpha})`;\n  }\n  handleValueChange({ data, $event }) {\n    this.handleChange(data, $event);\n  }\n}\n\n@NgModule({\n  declarations: [ChromeComponent, ChromeFieldsComponent],\n  exports: [ChromeComponent, ChromeFieldsComponent],\n  imports: [\n    CommonModule,\n    AlphaModule,\n    CheckboardModule,\n    EditableInputModule,\n    HueModule,\n    SaturationModule,\n  ],\n})\nexport class ColorChromeModule {}\n"]}

package/esm2022/circle/circle-swatch.component.mjs

@@ -0,0 +1,69 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-color";
+class CircleSwatchComponent {
+    color;
+    circleSize = 28;
+    circleSpacing = 14;
+    focus = false;
+    onClick = new EventEmitter();
+    onSwatchHover = new EventEmitter();
+    focusStyle = {};
+    swatchStyle = {
+        borderRadius: '50%',
+        background: 'transparent',
+        transition: '100ms box-shadow ease 0s',
+    };
+    ngOnChanges() {
+        this.swatchStyle.boxShadow = `inset 0 0 0 ${this.circleSize / 2}px ${this.color}`;
+        this.focusStyle.boxShadow = `inset 0 0 0 ${this.circleSize / 2}px ${this.color}, 0 0 5px ${this.color}`;
+        if (this.focus) {
+            this.focusStyle.boxShadow = `inset 0 0 0 3px ${this.color}, 0 0 5px ${this.color}`;
+        }
+    }
+    handleClick({ hex, $event }) {
+        this.onClick.emit({ hex, $event });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: CircleSwatchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.1", type: CircleSwatchComponent, selector: "color-circle-swatch", inputs: { color: "color", circleSize: "circleSize", circleSpacing: "circleSpacing", focus: "focus" }, outputs: { onClick: "onClick", onSwatchHover: "onSwatchHover" }, usesOnChanges: true, ngImport: i0, template: `
+  <div class="circle-swatch"
+    [style.width.px]="circleSize" [style.height.px]="circleSize"
+    [style.margin-right.px]="circleSpacing" [style.margin-bottom.px]="circleSpacing"
+    >
+    <color-swatch
+      [color]="color" [style]="swatchStyle" [focus]="focus" [focusStyle]="focusStyle"
+      (onClick)="handleClick($event)" (onHover)="onSwatchHover.emit($event)">
+    </color-swatch>
+    <div class="clear"></div>
+  </div>
+  `, isInline: true, styles: [".circle-swatch{transform:scale(1);transition:transform .1s ease}.circle-swatch:hover{transform:scale(1.2)}\n"], dependencies: [{ kind: "component", type: i1.SwatchComponent, selector: "color-swatch", inputs: ["color", "style", "focusStyle", "focus"], outputs: ["onClick", "onHover"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+export { CircleSwatchComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: CircleSwatchComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'color-circle-swatch', template: `
+  <div class="circle-swatch"
+    [style.width.px]="circleSize" [style.height.px]="circleSize"
+    [style.margin-right.px]="circleSpacing" [style.margin-bottom.px]="circleSpacing"
+    >
+    <color-swatch
+      [color]="color" [style]="swatchStyle" [focus]="focus" [focusStyle]="focusStyle"
+      (onClick)="handleClick($event)" (onHover)="onSwatchHover.emit($event)">
+    </color-swatch>
+    <div class="clear"></div>
+  </div>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, preserveWhitespaces: false, styles: [".circle-swatch{transform:scale(1);transition:transform .1s ease}.circle-swatch:hover{transform:scale(1.2)}\n"] }]
+        }], propDecorators: { color: [{
+                type: Input
+            }], circleSize: [{
+                type: Input
+            }], circleSpacing: [{
+                type: Input
+            }], focus: [{
+                type: Input
+            }], onClick: [{
+                type: Output
+            }], onSwatchHover: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/circle/circle.component.mjs

@@ -0,0 +1,136 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, forwardRef, Input, NgModule } from '@angular/core';
+import { amber, blue, blueGrey, brown, cyan, deepOrange, deepPurple, green, indigo, lightBlue, lightGreen, lime, orange, pink, purple, red, teal, yellow, } from 'material-colors';
+import { TinyColor } from '@ctrl/tinycolor';
+import { ColorWrap, isValidHex, SwatchModule } from 'ngx-color';
+import { CircleSwatchComponent } from './circle-swatch.component';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+class CircleComponent extends ColorWrap {
+    /** Pixel value for picker width */
+    width = 252;
+    /** Color squares to display */
+    colors = [
+        red['500'],
+        pink['500'],
+        purple['500'],
+        deepPurple['500'],
+        indigo['500'],
+        blue['500'],
+        lightBlue['500'],
+        cyan['500'],
+        teal['500'],
+        green['500'],
+        lightGreen['500'],
+        lime['500'],
+        yellow['500'],
+        amber['500'],
+        orange['500'],
+        deepOrange['500'],
+        brown['500'],
+        blueGrey['500'],
+    ];
+    /** Value for circle size */
+    circleSize = 28;
+    /** Value for spacing between circles */
+    circleSpacing = 14;
+    constructor() {
+        super();
+    }
+    isActive(color) {
+        return new TinyColor(this.hex).equals(color);
+    }
+    handleBlockChange({ hex, $event }) {
+        if (isValidHex(hex)) {
+            this.handleChange({ hex, source: 'hex' }, $event);
+        }
+    }
+    handleValueChange({ data, $event }) {
+        this.handleChange(data, $event);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: CircleComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.1", type: CircleComponent, selector: "color-circle", inputs: { width: "width", colors: "colors", circleSize: "circleSize", circleSpacing: "circleSpacing" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => CircleComponent),
+                multi: true,
+            },
+            {
+                provide: ColorWrap,
+                useExisting: forwardRef(() => CircleComponent),
+            },
+        ], usesInheritance: true, ngImport: i0, template: `
+    <div
+      class="circle-picker {{ className }}"
+      [style.width.px]="width"
+      [style.margin-right.px]="-circleSpacing"
+      [style.margin-bottom.px]="-circleSpacing"
+    >
+      <color-circle-swatch
+        *ngFor="let color of colors"
+        [circleSize]="circleSize"
+        [circleSpacing]="circleSpacing"
+        [color]="color"
+        [focus]="isActive(color)"
+        (onClick)="handleBlockChange($event)"
+        (onSwatchHover)="onSwatchHover.emit($event)"
+      ></color-circle-swatch>
+    </div>
+  `, isInline: true, styles: [".circle-picker{display:flex;flex-wrap:wrap}\n"], dependencies: [{ kind: "directive", type: i0.forwardRef(function () { return i1.NgForOf; }), selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i0.forwardRef(function () { return CircleSwatchComponent; }), selector: "color-circle-swatch", inputs: ["color", "circleSize", "circleSpacing", "focus"], outputs: ["onClick", "onSwatchHover"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+export { CircleComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: CircleComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'color-circle', template: `
+    <div
+      class="circle-picker {{ className }}"
+      [style.width.px]="width"
+      [style.margin-right.px]="-circleSpacing"
+      [style.margin-bottom.px]="-circleSpacing"
+    >
+      <color-circle-swatch
+        *ngFor="let color of colors"
+        [circleSize]="circleSize"
+        [circleSpacing]="circleSpacing"
+        [color]="color"
+        [focus]="isActive(color)"
+        (onClick)="handleBlockChange($event)"
+        (onSwatchHover)="onSwatchHover.emit($event)"
+      ></color-circle-swatch>
+    </div>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, preserveWhitespaces: false, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => CircleComponent),
+                            multi: true,
+                        },
+                        {
+                            provide: ColorWrap,
+                            useExisting: forwardRef(() => CircleComponent),
+                        },
+                    ], styles: [".circle-picker{display:flex;flex-wrap:wrap}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { width: [{
+                type: Input
+            }], colors: [{
+                type: Input
+            }], circleSize: [{
+                type: Input
+            }], circleSpacing: [{
+                type: Input
+            }] } });
+class ColorCircleModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ColorCircleModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.1", ngImport: i0, type: ColorCircleModule, declarations: [CircleComponent, CircleSwatchComponent], imports: [CommonModule, SwatchModule], exports: [CircleComponent, CircleSwatchComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ColorCircleModule, imports: [CommonModule, SwatchModule] });
+}
+export { ColorCircleModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ColorCircleModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [CircleComponent, CircleSwatchComponent],
+                    exports: [CircleComponent, CircleSwatchComponent],
+                    imports: [CommonModule, SwatchModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/color-wrap.component.mjs

@@ -0,0 +1,173 @@
+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 = {}));
+class ColorWrap {
+    className;
+    /**
+     * Descriptors the return color format if the component is used with two-way binding
+     */
+    mode = ColorMode.HEX;
+    color = {
+        h: 250,
+        s: 0.5,
+        l: 0.2,
+        a: 1,
+    };
+    colorChange = new EventEmitter();
+    onChange = new EventEmitter();
+    onChangeComplete = new EventEmitter();
+    onSwatchHover = new EventEmitter();
+    oldHue;
+    hsl;
+    hsv;
+    rgb;
+    hex;
+    source;
+    currentColor;
+    changes;
+    disableAlpha;
+    _onChangeCompleteSubscription = new Subscription();
+    _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;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ColorWrap, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.1", 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 });
+}
+export { ColorWrap };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", 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
+            }] } });
+class ColorWrapModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ColorWrapModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.1", ngImport: i0, type: ColorWrapModule, declarations: [ColorWrap], imports: [CommonModule], exports: [ColorWrap] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ColorWrapModule, imports: [CommonModule] });
+}
+export { ColorWrapModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", 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/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"]}