@fbltd/math 1.0.40 → 1.0.41

package/dist/bin/src/colors/blend.js

@@ -0,0 +1,23 @@
+import { Color } from "./color.js";
+/**
+ * Смешение цветов
+ */
+export function blend(background, ...foregrounds) {
+    let temp;
+    let red, green, blue;
+    for (let foreground of foregrounds) {
+        const fgAlpha = foreground.alpha;
+        const bgAlpha = background.alpha;
+        let alpha = 1 - (1 - fgAlpha) * (1 - bgAlpha);
+        if (alpha <= 0) {
+            background = new Color(0, 0, 0, 0);
+            continue;
+        }
+        temp = bgAlpha * (1 - fgAlpha) / alpha;
+        red = Math.floor(foreground.red * fgAlpha / alpha + background.red * temp);
+        green = Math.floor(foreground.green * fgAlpha / alpha + background.green * temp);
+        blue = Math.floor(foreground.blue * fgAlpha / alpha + background.blue * temp);
+        background = new Color(red, green, blue, alpha);
+    }
+    return background;
+}

package/dist/bin/src/colors/color.js

@@ -5,7 +5,7 @@ export class Color {
     _green;
     _blue;
     _alpha;
-    constructor(_red, _green, _blue, _alpha = 255) {
+    constructor(_red, _green, _blue, _alpha = 1) {
         this._red = _red;
         this._green = _green;
         this._blue = _blue;

package/dist/bin/src/colors/constants.js

@@ -0,0 +1,6 @@
+import { Color } from "./color.js";
+export const COLORS = {
+    WHITE: new Color(255, 255, 255, 1),
+    BLACK: new Color(0, 0, 0, 1),
+    TRANSPARENT: new Color(0, 0, 0, 0),
+};

package/dist/bin/src/colors/{conic.gradient.js → gradient/base.gradient.js}

@@ -1,87 +1,69 @@
-import { Color } from "./color.js";
-export class ConicGradient {
+import { Color } from "../color.js";
+import { denormalizeShade } from "../utils.js";
+export class BaseGradient {
     colors;
     constructor(...colors) {
-        this.colors = [...colors].sort((a, b) => a.angle - b.angle);
+        this.colors = [...colors].sort((a, b) => a.percentage - b.percentage);
         this.colors.push({
-            angle: 1,
+            percentage: 1,
             color: this.colors[0].color
         });
     }
     /**
      * Получить цвет по углу от оси X по часовой стрелке
-     * @param angle единица измерения угла должна быть той же самой, что и углы всех передаваемых в констурктор цветов
+     * @param percentage единица измерения угла должна быть той же самой, что и углы всех передаваемых в констурктор цветов
      */
-    getColorAtAngle(angle) {
+    getColorAtPercentage(percentage) {
         let prev = undefined;
         let next = undefined;
         for (let entry of this.colors) {
-            if (entry.angle === angle)
+            if (entry.percentage === percentage)
                 return entry.color;
-            if (entry.angle < angle)
+            if (entry.percentage < percentage)
                 prev = entry;
-            if (entry.angle > angle) {
+            if (entry.percentage > percentage) {
                 next = entry;
                 break;
             }
         }
         if (!prev || !next)
             return undefined;
-        const coef = (angle - prev.angle) / (next.angle - prev.angle);
-        return new Color(Math.floor((next.color.red - prev.color.red) * coef + prev.color.red), Math.floor((next.color.green - prev.color.green) * coef + prev.color.green), Math.floor((next.color.blue - prev.color.blue) * coef + prev.color.blue));
+        const coef = (percentage - prev.percentage) / (next.percentage - prev.percentage);
+        return new Color(Math.floor((next.color.red - prev.color.red) * coef + prev.color.red), Math.floor((next.color.green - prev.color.green) * coef + prev.color.green), Math.floor((next.color.blue - prev.color.blue) * coef + prev.color.blue), (next.color.alpha - prev.color.alpha) * coef + prev.color.alpha);
     }
-    getAngleByColor(color) {
+    getPercentageByColor(color) {
         let prev;
         let next = this.colors[0];
         if (color.isEqual(next.color))
-            return next.angle;
+            return next.percentage;
         for (let i = 1; i < this.colors.length; i++) {
             next = this.colors[i];
             prev = this.colors[i - 1];
             if (color.isEqual(next.color))
-                return next.angle;
+                return next.percentage;
             let redDif = next.color.red - prev.color.red;
             let greenDif = next.color.green - prev.color.green;
             let blueDif = next.color.blue - prev.color.blue;
+            let alphaDif = denormalizeShade(next.color.alpha) - denormalizeShade(prev.color.alpha);
             let redDifColor = color.red - prev.color.red;
             let greenDifColor = color.green - prev.color.green;
             let blueDifColor = color.blue - prev.color.blue;
+            let alphaDifColor = denormalizeShade(color.alpha) - denormalizeShade(prev.color.alpha);
             if (((redDifColor >= 0 && redDifColor <= redDif) || (redDifColor <= 0 && redDifColor >= redDif)) &&
                 ((greenDifColor >= 0 && greenDifColor <= greenDif) || (greenDifColor <= 0 && greenDifColor >= greenDif)) &&
-                ((blueDifColor >= 0 && blueDifColor <= blueDif) || (blueDifColor <= 0 && blueDifColor >= blueDif))) {
+                ((blueDifColor >= 0 && blueDifColor <= blueDif) || (blueDifColor <= 0 && blueDifColor >= blueDif)) &&
+                ((alphaDifColor >= 0 && alphaDifColor <= alphaDif) || (alphaDifColor <= 0 && alphaDifColor >= alphaDif))) {
                 const redCoef = ((color.red - prev.color.red) / (next.color.red - prev.color.red));
                 const greenCoef = ((color.green - prev.color.green) / (next.color.green - prev.color.green));
                 const blueCoef = ((color.blue - prev.color.blue) / (next.color.blue - prev.color.blue));
-                const coefs = [redCoef, greenCoef, blueCoef].filter(Boolean);
-                return (next.angle - prev.angle) * Math.min(...coefs) + prev.angle;
+                const alphaCoef = ((color.alpha - prev.color.alpha) / (next.color.alpha - prev.color.alpha));
+                const coefs = [redCoef, greenCoef, blueCoef, alphaCoef].filter(Boolean);
+                return (next.percentage - prev.percentage) * Math.min(...coefs) + prev.percentage;
             }
         }
         return undefined;
     }
     isColorInRange(color) {
-        return Boolean(this.getAngleByColor(color));
-    }
-    /**
-     * Для использования метода, углы  должны быть в Turn единицах измерения
-     */
-    toCanvas(ctx, center) {
-        const gradient = ctx.createConicGradient(0, ...center);
-        for (let color of this.colors) {
-            gradient.addColorStop(color.angle, color.color.toString());
-        }
-        return gradient;
-    }
-    /**
-     * Для использования метода, углы  должны быть в Turn единицах измерения
-     */
-    toCSS() {
-        let s = '';
-        for (let color of this.colors) {
-            if (s)
-                s += ',';
-            s += `rgb(${color.color.red},${color.color.green},${color.color.blue})`;
-        }
-        s = `conic-gradient(in srgb from 0.25turn at 50% 50%, ${s})`;
-        return s;
+        return Boolean(this.getPercentageByColor(color));
     }
 }

package/dist/bin/src/colors/gradient/conic.gradient.js

@@ -0,0 +1,26 @@
+import { BaseGradient } from "./base.gradient.js";
+export class ConicGradient extends BaseGradient {
+    /**
+     * Для использования метода, углы  должны быть в Turn единицах измерения
+     */
+    toCanvas(ctx, center) {
+        const gradient = ctx.createConicGradient(0, ...center);
+        for (let color of this.colors) {
+            gradient.addColorStop(color.percentage, color.color.toString());
+        }
+        return gradient;
+    }
+    /**
+     * Для использования метода, углы  должны быть в Turn единицах измерения
+     */
+    toCSS() {
+        let s = '';
+        for (let color of this.colors) {
+            if (s)
+                s += ',';
+            s += `rgb(${color.color.red},${color.color.green},${color.color.blue})`;
+        }
+        s = `conic-gradient(in srgb from 0.25turn at 50% 50%, ${s})`;
+        return s;
+    }
+}

package/dist/bin/src/colors/gradient/index.js

@@ -0,0 +1,2 @@
+export * from "./conic.gradient.js";
+export * from "./linear.gradient.js";

package/dist/bin/src/colors/gradient/linear.gradient.js

@@ -0,0 +1,19 @@
+import { BaseGradient } from "./base.gradient.js";
+export class LinearGradient extends BaseGradient {
+    toCanvas(ctx, p1, p2) {
+        const gradient = ctx.createLinearGradient(...p1, ...p2);
+        for (let color of this.colors) {
+            gradient.addColorStop(color.percentage, color.color.toString());
+        }
+        return gradient;
+    }
+    toCSS(direction = 'to bottom') {
+        let s = '';
+        for (let color of this.colors) {
+            if (s)
+                s += ',';
+            s += `rgb(${color.color.red},${color.color.green},${color.color.blue})`;
+        }
+        return `conic-gradient(${direction}, ${s})`;
+    }
+}

package/dist/bin/src/colors/index.js

@@ -1,2 +1,5 @@
 export * from "./color.js";
-export * from "./conic.gradient.js";
+export * from "./gradient/conic.gradient.js";
+export * from "./blend.js";
+export * from "./utils.js";
+export * from "./constants.js";

package/dist/types/src/colors/blend.d.ts

@@ -0,0 +1,5 @@
+import { Color } from "./color.ts";
+/**
+ * Смешение цветов
+ */
+export declare function blend(background: Color, ...foregrounds: Color[]): Color;

package/dist/types/src/colors/constants.d.ts

@@ -0,0 +1,6 @@
+import { Color } from "./color.ts";
+export declare const COLORS: {
+    WHITE: Color;
+    BLACK: Color;
+    TRANSPARENT: Color;
+};

package/dist/types/src/colors/gradient/base.gradient.d.ts

@@ -0,0 +1,17 @@
+import { Color } from "../color.ts";
+export declare abstract class BaseGradient {
+    protected colors: {
+        percentage: number;
+        color: Color;
+    }[];
+    constructor(...colors: typeof this.colors);
+    /**
+     * Получить цвет по углу от оси X по часовой стрелке
+     * @param percentage единица измерения угла должна быть той же самой, что и углы всех передаваемых в констурктор цветов
+     */
+    getColorAtPercentage(percentage: number): Color | undefined;
+    getPercentageByColor(color: Color): number | undefined;
+    isColorInRange(color: Color): boolean;
+    abstract toCanvas(ctx: CanvasRenderingContext2D, ...args: any): CanvasGradient;
+    abstract toCSS(...args: any): string;
+}

package/dist/types/src/colors/gradient/conic.gradient.d.ts

@@ -0,0 +1,12 @@
+import type { IPoint2 } from "../../figures/index.ts";
+import { BaseGradient } from "./base.gradient.ts";
+export declare class ConicGradient extends BaseGradient {
+    /**
+     * Для использования метода, углы  должны быть в Turn единицах измерения
+     */
+    toCanvas(ctx: CanvasRenderingContext2D, center: IPoint2): CanvasGradient;
+    /**
+     * Для использования метода, углы  должны быть в Turn единицах измерения
+     */
+    toCSS(): string;
+}

package/dist/types/src/colors/gradient/index.d.ts

@@ -0,0 +1,2 @@
+export * from './conic.gradient.ts';
+export * from './linear.gradient.ts';

package/dist/types/src/colors/gradient/linear.gradient.d.ts

@@ -0,0 +1,6 @@
+import { BaseGradient } from "./base.gradient.ts";
+import type { IPoint2 } from "../../figures/index.ts";
+export declare class LinearGradient extends BaseGradient {
+    toCanvas(ctx: CanvasRenderingContext2D, p1: IPoint2, p2: IPoint2): CanvasGradient;
+    toCSS(direction?: string): string;
+}

package/dist/types/src/colors/index.d.ts

@@ -1,2 +1,5 @@
 export * from './color.ts';
-export * from './conic.gradient.ts';
+export * from './gradient/conic.gradient.ts';
+export * from "./blend.ts";
+export * from './utils.ts';
+export * from './constants.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fbltd/math",
-  "version": "1.0.40",
+  "version": "1.0.41",
   "description": "Math and geometry utilities",
   "sideEffects": false,
   "main": "dist/bin/index.js",

package/dist/types/src/colors/conic.gradient.d.ts

@@ -1,27 +0,0 @@
-import { Color } from "./color.ts";
-import type { IPoint2 } from "../figures/index.ts";
-export declare class ConicGradient {
-    colors: {
-        angle: number;
-        color: Color;
-    }[];
-    constructor(...colors: {
-        angle: number;
-        color: Color;
-    }[]);
-    /**
-     * Получить цвет по углу от оси X по часовой стрелке
-     * @param angle единица измерения угла должна быть той же самой, что и углы всех передаваемых в констурктор цветов
-     */
-    getColorAtAngle(angle: number): Color | undefined;
-    getAngleByColor(color: Color): number | undefined;
-    isColorInRange(color: Color): boolean;
-    /**
-     * Для использования метода, углы  должны быть в Turn единицах измерения
-     */
-    toCanvas(ctx: CanvasRenderingContext2D, center: IPoint2): CanvasGradient;
-    /**
-     * Для использования метода, углы  должны быть в Turn единицах измерения
-     */
-    toCSS(): string;
-}