@mintplayer/ng-bootstrap 16.6.0 → 16.7.0

package/esm2022/color-picker/components/color-wheel/color-wheel.component.mjs

@@ -0,0 +1,321 @@
+import { Component, ElementRef, EventEmitter, HostBinding, HostListener, Input, Output, ViewChild } from '@angular/core';
+import { BehaviorSubject, combineLatest, debounceTime, map, take, switchMap } from 'rxjs';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class BsColorWheelComponent {
+    constructor(element) {
+        // this.resizeObserver = new ResizeObserver((entries) => {
+        //   for (const entry of entries) {
+        //     if (entry.target === this.element.nativeElement) {
+        //       console.log(entry.contentRect);
+        //       this.width$.next(entry.contentRect.width);
+        //       this.height$.next(entry.contentRect.height);
+        //       break;
+        //     }
+        //   }
+        // });
+        this.element = element;
+        this.positionRelative = true;
+        //#region Hue/Luminosity
+        this.hs$ = new BehaviorSubject({ hue: 0, saturation: 0 });
+        this.hsChange = new EventEmitter();
+        //#endregion
+        //#region Luminosity
+        this.luminosity$ = new BehaviorSubject(0);
+        //#endregion
+        // private resizeObserver: ResizeObserver;
+        this.canvasContext = null;
+        this.isPointerDown = false;
+        this.width$ = new BehaviorSubject(150);
+        this.height$ = new BehaviorSubject(150);
+        this.diameterRatio$ = new BehaviorSubject(0);
+        this.disabled$ = new BehaviorSubject(false);
+        this.viewInited$ = new BehaviorSubject(false);
+        this.squareSize$ = combineLatest([this.width$, this.height$])
+            .pipe(map(([width, height]) => {
+            if ((width === null) || (height === null)) {
+                return null;
+            }
+            const squareSize = Math.min(width, height);
+            return squareSize;
+        }));
+        this.shiftX$ = combineLatest([this.width$, this.height$])
+            .pipe(map(([width, height]) => {
+            if ((width === null) || (height === null)) {
+                return null;
+            }
+            else if (width < height) {
+                return 0;
+            }
+            else {
+                return (width - height) / 2;
+            }
+        }));
+        this.shiftY$ = combineLatest([this.width$, this.height$])
+            .pipe(map(([width, height]) => {
+            if ((width === null) || (height === null)) {
+                return null;
+            }
+            else if (width < height) {
+                return (height - width) / 2;
+            }
+            else {
+                return 0;
+            }
+        }));
+        this.innerRadius$ = combineLatest([this.squareSize$, this.diameterRatio$])
+            .pipe(map(([squareSize, diameterRatio]) => {
+            if (squareSize) {
+                return squareSize / 2 * diameterRatio;
+            }
+            else {
+                return 0;
+            }
+        }));
+        this.outerRadius$ = combineLatest([this.squareSize$, this.diameterRatio$])
+            .pipe(map(([squareSize, diameterRatio]) => {
+            if (squareSize) {
+                return squareSize / 2;
+            }
+            else {
+                return 150;
+            }
+        }));
+        combineLatest([this.innerRadius$, this.outerRadius$, this.shiftX$, this.shiftY$])
+            .pipe(debounceTime(20), takeUntilDestroyed())
+            .subscribe(([innerRadius, outerRadius, shiftX, shiftY]) => {
+            if (this.canvasContext && (innerRadius !== null) && (outerRadius !== null) && (shiftX !== null) && (shiftY !== null)) {
+                this.canvasContext.clearRect(0, 0, this.canvas.nativeElement.width, this.canvas.nativeElement.height);
+                this.canvasContext.save();
+                this.canvasContext.translate(shiftX + outerRadius, shiftY + outerRadius);
+                for (let x = 0; x < 360; x++) {
+                    this.canvasContext.rotate(1 * Math.PI / 180);
+                    const gradient = this.canvasContext.createLinearGradient(innerRadius, 0, outerRadius, 0);
+                    gradient.addColorStop(0, `hsl(${x}, 0%, 50%)`);
+                    gradient.addColorStop(1, `hsl(${x}, 100%, 50%)`);
+                    this.canvasContext.fillStyle = gradient;
+                    this.canvasContext.fillRect(innerRadius, 0, outerRadius - innerRadius, outerRadius / 50);
+                }
+                this.canvasContext.restore();
+            }
+        });
+        this.markerPosition$ = combineLatest([this.hs$, this.shiftX$, this.shiftY$])
+            .pipe(switchMap(([hs, shiftX, shiftY]) => {
+            return this.color2position(hs)
+                .pipe(map((position) => ({ position, shiftX: (shiftX ?? 0), shiftY: (shiftY ?? 0) })));
+        }))
+            .pipe(map(({ position, shiftX, shiftY }) => {
+            return {
+                x: position.x + shiftX,
+                y: position.y + shiftY,
+            };
+        }));
+        this.hs$.pipe(takeUntilDestroyed())
+            .subscribe((hs) => this.hsChange.emit(hs));
+    }
+    set diameterRatio(value) {
+        this.diameterRatio$.next(value);
+    }
+    set width(value) {
+        this.width$.next(value);
+    }
+    set height(value) {
+        this.height$.next(value);
+    }
+    get hs() {
+        return this.hs$.value;
+    }
+    set hs(value) {
+        this.hs$.next(value);
+    }
+    get luminosity() {
+        return this.luminosity$.value;
+    }
+    set luminosity(value) {
+        this.luminosity$.next(value);
+    }
+    ngAfterViewInit() {
+        // this.resizeObserver.observe(this.element.nativeElement);
+        this.viewInited$.next(true);
+        this.canvasContext = this.canvas.nativeElement.getContext('2d', { willReadFrequently: true });
+    }
+    onPointerDown(ev) {
+        if (!this.disabled$.value) {
+            ev.preventDefault();
+            this.isPointerDown = true;
+            this.updateColor(ev, !('touches' in ev));
+        }
+    }
+    onPointerMove(ev) {
+        if (this.isPointerDown) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            this.updateColor(ev, !('touches' in ev));
+        }
+    }
+    onMouseMove(ev) {
+        this.onPointerMove(ev);
+    }
+    onPointerUp(ev) {
+        this.isPointerDown = false;
+    }
+    updateColor(ev, subtract) {
+        let co;
+        const rect = this.canvas.nativeElement.getBoundingClientRect();
+        if ('touches' in ev) {
+            co = {
+                x: ev.touches[0].clientX - rect.left,
+                y: ev.touches[0].clientY - rect.top,
+            };
+        }
+        else {
+            co = {
+                x: ev.clientX - (subtract ? rect.left : 0),
+                y: ev.clientY - (subtract ? rect.top : 0),
+            };
+        }
+        this.position2color(co.x, co.y).pipe(take(1)).subscribe((color) => {
+            if (color) {
+                this.hs$.next({ hue: color.hue, saturation: color.saturation });
+            }
+            else {
+                console.warn('Color is null');
+            }
+        });
+    }
+    isInsideCircle(x, y) {
+        return combineLatest([this.squareSize$, this.shiftX$, this.shiftY$])
+            .pipe(map(([squareSize, shiftX, shiftY]) => {
+            // Position to the square
+            const sx = x - (shiftX ?? 0);
+            const sy = y - (shiftY ?? 0);
+            // Square radius
+            const sr = (squareSize ?? 0) / 2;
+            const radius = Math.sqrt(Math.pow(sx - sr, 2) + Math.pow(sy - sr, 2));
+            const angle = (Math.atan2(sr - sy, sr - sx) + Math.PI) % 360;
+            return {
+                inside: radius <= sr,
+                angle
+            };
+        }));
+    }
+    position2color(x, y) {
+        return this.isInsideCircle(x, y).pipe(map((result) => {
+            if (!this.canvasContext) {
+                return null;
+            }
+            if (result.inside) {
+                const imageData = this.canvasContext.getImageData(x, y, 1, 1).data;
+                const hsl = this.rgb2Hsl({ r: imageData[0], g: imageData[1], b: imageData[2] });
+                return hsl;
+            }
+            return { hue: result.angle * 180 / Math.PI, saturation: 1, luminosity: 0.5 };
+        }));
+    }
+    color2position(hs) {
+        return combineLatest([this.innerRadius$, this.outerRadius$])
+            .pipe(map(([innerRadius, outerRadius]) => {
+            if (innerRadius === null) {
+                innerRadius = 0;
+            }
+            if (!outerRadius) {
+                outerRadius = 100;
+            }
+            const theta = hs.hue * Math.PI / 180;
+            const c = {
+                x: -outerRadius * Math.cos(theta),
+                y: -outerRadius * Math.sin(theta)
+            };
+            const d = hs.saturation * (outerRadius - innerRadius) + innerRadius;
+            const o = { x: outerRadius, y: outerRadius };
+            return {
+                x: o.x - d * (c.x / outerRadius),
+                y: o.y - d * (c.y / outerRadius),
+            };
+        }));
+    }
+    rgb2Hsl(color) {
+        const r01 = this.bound01(color.r, 255);
+        const g01 = this.bound01(color.g, 255);
+        const b01 = this.bound01(color.b, 255);
+        const max = Math.max(r01, g01, b01);
+        const min = Math.min(r01, g01, b01);
+        let h, s;
+        const l = (max + min) / 2;
+        if (max === min) {
+            h = s = 0;
+        }
+        else {
+            const d = max - min;
+            s = (l > 0.5) ? (d / (2 - max - min)) : (d / (max + min));
+            switch (max) {
+                case r01:
+                    {
+                        h = (g01 - b01) / d + ((g01 < b01) ? 6 : 0);
+                    }
+                    break;
+                case g01:
+                    {
+                        h = (b01 - r01) / d + 2;
+                    }
+                    break;
+                case b01:
+                    {
+                        h = (r01 - g01) / d + 4;
+                    }
+                    break;
+                default: {
+                    throw 'Invalid operation';
+                }
+            }
+            h /= 6;
+        }
+        h *= 360;
+        return { hue: h, saturation: s, luminosity: l };
+    }
+    /**
+     * Divide 1 to n, handling floating point errors.
+     * Ensures that the value is in between 0 and 1.
+     **/
+    bound01(n, max) {
+        n = Math.min(max, Math.max(0, n));
+        if ((Math.abs(n - max) < 0.000001)) {
+            return 1;
+        }
+        else {
+            return (n % max) / max;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsColorWheelComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.2", type: BsColorWheelComponent, selector: "bs-color-wheel", inputs: { diameterRatio: "diameterRatio", width: "width", height: "height", hs: "hs", luminosity: "luminosity" }, outputs: { hsChange: "hsChange" }, host: { listeners: { "document:mousemove": "onMouseMove($event)", "document:mouseup": "onPointerUp($event)" }, properties: { "class.position-relative": "this.positionRelative" } }, viewQueries: [{ propertyName: "canvas", first: true, predicate: ["canvas"], descendants: true }], ngImport: i0, template: "<canvas\n    class=\"d-block\"\n    [width]=\"width$ | async\"\n    [height]=\"height$ | async\"\n    (mousedown)=\"onPointerDown($event)\"\n    (touchstart)=\"onPointerDown($event)\"\n    (touchmove)=\"onPointerMove($event)\"\n    (touchend)=\"onPointerUp($event)\"\n    #canvas></canvas>\n\n<ng-container *ngIf=\"(markerPosition$ | async) as markerPosition\">\n    <div class=\"thumb position-absolute pe-none\" [style.left.px]=\"markerPosition.x\" [style.top.px]=\"markerPosition.y\"></div>\n</ng-container>", styles: [".thumb{width:30px;height:30px;border-radius:15px;margin-top:-15px;margin-left:-15px;box-sizing:border-box;border:2px solid white;box-shadow:#0000001a 0 0 10px 5px}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsColorWheelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bs-color-wheel', template: "<canvas\n    class=\"d-block\"\n    [width]=\"width$ | async\"\n    [height]=\"height$ | async\"\n    (mousedown)=\"onPointerDown($event)\"\n    (touchstart)=\"onPointerDown($event)\"\n    (touchmove)=\"onPointerMove($event)\"\n    (touchend)=\"onPointerUp($event)\"\n    #canvas></canvas>\n\n<ng-container *ngIf=\"(markerPosition$ | async) as markerPosition\">\n    <div class=\"thumb position-absolute pe-none\" [style.left.px]=\"markerPosition.x\" [style.top.px]=\"markerPosition.y\"></div>\n</ng-container>", styles: [".thumb{width:30px;height:30px;border-radius:15px;margin-top:-15px;margin-left:-15px;box-sizing:border-box;border:2px solid white;box-shadow:#0000001a 0 0 10px 5px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { positionRelative: [{
+                type: HostBinding,
+                args: ['class.position-relative']
+            }], diameterRatio: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], canvas: [{
+                type: ViewChild,
+                args: ['canvas']
+            }], hsChange: [{
+                type: Output
+            }], hs: [{
+                type: Input
+            }], luminosity: [{
+                type: Input
+            }], onMouseMove: [{
+                type: HostListener,
+                args: ['document:mousemove', ['$event']]
+            }], onPointerUp: [{
+                type: HostListener,
+                args: ['document:mouseup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"color-wheel.component.js","sourceRoot":"","sources":["../../../../../../../libs/mintplayer-ng-bootstrap/color-picker/components/color-wheel/color-wheel.component.ts","../../../../../../../libs/mintplayer-ng-bootstrap/color-picker/components/color-wheel/color-wheel.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, ElementRef, EventEmitter, HostBinding, HostListener, Input, Output, ViewChild } from '@angular/core';\nimport { BehaviorSubject, combineLatest, debounceTime, map, take, Observable, switchMap } from 'rxjs';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { HS } from '../../interfaces/hs';\nimport { HslColor } from '../../interfaces/hsl-color';\nimport { RgbColor } from '../../interfaces/rgb-color';\n\n@Component({\n  selector: 'bs-color-wheel',\n  templateUrl: './color-wheel.component.html',\n  styleUrls: ['./color-wheel.component.scss']\n})\nexport class BsColorWheelComponent implements AfterViewInit {\n\n  constructor(private element: ElementRef<HTMLElement>) {\n    // this.resizeObserver = new ResizeObserver((entries) => {\n    //   for (const entry of entries) {\n    //     if (entry.target === this.element.nativeElement) {\n    //       console.log(entry.contentRect);\n    //       this.width$.next(entry.contentRect.width);\n    //       this.height$.next(entry.contentRect.height);\n    //       break;\n    //     }\n    //   }\n    // });\n\n    this.squareSize$ = combineLatest([this.width$, this.height$])\n      .pipe(map(([width, height]) => {\n        if ((width === null) || (height === null)) {\n          return null;\n        }\n\n        const squareSize = Math.min(width, height);\n        return squareSize;\n      }));\n\n    this.shiftX$ = combineLatest([this.width$, this.height$])\n      .pipe(map(([width, height]) => {\n        if ((width === null) || (height === null)) {\n          return null;\n        } else if (width < height) {\n          return 0;\n        } else {\n          return (width - height) / 2;\n        }\n      }));\n\n    this.shiftY$ = combineLatest([this.width$, this.height$])\n      .pipe(map(([width, height]) => {\n        if ((width === null) || (height === null)) {\n          return null;\n        } else if (width < height) {\n          return (height - width) / 2;\n        } else {\n          return 0;\n        }\n      }));\n\n    this.innerRadius$ = combineLatest([this.squareSize$, this.diameterRatio$])\n      .pipe(map(([squareSize, diameterRatio]) => {\n        if (squareSize) {\n          return squareSize / 2 * diameterRatio;\n        } else {\n          return 0;\n        }\n      }));\n\n    this.outerRadius$ = combineLatest([this.squareSize$, this.diameterRatio$])\n      .pipe(map(([squareSize, diameterRatio]) => {\n        if (squareSize) {\n          return squareSize / 2;\n        } else {\n          return 150;\n        }\n      }));\n  \n    combineLatest([this.innerRadius$, this.outerRadius$, this.shiftX$, this.shiftY$])\n      .pipe(debounceTime(20), takeUntilDestroyed())\n      .subscribe(([innerRadius, outerRadius, shiftX, shiftY]) => {\n        if (this.canvasContext && (innerRadius !== null) && (outerRadius !== null) && (shiftX !== null) && (shiftY !== null)) {\n          this.canvasContext.clearRect(0, 0, this.canvas.nativeElement.width, this.canvas.nativeElement.height);\n          this.canvasContext.save();\n          this.canvasContext.translate(shiftX + outerRadius, shiftY + outerRadius);\n\n          for (let x = 0; x < 360; x++) {\n            this.canvasContext.rotate(1 * Math.PI / 180);\n            const gradient = this.canvasContext.createLinearGradient(innerRadius, 0, outerRadius, 0);\n\n            gradient.addColorStop(0, `hsl(${x}, 0%, 50%)`);\n            gradient.addColorStop(1, `hsl(${x}, 100%, 50%)`);\n\n            this.canvasContext.fillStyle = gradient;\n            this.canvasContext.fillRect(innerRadius, 0, outerRadius - innerRadius, outerRadius / 50);\n          }\n\n          this.canvasContext.restore();\n        }\n      });\n\n    this.markerPosition$ = combineLatest([this.hs$, this.shiftX$, this.shiftY$])\n      .pipe(switchMap(([hs, shiftX, shiftY]) => {\n        return this.color2position(hs)\n          .pipe(map((position) => ({position, shiftX: (shiftX ?? 0), shiftY: (shiftY ?? 0)})));\n      }))\n      .pipe(map(({position, shiftX, shiftY}) => {\n        return {\n          x: position.x + shiftX,\n          y: position.y + shiftY,\n        };\n      }));\n\n    this.hs$.pipe(takeUntilDestroyed())\n      .subscribe((hs) => this.hsChange.emit(hs));\n  }\n\n  @HostBinding('class.position-relative') positionRelative = true;\n  \n  @Input() set diameterRatio(value: number) {\n    this.diameterRatio$.next(value);\n  }\n  @Input() set width(value: number) {\n    this.width$.next(value);\n  }\n  @Input() set height(value: number) {\n    this.height$.next(value);\n  }\n  @ViewChild('canvas') canvas!: ElementRef<HTMLCanvasElement>;\n  \n  //#region Hue/Luminosity\n  hs$ = new BehaviorSubject<HS>({ hue: 0, saturation: 0 });\n  @Output() hsChange = new EventEmitter<HS>();\n  public get hs() {\n    return this.hs$.value;\n  }\n  @Input() public set hs(value: HS) {\n    this.hs$.next(value);\n  }\n  //#endregion\n  //#region Luminosity\n  luminosity$ = new BehaviorSubject<number>(0);\n  public get luminosity() {\n    return this.luminosity$.value;\n  }\n  @Input() public set luminosity(value: number) {\n    this.luminosity$.next(value);\n  }\n  //#endregion\n\n  // private resizeObserver: ResizeObserver;\n  private canvasContext: CanvasRenderingContext2D | null = null;\n  private isPointerDown = false;\n  width$ = new BehaviorSubject<number>(150);\n  height$ = new BehaviorSubject<number>(150);\n  diameterRatio$ = new BehaviorSubject<number>(0);\n\n  squareSize$: Observable<number | null>;\n  shiftX$: Observable<number | null>;\n  shiftY$: Observable<number | null>;\n\n  innerRadius$: Observable<number | null>;\n  outerRadius$: Observable<number | null>;\n  markerPosition$: Observable<{x: number, y: number}>;\n  disabled$ = new BehaviorSubject<boolean>(false);\n  \n  viewInited$ = new BehaviorSubject<boolean>(false);\n\n  ngAfterViewInit() {\n    // this.resizeObserver.observe(this.element.nativeElement);\n    this.viewInited$.next(true);\n    this.canvasContext = this.canvas.nativeElement.getContext('2d', { willReadFrequently: true });\n  }\n\n  onPointerDown(ev: MouseEvent | TouchEvent) {\n    if (!this.disabled$.value) {\n      ev.preventDefault();\n      this.isPointerDown = true;\n      this.updateColor(ev, !('touches' in ev));\n    }\n  }\n\n  onPointerMove(ev: MouseEvent | TouchEvent) {\n    if (this.isPointerDown) {\n      ev.preventDefault();\n      ev.stopPropagation();\n      this.updateColor(ev, !('touches' in ev));\n    }\n  }\n\n  @HostListener('document:mousemove', ['$event'])\n  onMouseMove(ev: MouseEvent) {\n    this.onPointerMove(ev);\n  }\n\n  @HostListener('document:mouseup', ['$event'])\n  onPointerUp(ev: MouseEvent | TouchEvent) {\n    this.isPointerDown = false;\n  }\n\n  private updateColor(ev: MouseEvent | TouchEvent, subtract: boolean) {\n    let co: { x: number, y: number };\n    const rect = this.canvas.nativeElement.getBoundingClientRect();\n    if ('touches' in ev) {\n      co = {\n        x: ev.touches[0].clientX - rect.left,\n        y: ev.touches[0].clientY - rect.top,\n      };\n    } else {\n      co = {\n        x: ev.clientX - (subtract ? rect.left : 0),\n        y: ev.clientY - (subtract ? rect.top : 0),\n      };\n    }\n    \n    this.position2color(co.x, co.y).pipe(take(1)).subscribe((color) => {\n      if (color) {\n        this.hs$.next({ hue: color.hue, saturation: color.saturation });\n      } else {\n        console.warn('Color is null');\n      }\n    });\n  }\n\n  private isInsideCircle(x: number, y: number) {\n    return combineLatest([this.squareSize$, this.shiftX$, this.shiftY$])\n      .pipe(map(([squareSize, shiftX, shiftY]) => {\n        // Position to the square\n        const sx: number = x - (shiftX ?? 0);\n        const sy = y - (shiftY ?? 0);\n        // Square radius\n        const sr = (squareSize ?? 0) / 2;\n\n        const radius = Math.sqrt(Math.pow(sx - sr, 2) + Math.pow(sy - sr, 2));\n        const angle = (Math.atan2(sr - sy, sr - sx) + Math.PI) % 360;\n        return {\n          inside: radius <= sr,\n          angle\n        };\n      }));\n  }\n\n  private position2color(x: number, y: number) {\n    return this.isInsideCircle(x, y).pipe(map((result) => {\n      if (!this.canvasContext) {\n        return null;\n      }\n\n      if (result.inside) {\n        const imageData = this.canvasContext.getImageData(x, y, 1, 1).data;\n        const hsl = this.rgb2Hsl({ r: imageData[0], g: imageData[1], b: imageData[2] });\n        return hsl;\n      }\n\n      return <HslColor>{ hue: result.angle * 180 / Math.PI, saturation: 1, luminosity: 0.5 };\n    }));\n  }\n\n  private color2position(hs: HS) {\n    return combineLatest([this.innerRadius$, this.outerRadius$])\n      .pipe(map(([innerRadius, outerRadius]) => {\n        if (innerRadius === null) {\n          innerRadius = 0;\n        }\n        if (!outerRadius) {\n          outerRadius = 100;\n        }\n\n        const theta = hs.hue * Math.PI / 180;\n        const c = {\n          x: -outerRadius * Math.cos(theta),\n          y: -outerRadius * Math.sin(theta)\n        };\n    \n        const d = hs.saturation * (outerRadius - innerRadius) + innerRadius;\n        const o = { x: outerRadius, y: outerRadius };\n    \n        return {\n          x: o.x - d * (c.x / outerRadius),\n          y: o.y - d * (c.y / outerRadius),\n        }\n      }));\n  }\n  \n  private rgb2Hsl(color: RgbColor) {\n    const r01 = this.bound01(color.r, 255);\n    const g01 = this.bound01(color.g, 255);\n    const b01 = this.bound01(color.b, 255);\n\n    const max = Math.max(r01, g01, b01);\n    const min = Math.min(r01, g01, b01);\n\n    let h: number, s: number; const l = (max + min) / 2;\n    if (max === min) {\n        h = s = 0;\n    } else {\n        const d = max - min;\n        s = (l > 0.5) ? (d / (2 - max - min)) : (d / (max + min));\n        switch (max) {\n            case r01: {\n                h = (g01 - b01) / d + ((g01 < b01) ? 6 : 0);\n            } break;\n            case g01: {\n                h = (b01 - r01) / d + 2;\n            } break;\n            case b01: {\n                h = (r01 - g01) / d + 4;\n            } break;\n            default: {\n                throw 'Invalid operation';\n            }\n        }\n        \n        h /= 6;\n    }\n    \n    h *= 360;\n\n    return <HslColor>{ hue: h, saturation: s, luminosity: l };\n  }\n\n  /**\n   * Divide 1 to n, handling floating point errors.\n   * Ensures that the value is in between 0 and 1.\n   **/\n  private bound01(n: number, max: number) {\n      n = Math.min(max, Math.max(0, n));\n      if ((Math.abs(n - max) < 0.000001)) {\n          return 1;\n      } else {\n          return (n % max) / max;\n      }\n  }\n\n}\n","<canvas\n    class=\"d-block\"\n    [width]=\"width$ | async\"\n    [height]=\"height$ | async\"\n    (mousedown)=\"onPointerDown($event)\"\n    (touchstart)=\"onPointerDown($event)\"\n    (touchmove)=\"onPointerMove($event)\"\n    (touchend)=\"onPointerUp($event)\"\n    #canvas></canvas>\n\n<ng-container *ngIf=\"(markerPosition$ | async) as markerPosition\">\n    <div class=\"thumb position-absolute pe-none\" [style.left.px]=\"markerPosition.x\" [style.top.px]=\"markerPosition.y\"></div>\n</ng-container>"]}

package/esm2022/color-picker/components/index.mjs

@@ -0,0 +1,6 @@
+export * from './alpha-strip/alpha-strip.component';
+export * from './color-picker/color-picker.component';
+export * from './color-wheel/color-wheel.component';
+export * from './luminosity-strip/luminosity-strip.component';
+export * from './slider/slider.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL21pbnRwbGF5ZXItbmctYm9vdHN0cmFwL2NvbG9yLXBpY2tlci9jb21wb25lbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsK0NBQStDLENBQUM7QUFDOUQsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWxwaGEtc3RyaXAvYWxwaGEtc3RyaXAuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vY29sb3ItcGlja2VyL2NvbG9yLXBpY2tlci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9jb2xvci13aGVlbC9jb2xvci13aGVlbC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9sdW1pbm9zaXR5LXN0cmlwL2x1bWlub3NpdHktc3RyaXAuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vc2xpZGVyL3NsaWRlci5jb21wb25lbnQnOyJdfQ==

package/esm2022/color-picker/components/luminosity-strip/luminosity-strip.component.mjs

@@ -0,0 +1,72 @@
+import { Component, EventEmitter, Input, Output, ViewChild, ElementRef } from '@angular/core';
+import { BehaviorSubject, combineLatest, map } from 'rxjs';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+import * as i1 from "../slider/slider.component";
+import * as i2 from "@angular/common";
+export class BsLuminosityStripComponent {
+    constructor() {
+        //#region HS
+        this.hs$ = new BehaviorSubject({ hue: 0, saturation: 0 });
+        //#endregion
+        //#region Luminosity
+        this.luminosity$ = new BehaviorSubject(0.5);
+        this.luminosityChange = new EventEmitter();
+        //#endregion
+        this.canvasContext = null;
+        this.hs$.pipe(takeUntilDestroyed()).subscribe((hs) => {
+            if (this.canvasContext) {
+                const width = this.canvas.nativeElement.width, height = this.canvas.nativeElement.height;
+                this.canvasContext.clearRect(0, 0, width, height);
+                this.canvasContext.save();
+                // HSL
+                // - H: 0 - 359
+                // - S: "0%" - "100%"
+                // - L: "0%" - "50%" - "100%"
+                const gradient = this.canvasContext.createLinearGradient(0, 0, width, 0);
+                gradient.addColorStop(0, `hsl(${hs.hue}, ${hs.saturation * 100}%, 0%)`);
+                gradient.addColorStop(0.5, `hsl(${hs.hue}, ${hs.saturation * 100}%, 50%)`);
+                gradient.addColorStop(1, `hsl(${hs.hue}, ${hs.saturation * 100}%, 100%)`);
+                this.canvasContext.fillStyle = gradient;
+                this.canvasContext.fillRect(0, 0, width, height);
+            }
+        });
+        this.resultBackground$ = combineLatest([this.hs$, this.luminosity$])
+            .pipe(map(([hs, luminosity]) => {
+            return `hsl(${hs.hue}, ${hs.saturation * 100}%, ${luminosity * 100}%)`;
+        }));
+        this.luminosity$.pipe(takeUntilDestroyed())
+            .subscribe(luminosity => this.luminosityChange.emit(luminosity));
+    }
+    get hs() {
+        return this.hs$.value;
+    }
+    set hs(value) {
+        this.hs$.next(value);
+    }
+    get luminosity() {
+        return this.luminosity$.value;
+    }
+    set luminosity(value) {
+        this.luminosity$.next(value);
+    }
+    ngAfterViewInit() {
+        this.canvasContext = this.canvas.nativeElement.getContext('2d', { willReadFrequently: true });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsLuminosityStripComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.2", type: BsLuminosityStripComponent, selector: "bs-luminosity-strip", inputs: { hs: "hs", luminosity: "luminosity" }, outputs: { luminosityChange: "luminosityChange" }, viewQueries: [{ propertyName: "canvas", first: true, predicate: ["canvas"], descendants: true }], ngImport: i0, template: "<bs-slider [value]=\"(luminosity$ | async)!\" (valueChange)=\"luminosityChange.emit($event)\">\n    <canvas bsTrack class=\"position-absolute w-100\" #canvas></canvas>\n    <div bsThumb [style.background]=\"resultBackground$ | async\"></div>\n</bs-slider>", styles: [""], dependencies: [{ kind: "component", type: i1.BsSliderComponent, selector: "bs-slider", inputs: ["value"], outputs: ["valueChange"] }, { kind: "directive", type: i1.BsThumbDirective, selector: "[bsThumb]" }, { kind: "directive", type: i1.BsTrackDirective, selector: "[bsTrack]" }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsLuminosityStripComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bs-luminosity-strip', template: "<bs-slider [value]=\"(luminosity$ | async)!\" (valueChange)=\"luminosityChange.emit($event)\">\n    <canvas bsTrack class=\"position-absolute w-100\" #canvas></canvas>\n    <div bsThumb [style.background]=\"resultBackground$ | async\"></div>\n</bs-slider>" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { hs: [{
+                type: Input
+            }], luminosityChange: [{
+                type: Output
+            }], luminosity: [{
+                type: Input
+            }], canvas: [{
+                type: ViewChild,
+                args: ['canvas']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/color-picker/components/slider/slider.component.mjs

@@ -0,0 +1,125 @@
+import { Component, Directive, ElementRef, EventEmitter, HostBinding, HostListener, Input, Output, ViewChild, NgZone } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { BehaviorSubject, map } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class BsSliderComponent {
+    constructor(element, zone) {
+        this.element = element;
+        this.zone = zone;
+        this.dBlock = true;
+        this.positionRelative = true;
+        //#region Value
+        this.value$ = new BehaviorSubject(0.5);
+        this.valueChange = new EventEmitter();
+        //#endregion
+        this.isPointerDown$ = new BehaviorSubject(false);
+        this.value$.pipe(takeUntilDestroyed())
+            .subscribe((value) => this.valueChange.emit(value));
+        this.thumbMarginLeft$ = this.value$.pipe(map((value) => {
+            const res = value * element.nativeElement.clientWidth - 12;
+            return res;
+        }));
+        this.cursorClass$ = this.isPointerDown$.pipe(map((isPointerDown) => {
+            return isPointerDown ? 'cursor-grabbing' : 'cursor-grab';
+        }));
+    }
+    get value() {
+        return this.value$.value;
+    }
+    set value(value) {
+        this.value$.next(value);
+    }
+    onPointerDown(ev) {
+        ev.preventDefault();
+        this.zone.run(() => this.isPointerDown$.next(true));
+        this.updateColor(ev);
+    }
+    onPointerMove(ev) {
+        if (this.isPointerDown$.value) {
+            ev.preventDefault();
+            ev.stopPropagation();
+            this.updateColor(ev);
+        }
+    }
+    onPointerUp(ev) {
+        this.isPointerDown$.next(false);
+    }
+    updateColor(ev) {
+        let co;
+        const rect = this.track.nativeElement.getBoundingClientRect();
+        if ('touches' in ev) {
+            co = {
+                x: ev.touches[0].clientX - rect.left,
+            };
+        }
+        else {
+            co = {
+                x: ev.clientX - rect.left,
+            };
+        }
+        const percent = co.x / this.track.nativeElement.clientWidth;
+        const limited = Math.max(0, Math.min(1, percent));
+        this.value$.next(limited);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsSliderComponent, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.2", type: BsSliderComponent, selector: "bs-slider", inputs: { value: "value" }, outputs: { valueChange: "valueChange" }, host: { listeners: { "document:mousemove": "onPointerMove($event)", "document:mouseup": "onPointerUp($event)" }, properties: { "class.d-block": "this.dBlock", "class.position-relative": "this.positionRelative" } }, viewQueries: [{ propertyName: "track", first: true, predicate: ["track"], descendants: true }, { propertyName: "thumb", first: true, predicate: ["thumb"], descendants: true }], ngImport: i0, template: "<div class=\"wrapper d-block position-relative\">\n    <div #track class=\"track2\"\n        (mousedown)=\"onPointerDown($event)\"\n        (touchstart)=\"onPointerDown($event)\"\n        (touchmove)=\"onPointerMove($event)\"\n        (touchend)=\"onPointerUp($event)\">\n        <ng-content select=\"[bsTrack]\"></ng-content>\n    </div>\n    <div #thumb\n        (mousedown)=\"onPointerDown($event)\"\n        (touchstart)=\"onPointerDown($event)\"\n        (touchmove)=\"onPointerMove($event)\"\n        (touchend)=\"onPointerUp($event)\"\n        [class]=\"cursorClass$ | async\"\n        [style.margin-left.px]=\"thumbMarginLeft$ | async\">\n        <ng-content select=\"[bsThumb]\"></ng-content>\n    </div>\n</div>", styles: [".track2{height:8px}.wrapper{padding-top:8px;padding-bottom:8px}::ng-deep .thumb{width:24px;height:24px;top:0;border-radius:50%;box-shadow:0 0 0 .1rem #646b7240}::ng-deep .track{height:8px;border-radius:8px}\n"], dependencies: [{ kind: "pipe", type: i1.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsSliderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bs-slider', template: "<div class=\"wrapper d-block position-relative\">\n    <div #track class=\"track2\"\n        (mousedown)=\"onPointerDown($event)\"\n        (touchstart)=\"onPointerDown($event)\"\n        (touchmove)=\"onPointerMove($event)\"\n        (touchend)=\"onPointerUp($event)\">\n        <ng-content select=\"[bsTrack]\"></ng-content>\n    </div>\n    <div #thumb\n        (mousedown)=\"onPointerDown($event)\"\n        (touchstart)=\"onPointerDown($event)\"\n        (touchmove)=\"onPointerMove($event)\"\n        (touchend)=\"onPointerUp($event)\"\n        [class]=\"cursorClass$ | async\"\n        [style.margin-left.px]=\"thumbMarginLeft$ | async\">\n        <ng-content select=\"[bsThumb]\"></ng-content>\n    </div>\n</div>", styles: [".track2{height:8px}.wrapper{padding-top:8px;padding-bottom:8px}::ng-deep .thumb{width:24px;height:24px;top:0;border-radius:50%;box-shadow:0 0 0 .1rem #646b7240}::ng-deep .track{height:8px;border-radius:8px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { dBlock: [{
+                type: HostBinding,
+                args: ['class.d-block']
+            }], positionRelative: [{
+                type: HostBinding,
+                args: ['class.position-relative']
+            }], track: [{
+                type: ViewChild,
+                args: ['track']
+            }], thumb: [{
+                type: ViewChild,
+                args: ['thumb']
+            }], valueChange: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }], onPointerMove: [{
+                type: HostListener,
+                args: ['document:mousemove', ['$event']]
+            }], onPointerUp: [{
+                type: HostListener,
+                args: ['document:mouseup', ['$event']]
+            }] } });
+export class BsThumbDirective {
+    constructor() {
+        this.thumbClass = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsThumbDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.2", type: BsThumbDirective, selector: "[bsThumb]", host: { properties: { "class.thumb": "this.thumbClass", "class.position-absolute": "this.thumbClass" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsThumbDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[bsThumb]' }]
+        }], propDecorators: { thumbClass: [{
+                type: HostBinding,
+                args: ['class.thumb']
+            }, {
+                type: HostBinding,
+                args: ['class.position-absolute']
+            }] } });
+export class BsTrackDirective {
+    constructor() {
+        this.trackClass = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsTrackDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.2", type: BsTrackDirective, selector: "[bsTrack]", host: { properties: { "class.track": "this.trackClass" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.2", ngImport: i0, type: BsTrackDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[bsTrack]' }]
+        }], propDecorators: { trackClass: [{
+                type: HostBinding,
+                args: ['class.track']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider.component.js","sourceRoot":"","sources":["../../../../../../../libs/mintplayer-ng-bootstrap/color-picker/components/slider/slider.component.ts","../../../../../../../libs/mintplayer-ng-bootstrap/color-picker/components/slider/slider.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Directive, ElementRef, EventEmitter, HostBinding, HostListener, Input, Output, ViewChild, NgZone } from '@angular/core';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { BehaviorSubject, map, Observable } from 'rxjs';\n\n@Component({\n  selector: 'bs-slider',\n  templateUrl: './slider.component.html',\n  styleUrls: ['./slider.component.scss']\n})\nexport class BsSliderComponent {\n  constructor(private element: ElementRef<HTMLElement>, private zone: NgZone) {\n    this.value$.pipe(takeUntilDestroyed())\n      .subscribe((value) => this.valueChange.emit(value));\n\n    this.thumbMarginLeft$ = this.value$.pipe(map((value) => {\n      const res = value * element.nativeElement.clientWidth - 12;\n      return res;\n    }));\n\n    this.cursorClass$ = this.isPointerDown$.pipe(map((isPointerDown) => {\n      return isPointerDown ? 'cursor-grabbing' : 'cursor-grab';\n    }));\n  }\n\n  @HostBinding('class.d-block') dBlock = true;\n  @HostBinding('class.position-relative') positionRelative = true;\n  thumbMarginLeft$: Observable<number>;\n  @ViewChild('track') track!: ElementRef<HTMLDivElement>;\n  @ViewChild('thumb') thumb!: ElementRef<HTMLDivElement>;\n\n  //#region Value\n  value$ = new BehaviorSubject<number>(0.5);\n  @Output() valueChange = new EventEmitter<number>();\n  public get value() {\n    return this.value$.value;\n  }\n  @Input() public set value(value: number) {\n    this.value$.next(value);\n  }\n  //#endregion\n\n  private isPointerDown$ = new BehaviorSubject<boolean>(false);\n  cursorClass$: Observable<string>;\n\n  onPointerDown(ev: MouseEvent | TouchEvent) {\n    ev.preventDefault();\n    this.zone.run(() => this.isPointerDown$.next(true));\n    this.updateColor(ev);\n  }\n\n  @HostListener('document:mousemove', ['$event'])\n  onPointerMove(ev: MouseEvent | TouchEvent) {\n    if (this.isPointerDown$.value) {\n      ev.preventDefault();\n      ev.stopPropagation();\n      this.updateColor(ev);\n    }\n  }\n\n  @HostListener('document:mouseup', ['$event'])\n  onPointerUp(ev: MouseEvent | TouchEvent) {\n    this.isPointerDown$.next(false);\n  }\n\n  private updateColor(ev: MouseEvent | TouchEvent) {\n    let co: { x: number };\n    const rect = this.track.nativeElement.getBoundingClientRect();\n    if ('touches' in ev) {\n      co = {\n        x: ev.touches[0].clientX - rect.left,\n      };\n    } else {\n      co = {\n        x: ev.clientX - rect.left,\n      };\n    }\n    \n    const percent = co.x / this.track.nativeElement.clientWidth;\n    const limited = Math.max(0, Math.min(1, percent));\n    this.value$.next(limited);\n  }\n}\n\n@Directive({ selector: '[bsThumb]' })\nexport class BsThumbDirective {\n  @HostBinding('class.thumb')\n  @HostBinding('class.position-absolute')\n  thumbClass = true;\n}\n\n@Directive({ selector: '[bsTrack]' })\nexport class BsTrackDirective {\n  @HostBinding('class.track') trackClass = true;\n}","<div class=\"wrapper d-block position-relative\">\n    <div #track class=\"track2\"\n        (mousedown)=\"onPointerDown($event)\"\n        (touchstart)=\"onPointerDown($event)\"\n        (touchmove)=\"onPointerMove($event)\"\n        (touchend)=\"onPointerUp($event)\">\n        <ng-content select=\"[bsTrack]\"></ng-content>\n    </div>\n    <div #thumb\n        (mousedown)=\"onPointerDown($event)\"\n        (touchstart)=\"onPointerDown($event)\"\n        (touchmove)=\"onPointerMove($event)\"\n        (touchend)=\"onPointerUp($event)\"\n        [class]=\"cursorClass$ | async\"\n        [style.margin-left.px]=\"thumbMarginLeft$ | async\">\n        <ng-content select=\"[bsThumb]\"></ng-content>\n    </div>\n</div>"]}