ngx-color 7.2.0 → 7.3.0

package/sketch/esm2020/sketch-fields.component.mjs

@@ -0,0 +1,243 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { isValidHex } from 'ngx-color';
+import { TinyColor } from '@ctrl/tinycolor';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-color";
+import * as i2 from "@angular/common";
+export class SketchFieldsComponent {
+    constructor() {
+        this.disableAlpha = false;
+        this.onChange = new EventEmitter();
+        this.input = {
+            width: '100%',
+            padding: '4px 10% 3px',
+            border: 'none',
+            boxSizing: 'border-box',
+            boxShadow: 'inset 0 0 0 1px #ccc',
+            fontSize: '11px',
+        };
+        this.label = {
+            display: 'block',
+            textAlign: 'center',
+            fontSize: '11px',
+            color: '#222',
+            paddingTop: '3px',
+            paddingBottom: '4px',
+            textTransform: 'capitalize',
+        };
+    }
+    round(value) {
+        return Math.round(value);
+    }
+    handleChange({ data, $event }) {
+        if (data.hex) {
+            if (isValidHex(data.hex)) {
+                const color = new TinyColor(data.hex);
+                this.onChange.emit({
+                    data: {
+                        hex: this.disableAlpha || data.hex.length <= 6 ? color.toHex() : color.toHex8(),
+                        source: 'hex',
+                    },
+                    $event,
+                });
+            }
+        }
+        else if (data.r || data.g || data.b) {
+            this.onChange.emit({
+                data: {
+                    r: data.r || this.rgb.r,
+                    g: data.g || this.rgb.g,
+                    b: data.b || this.rgb.b,
+                    source: 'rgb',
+                },
+                $event,
+            });
+        }
+        else if (data.a) {
+            if (data.a < 0) {
+                data.a = 0;
+            }
+            else if (data.a > 100) {
+                data.a = 100;
+            }
+            data.a /= 100;
+            if (this.disableAlpha) {
+                data.a = 1;
+            }
+            this.onChange.emit({
+                data: {
+                    h: this.hsl.h,
+                    s: this.hsl.s,
+                    l: this.hsl.l,
+                    a: Math.round(data.a * 100) / 100,
+                    source: 'rgb',
+                },
+                $event,
+            });
+        }
+        else if (data.h || data.s || data.l) {
+            this.onChange.emit({
+                data: {
+                    h: data.h || this.hsl.h,
+                    s: Number((data.s && data.s) || this.hsl.s),
+                    l: Number((data.l && data.l) || this.hsl.l),
+                    source: 'hsl',
+                },
+                $event,
+            });
+        }
+    }
+}
+SketchFieldsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: SketchFieldsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SketchFieldsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: SketchFieldsComponent, selector: "color-sketch-fields", inputs: { hsl: "hsl", rgb: "rgb", hex: "hex", disableAlpha: "disableAlpha" }, outputs: { onChange: "onChange" }, ngImport: i0, template: `
+  <div class="sketch-fields">
+    <div class="sketch-double">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="hex"
+        [value]="hex.replace('#', '')"
+        (onChange)="handleChange($event)"
+      ></color-editable-input>
+    </div>
+    <div class="sketch-single">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="r"
+        [value]="rgb.r"
+        (onChange)="handleChange($event)"
+        [dragLabel]="true"
+        [dragMax]="255"
+      ></color-editable-input>
+    </div>
+    <div class="sketch-single">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="g"
+        [value]="rgb.g"
+        (onChange)="handleChange($event)"
+        [dragLabel]="true"
+        [dragMax]="255"
+      ></color-editable-input>
+    </div>
+    <div class="sketch-single">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="b"
+        [value]="rgb.b"
+        (onChange)="handleChange($event)"
+        [dragLabel]="true"
+        [dragMax]="255"
+      ></color-editable-input>
+    </div>
+    <div class="sketch-alpha" *ngIf="disableAlpha === false">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="a"
+        [value]="round(rgb.a * 100)"
+        (onChange)="handleChange($event)"
+        [dragLabel]="true"
+        [dragMax]="100"
+      ></color-editable-input>
+    </div>
+  </div>
+  `, isInline: true, styles: [".sketch-fields{display:flex;padding-top:4px}.sketch-double{flex:2 1 0%}.sketch-single{flex:1 1 0%;padding-left:6px}.sketch-alpha{flex:1 1 0%;padding-left:6px}:host-context([dir=rtl]) .sketch-single{padding-right:6px;padding-left:0}:host-context([dir=rtl]) .sketch-alpha{padding-right:6px;padding-left:0}\n"], components: [{ type: i1.EditableInputComponent, selector: "color-editable-input", inputs: ["style", "label", "value", "arrowOffset", "dragLabel", "dragMax", "placeholder"], outputs: ["onChange"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: SketchFieldsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'color-sketch-fields',
+                    template: `
+  <div class="sketch-fields">
+    <div class="sketch-double">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="hex"
+        [value]="hex.replace('#', '')"
+        (onChange)="handleChange($event)"
+      ></color-editable-input>
+    </div>
+    <div class="sketch-single">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="r"
+        [value]="rgb.r"
+        (onChange)="handleChange($event)"
+        [dragLabel]="true"
+        [dragMax]="255"
+      ></color-editable-input>
+    </div>
+    <div class="sketch-single">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="g"
+        [value]="rgb.g"
+        (onChange)="handleChange($event)"
+        [dragLabel]="true"
+        [dragMax]="255"
+      ></color-editable-input>
+    </div>
+    <div class="sketch-single">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="b"
+        [value]="rgb.b"
+        (onChange)="handleChange($event)"
+        [dragLabel]="true"
+        [dragMax]="255"
+      ></color-editable-input>
+    </div>
+    <div class="sketch-alpha" *ngIf="disableAlpha === false">
+      <color-editable-input
+        [style]="{ input: input, label: label }"
+        label="a"
+        [value]="round(rgb.a * 100)"
+        (onChange)="handleChange($event)"
+        [dragLabel]="true"
+        [dragMax]="100"
+      ></color-editable-input>
+    </div>
+  </div>
+  `,
+                    styles: [
+                        `
+    .sketch-fields {
+      display: flex;
+      padding-top: 4px;
+    }
+    .sketch-double {
+      -webkit-box-flex: 2;
+      flex: 2 1 0%;
+    }
+    .sketch-single {
+      flex: 1 1 0%;
+      padding-left: 6px;
+    }
+    .sketch-alpha {
+      -webkit-box-flex: 1;
+      flex: 1 1 0%;
+      padding-left: 6px;
+    }
+    :host-context([dir=rtl]) .sketch-single {
+      padding-right: 6px;
+      padding-left: 0;
+    }
+    :host-context([dir=rtl]) .sketch-alpha {
+      padding-right: 6px;
+      padding-left: 0;
+    }
+  `,
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    preserveWhitespaces: false,
+                }]
+        }], propDecorators: { hsl: [{
+                type: Input
+            }], rgb: [{
+                type: Input
+            }], hex: [{
+                type: Input
+            }], disableAlpha: [{
+                type: Input
+            }], onChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sketch-fields.component.js","sourceRoot":"","sources":["../../../../src/lib/components/sketch/sketch-fields.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  Output,\n} from '@angular/core';\n\nimport { isValidHex, HSLA, RGBA } from 'ngx-color';\nimport { TinyColor } from '@ctrl/tinycolor';\n\n@Component({\n  selector: 'color-sketch-fields',\n  template: `\n  <div class=\"sketch-fields\">\n    <div class=\"sketch-double\">\n      <color-editable-input\n        [style]=\"{ input: input, label: label }\"\n        label=\"hex\"\n        [value]=\"hex.replace('#', '')\"\n        (onChange)=\"handleChange($event)\"\n      ></color-editable-input>\n    </div>\n    <div class=\"sketch-single\">\n      <color-editable-input\n        [style]=\"{ input: input, label: label }\"\n        label=\"r\"\n        [value]=\"rgb.r\"\n        (onChange)=\"handleChange($event)\"\n        [dragLabel]=\"true\"\n        [dragMax]=\"255\"\n      ></color-editable-input>\n    </div>\n    <div class=\"sketch-single\">\n      <color-editable-input\n        [style]=\"{ input: input, label: label }\"\n        label=\"g\"\n        [value]=\"rgb.g\"\n        (onChange)=\"handleChange($event)\"\n        [dragLabel]=\"true\"\n        [dragMax]=\"255\"\n      ></color-editable-input>\n    </div>\n    <div class=\"sketch-single\">\n      <color-editable-input\n        [style]=\"{ input: input, label: label }\"\n        label=\"b\"\n        [value]=\"rgb.b\"\n        (onChange)=\"handleChange($event)\"\n        [dragLabel]=\"true\"\n        [dragMax]=\"255\"\n      ></color-editable-input>\n    </div>\n    <div class=\"sketch-alpha\" *ngIf=\"disableAlpha === false\">\n      <color-editable-input\n        [style]=\"{ input: input, label: label }\"\n        label=\"a\"\n        [value]=\"round(rgb.a * 100)\"\n        (onChange)=\"handleChange($event)\"\n        [dragLabel]=\"true\"\n        [dragMax]=\"100\"\n      ></color-editable-input>\n    </div>\n  </div>\n  `,\n  styles: [\n    `\n    .sketch-fields {\n      display: flex;\n      padding-top: 4px;\n    }\n    .sketch-double {\n      -webkit-box-flex: 2;\n      flex: 2 1 0%;\n    }\n    .sketch-single {\n      flex: 1 1 0%;\n      padding-left: 6px;\n    }\n    .sketch-alpha {\n      -webkit-box-flex: 1;\n      flex: 1 1 0%;\n      padding-left: 6px;\n    }\n    :host-context([dir=rtl]) .sketch-single {\n      padding-right: 6px;\n      padding-left: 0;\n    }\n    :host-context([dir=rtl]) .sketch-alpha {\n      padding-right: 6px;\n      padding-left: 0;\n    }\n  `,\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  preserveWhitespaces: false,\n})\nexport class SketchFieldsComponent {\n  @Input() hsl!: HSLA;\n  @Input() rgb!: RGBA;\n  @Input() hex!: string;\n  @Input() disableAlpha = false;\n  @Output() onChange = new EventEmitter<any>();\n  input: {[key: string]: string} = {\n    width: '100%',\n    padding: '4px 10% 3px',\n    border: 'none',\n    boxSizing: 'border-box',\n    boxShadow: 'inset 0 0 0 1px #ccc',\n    fontSize: '11px',\n  };\n  label: {[key: string]: string} = {\n    display: 'block',\n    textAlign: 'center',\n    fontSize: '11px',\n    color: '#222',\n    paddingTop: '3px',\n    paddingBottom: '4px',\n    textTransform: 'capitalize',\n  };\n\n  round(value) {\n    return Math.round(value);\n  }\n  handleChange({ data, $event }) {\n    if (data.hex) {\n      if (isValidHex(data.hex)) {\n        const color = new TinyColor(data.hex);\n        this.onChange.emit({\n          data: {\n            hex: this.disableAlpha || data.hex.length <= 6 ? color.toHex() : color.toHex8(),\n            source: 'hex',\n          },\n          $event,\n        });\n      }\n    } else if (data.r || data.g || data.b) {\n      this.onChange.emit({\n        data: {\n          r: data.r || this.rgb.r,\n          g: data.g || this.rgb.g,\n          b: data.b || this.rgb.b,\n          source: 'rgb',\n        },\n        $event,\n      });\n    } else if (data.a) {\n      if (data.a < 0) {\n        data.a = 0;\n      } else if (data.a > 100) {\n        data.a = 100;\n      }\n      data.a /= 100;\n\n      if (this.disableAlpha) {\n        data.a = 1;\n      }\n\n      this.onChange.emit({\n        data: {\n          h: this.hsl.h,\n          s: this.hsl.s,\n          l: this.hsl.l,\n          a: Math.round(data.a * 100) / 100,\n          source: 'rgb',\n        },\n        $event,\n      });\n    } else if (data.h || data.s || data.l) {\n      this.onChange.emit({\n        data: {\n          h: data.h || this.hsl.h,\n          s: Number((data.s && data.s) || this.hsl.s),\n          l: Number((data.l && data.l) || this.hsl.l),\n          source: 'hsl',\n        },\n        $event,\n      });\n    }\n  }\n}\n"]}

package/sketch/esm2020/sketch-preset-colors.component.mjs

@@ -0,0 +1,98 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-color";
+import * as i2 from "@angular/common";
+export class SketchPresetColorsComponent {
+    constructor() {
+        this.onClick = new EventEmitter();
+        this.onSwatchHover = new EventEmitter();
+        this.swatchStyle = {
+            borderRadius: '3px',
+            boxShadow: 'inset 0 0 0 1px rgba(0,0,0,.15)',
+        };
+    }
+    handleClick({ hex, $event }) {
+        this.onClick.emit({ hex, $event });
+    }
+    normalizeValue(val) {
+        if (typeof val === 'string') {
+            return { color: val };
+        }
+        return val;
+    }
+    focusStyle(val) {
+        const c = this.normalizeValue(val);
+        return {
+            boxShadow: `inset 0 0 0 1px rgba(0,0,0,.15), 0 0 4px ${c.color}`,
+        };
+    }
+}
+SketchPresetColorsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: SketchPresetColorsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SketchPresetColorsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: SketchPresetColorsComponent, selector: "color-sketch-preset-colors", inputs: { colors: "colors" }, outputs: { onClick: "onClick", onSwatchHover: "onSwatchHover" }, ngImport: i0, template: `
+  <div class="sketch-swatches">
+    <div class="sketch-wrap" *ngFor="let c of colors">
+      <color-swatch
+        [color]="normalizeValue(c).color"
+        [style]="swatchStyle"
+        [focusStyle]="focusStyle(c)"
+        (onClick)="handleClick($event)"
+        (onHover)="onSwatchHover.emit($event)"
+        class="swatch"
+      ></color-swatch>
+    </div>
+  </div>
+  `, isInline: true, styles: [".sketch-swatches{position:relative;display:flex;flex-wrap:wrap;margin:0 -10px;padding:10px 0 0 10px;border-top:1px solid rgb(238,238,238)}.sketch-wrap{width:16px;height:16px;margin:0 10px 10px 0}:host-context([dir=rtl]) .sketch-swatches{padding-right:10px;padding-left:0}:host-context([dir=rtl]) .sketch-wrap{margin-left:10px;margin-right:0}\n"], components: [{ type: i1.SwatchComponent, selector: "color-swatch", inputs: ["color", "style", "focusStyle", "focus"], outputs: ["onClick", "onHover"] }], directives: [{ type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: SketchPresetColorsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'color-sketch-preset-colors',
+                    template: `
+  <div class="sketch-swatches">
+    <div class="sketch-wrap" *ngFor="let c of colors">
+      <color-swatch
+        [color]="normalizeValue(c).color"
+        [style]="swatchStyle"
+        [focusStyle]="focusStyle(c)"
+        (onClick)="handleClick($event)"
+        (onHover)="onSwatchHover.emit($event)"
+        class="swatch"
+      ></color-swatch>
+    </div>
+  </div>
+  `,
+                    styles: [
+                        `
+    .sketch-swatches {
+      position: relative;
+      display: flex;
+      flex-wrap: wrap;
+      margin: 0px -10px;
+      padding: 10px 0px 0px 10px;
+      border-top: 1px solid rgb(238, 238, 238);
+    }
+    .sketch-wrap {
+      width: 16px;
+      height: 16px;
+      margin: 0px 10px 10px 0px;
+    }
+    :host-context([dir=rtl]) .sketch-swatches {
+      padding-right: 10px;
+      padding-left: 0;
+    }
+    :host-context([dir=rtl]) .sketch-wrap {
+      margin-left: 10px;
+      margin-right: 0;
+    }
+  `,
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    preserveWhitespaces: false,
+                }]
+        }], propDecorators: { colors: [{
+                type: Input
+            }], onClick: [{
+                type: Output
+            }], onSwatchHover: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/sketch/esm2020/sketch.component.mjs

@@ -0,0 +1,283 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, forwardRef, Input, NgModule } from '@angular/core';
+import { AlphaModule, CheckboardModule, ColorWrap, EditableInputModule, HueModule, isValidHex, SaturationModule, SwatchModule, } from 'ngx-color';
+import { SketchFieldsComponent } from './sketch-fields.component';
+import { SketchPresetColorsComponent } from './sketch-preset-colors.component';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-color";
+import * as i2 from "@angular/common";
+export class SketchComponent extends ColorWrap {
+    constructor() {
+        super();
+        /** Remove alpha slider and options from picker */
+        this.disableAlpha = false;
+        /** Hex strings for default colors at bottom of picker */
+        this.presetColors = [
+            '#D0021B',
+            '#F5A623',
+            '#F8E71C',
+            '#8B572A',
+            '#7ED321',
+            '#417505',
+            '#BD10E0',
+            '#9013FE',
+            '#4A90E2',
+            '#50E3C2',
+            '#B8E986',
+            '#000000',
+            '#4A4A4A',
+            '#9B9B9B',
+            '#FFFFFF',
+        ];
+        /** Width of picker */
+        this.width = 200;
+    }
+    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);
+    }
+    handleBlockChange({ hex, $event }) {
+        if (isValidHex(hex)) {
+            // this.hex = hex;
+            this.handleChange({
+                hex,
+                source: 'hex',
+            }, $event);
+        }
+    }
+}
+SketchComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: SketchComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SketchComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: SketchComponent, selector: "color-sketch", inputs: { disableAlpha: "disableAlpha", presetColors: "presetColors", width: "width" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => SketchComponent),
+            multi: true,
+        },
+        {
+            provide: ColorWrap,
+            useExisting: forwardRef(() => SketchComponent),
+        },
+    ], usesInheritance: true, ngImport: i0, template: `
+  <div class="sketch-picker {{ className }}" [style.width]="width">
+    <div class="sketch-saturation">
+      <color-saturation [hsl]="hsl" [hsv]="hsv"
+        (onChange)="handleValueChange($event)"
+      >
+      </color-saturation>
+    </div>
+    <div class="sketch-controls">
+      <div class="sketch-sliders">
+        <div class="sketch-hue">
+          <color-hue [hsl]="hsl"
+            (onChange)="handleValueChange($event)"
+          ></color-hue>
+        </div>
+        <div class="sketch-alpha" *ngIf="disableAlpha === false">
+          <color-alpha
+            [radius]="2" [rgb]="rgb" [hsl]="hsl"
+            (onChange)="handleValueChange($event)"
+          ></color-alpha>
+        </div>
+      </div>
+      <div class="sketch-color">
+        <color-checkboard></color-checkboard>
+        <div class="sketch-active" [style.background]="activeBackground"></div>
+      </div>
+    </div>
+    <div class="sketch-fields-container">
+      <color-sketch-fields
+        [rgb]="rgb" [hsl]="hsl" [hex]="hex"
+        [disableAlpha]="disableAlpha"
+        (onChange)="handleValueChange($event)"
+      ></color-sketch-fields>
+    </div>
+    <div class="sketch-swatches-container" *ngIf="presetColors && presetColors.length">
+      <color-sketch-preset-colors
+        [colors]="presetColors"
+        (onClick)="handleBlockChange($event)"
+        (onSwatchHover)="onSwatchHover.emit($event)"
+      ></color-sketch-preset-colors>
+    </div>
+  </div>
+  `, isInline: true, styles: [".sketch-picker{padding:10px 10px 3px;box-sizing:initial;background:#fff;border-radius:4px;box-shadow:0 0 0 1px #00000026,0 8px 16px #00000026}.sketch-saturation{width:100%;padding-bottom:75%;position:relative;overflow:hidden}.sketch-fields-container{display:block}.sketch-swatches-container{display:block}.sketch-controls{display:flex}.sketch-sliders{padding:4px 0;flex:1 1 0%}.sketch-hue{position:relative;height:10px;overflow:hidden}.sketch-alpha{position:relative;height:10px;margin-top:4px;overflow:hidden}.sketch-color{width:24px;height:24px;position:relative;margin-top:4px;margin-left:4px;border-radius:3px}.sketch-active{position:absolute;top:0px;right:0px;bottom:0px;left:0px;border-radius:2px;box-shadow:#00000026 0 0 0 1px inset,#00000040 0 0 4px inset}:host-context([dir=rtl]) .sketch-color{margin-right:4px;margin-left:0}\n"], components: [{ type: i0.forwardRef(function () { return i1.SaturationComponent; }), selector: "color-saturation", inputs: ["hsl", "hsv", "radius", "pointer", "circle"], outputs: ["onChange"] }, { type: i0.forwardRef(function () { return i1.HueComponent; }), selector: "color-hue", inputs: ["hsl", "pointer", "radius", "shadow", "hidePointer", "direction"], outputs: ["onChange"] }, { type: i0.forwardRef(function () { return i1.AlphaComponent; }), selector: "color-alpha", inputs: ["hsl", "rgb", "pointer", "shadow", "radius", "direction"], outputs: ["onChange"] }, { type: i0.forwardRef(function () { return i1.CheckboardComponent; }), selector: "color-checkboard", inputs: ["white", "size", "grey", "boxShadow", "borderRadius"] }, { type: i0.forwardRef(function () { return SketchFieldsComponent; }), selector: "color-sketch-fields", inputs: ["hsl", "rgb", "hex", "disableAlpha"], outputs: ["onChange"] }, { type: i0.forwardRef(function () { return SketchPresetColorsComponent; }), selector: "color-sketch-preset-colors", inputs: ["colors"], outputs: ["onClick", "onSwatchHover"] }], directives: [{ type: i0.forwardRef(function () { return i2.NgIf; }), selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: SketchComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'color-sketch',
+                    template: `
+  <div class="sketch-picker {{ className }}" [style.width]="width">
+    <div class="sketch-saturation">
+      <color-saturation [hsl]="hsl" [hsv]="hsv"
+        (onChange)="handleValueChange($event)"
+      >
+      </color-saturation>
+    </div>
+    <div class="sketch-controls">
+      <div class="sketch-sliders">
+        <div class="sketch-hue">
+          <color-hue [hsl]="hsl"
+            (onChange)="handleValueChange($event)"
+          ></color-hue>
+        </div>
+        <div class="sketch-alpha" *ngIf="disableAlpha === false">
+          <color-alpha
+            [radius]="2" [rgb]="rgb" [hsl]="hsl"
+            (onChange)="handleValueChange($event)"
+          ></color-alpha>
+        </div>
+      </div>
+      <div class="sketch-color">
+        <color-checkboard></color-checkboard>
+        <div class="sketch-active" [style.background]="activeBackground"></div>
+      </div>
+    </div>
+    <div class="sketch-fields-container">
+      <color-sketch-fields
+        [rgb]="rgb" [hsl]="hsl" [hex]="hex"
+        [disableAlpha]="disableAlpha"
+        (onChange)="handleValueChange($event)"
+      ></color-sketch-fields>
+    </div>
+    <div class="sketch-swatches-container" *ngIf="presetColors && presetColors.length">
+      <color-sketch-preset-colors
+        [colors]="presetColors"
+        (onClick)="handleBlockChange($event)"
+        (onSwatchHover)="onSwatchHover.emit($event)"
+      ></color-sketch-preset-colors>
+    </div>
+  </div>
+  `,
+                    styles: [
+                        `
+    .sketch-picker {
+      padding: 10px 10px 3px;
+      box-sizing: initial;
+      background: #fff;
+      border-radius: 4px;
+      box-shadow: 0 0 0 1px rgba(0,0,0,.15), 0 8px 16px rgba(0,0,0,.15);
+    }
+    .sketch-saturation {
+      width: 100%;
+      padding-bottom: 75%;
+      position: relative;
+      overflow: hidden;
+    }
+    .sketch-fields-container {
+      display: block;
+    }
+    .sketch-swatches-container {
+      display: block;
+    }
+    .sketch-controls {
+      display: flex;
+    }
+    .sketch-sliders {
+      padding: 4px 0px;
+      -webkit-box-flex: 1;
+      flex: 1 1 0%;
+    }
+    .sketch-hue {
+      position: relative;
+      height: 10px;
+      overflow: hidden;
+    }
+    .sketch-alpha {
+      position: relative;
+      height: 10px;
+      margin-top: 4px;
+      overflow: hidden;
+    }
+    .sketch-color {
+      width: 24px;
+      height: 24px;
+      position: relative;
+      margin-top: 4px;
+      margin-left: 4px;
+      border-radius: 3px;
+    }
+    .sketch-active {
+      position: absolute;
+      top: 0px;
+      right: 0px;
+      bottom: 0px;
+      left: 0px;
+      border-radius: 2px;
+      box-shadow: rgba(0, 0, 0, 0.15) 0px 0px 0px 1px inset, rgba(0, 0, 0, 0.25) 0px 0px 4px inset;
+    }
+    :host-context([dir=rtl]) .sketch-color {
+      margin-right: 4px;
+      margin-left: 0;
+    }
+  `,
+                    ],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    preserveWhitespaces: false,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => SketchComponent),
+                            multi: true,
+                        },
+                        {
+                            provide: ColorWrap,
+                            useExisting: forwardRef(() => SketchComponent),
+                        },
+                    ]
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { disableAlpha: [{
+                type: Input
+            }], presetColors: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }] } });
+export class ColorSketchModule {
+}
+ColorSketchModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorSketchModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ColorSketchModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorSketchModule, declarations: [SketchComponent, SketchFieldsComponent,
+        SketchPresetColorsComponent], imports: [CommonModule,
+        AlphaModule,
+        CheckboardModule,
+        EditableInputModule,
+        HueModule,
+        SaturationModule,
+        SwatchModule], exports: [SketchComponent, SketchFieldsComponent,
+        SketchPresetColorsComponent] });
+ColorSketchModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorSketchModule, imports: [[
+            CommonModule,
+            AlphaModule,
+            CheckboardModule,
+            EditableInputModule,
+            HueModule,
+            SaturationModule,
+            SwatchModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ColorSketchModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SketchComponent,
+                        SketchFieldsComponent,
+                        SketchPresetColorsComponent,
+                    ],
+                    exports: [
+                        SketchComponent,
+                        SketchFieldsComponent,
+                        SketchPresetColorsComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        AlphaModule,
+                        CheckboardModule,
+                        EditableInputModule,
+                        HueModule,
+                        SaturationModule,
+                        SwatchModule,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sketch.component.js","sourceRoot":"","sources":["../../../../src/lib/components/sketch/sketch.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 {\n  AlphaModule,\n  CheckboardModule,\n  ColorWrap,\n  EditableInputModule,\n  HueModule,\n  isValidHex,\n  SaturationModule,\n  SwatchModule,\n} from 'ngx-color';\nimport { SketchFieldsComponent } from './sketch-fields.component';\nimport { SketchPresetColorsComponent } from './sketch-preset-colors.component';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\n\n@Component({\n  selector: 'color-sketch',\n  template: `\n  <div class=\"sketch-picker {{ className }}\" [style.width]=\"width\">\n    <div class=\"sketch-saturation\">\n      <color-saturation [hsl]=\"hsl\" [hsv]=\"hsv\"\n        (onChange)=\"handleValueChange($event)\"\n      >\n      </color-saturation>\n    </div>\n    <div class=\"sketch-controls\">\n      <div class=\"sketch-sliders\">\n        <div class=\"sketch-hue\">\n          <color-hue [hsl]=\"hsl\"\n            (onChange)=\"handleValueChange($event)\"\n          ></color-hue>\n        </div>\n        <div class=\"sketch-alpha\" *ngIf=\"disableAlpha === false\">\n          <color-alpha\n            [radius]=\"2\" [rgb]=\"rgb\" [hsl]=\"hsl\"\n            (onChange)=\"handleValueChange($event)\"\n          ></color-alpha>\n        </div>\n      </div>\n      <div class=\"sketch-color\">\n        <color-checkboard></color-checkboard>\n        <div class=\"sketch-active\" [style.background]=\"activeBackground\"></div>\n      </div>\n    </div>\n    <div class=\"sketch-fields-container\">\n      <color-sketch-fields\n        [rgb]=\"rgb\" [hsl]=\"hsl\" [hex]=\"hex\"\n        [disableAlpha]=\"disableAlpha\"\n        (onChange)=\"handleValueChange($event)\"\n      ></color-sketch-fields>\n    </div>\n    <div class=\"sketch-swatches-container\" *ngIf=\"presetColors && presetColors.length\">\n      <color-sketch-preset-colors\n        [colors]=\"presetColors\"\n        (onClick)=\"handleBlockChange($event)\"\n        (onSwatchHover)=\"onSwatchHover.emit($event)\"\n      ></color-sketch-preset-colors>\n    </div>\n  </div>\n  `,\n  styles: [\n    `\n    .sketch-picker {\n      padding: 10px 10px 3px;\n      box-sizing: initial;\n      background: #fff;\n      border-radius: 4px;\n      box-shadow: 0 0 0 1px rgba(0,0,0,.15), 0 8px 16px rgba(0,0,0,.15);\n    }\n    .sketch-saturation {\n      width: 100%;\n      padding-bottom: 75%;\n      position: relative;\n      overflow: hidden;\n    }\n    .sketch-fields-container {\n      display: block;\n    }\n    .sketch-swatches-container {\n      display: block;\n    }\n    .sketch-controls {\n      display: flex;\n    }\n    .sketch-sliders {\n      padding: 4px 0px;\n      -webkit-box-flex: 1;\n      flex: 1 1 0%;\n    }\n    .sketch-hue {\n      position: relative;\n      height: 10px;\n      overflow: hidden;\n    }\n    .sketch-alpha {\n      position: relative;\n      height: 10px;\n      margin-top: 4px;\n      overflow: hidden;\n    }\n    .sketch-color {\n      width: 24px;\n      height: 24px;\n      position: relative;\n      margin-top: 4px;\n      margin-left: 4px;\n      border-radius: 3px;\n    }\n    .sketch-active {\n      position: absolute;\n      top: 0px;\n      right: 0px;\n      bottom: 0px;\n      left: 0px;\n      border-radius: 2px;\n      box-shadow: rgba(0, 0, 0, 0.15) 0px 0px 0px 1px inset, rgba(0, 0, 0, 0.25) 0px 0px 4px inset;\n    }\n    :host-context([dir=rtl]) .sketch-color {\n      margin-right: 4px;\n      margin-left: 0;\n    }\n  `,\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  preserveWhitespaces: false,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => SketchComponent),\n      multi: true,\n    },\n    {\n      provide: ColorWrap,\n      useExisting: forwardRef(() => SketchComponent),\n    },\n  ]\n})\nexport class SketchComponent extends ColorWrap {\n  /** Remove alpha slider and options from picker */\n  @Input() disableAlpha = false;\n  /** Hex strings for default colors at bottom of picker */\n  @Input() presetColors = [\n    '#D0021B',\n    '#F5A623',\n    '#F8E71C',\n    '#8B572A',\n    '#7ED321',\n    '#417505',\n    '#BD10E0',\n    '#9013FE',\n    '#4A90E2',\n    '#50E3C2',\n    '#B8E986',\n    '#000000',\n    '#4A4A4A',\n    '#9B9B9B',\n    '#FFFFFF',\n  ];\n  /** Width of picker */\n  @Input() width = 200;\n  activeBackground!: string;\n  constructor() {\n    super();\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  handleBlockChange({ hex, $event }) {\n    if (isValidHex(hex)) {\n      // this.hex = hex;\n      this.handleChange(\n        {\n          hex,\n          source: 'hex',\n        },\n        $event,\n      );\n    }\n  }\n}\n\n@NgModule({\n  declarations: [\n    SketchComponent,\n    SketchFieldsComponent,\n    SketchPresetColorsComponent,\n  ],\n  exports: [\n    SketchComponent,\n    SketchFieldsComponent,\n    SketchPresetColorsComponent,\n  ],\n  imports: [\n    CommonModule,\n    AlphaModule,\n    CheckboardModule,\n    EditableInputModule,\n    HueModule,\n    SaturationModule,\n    SwatchModule,\n  ],\n})\nexport class ColorSketchModule {}\n"]}