@fbltd/math 1.0.47 → 1.0.49

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

@@ -3,7 +3,7 @@ import { Color } from "./color.js";
  * Смешение цветов
  */
 export function blend(background, ...foregrounds) {
-    let temp;
+    let premulBgAlpha;
     let red, green, blue;
     for (let foreground of foregrounds) {
         const fgAlpha = foreground.alpha;
@@ -13,10 +13,10 @@ export function blend(background, ...foregrounds) {
             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);
+        premulBgAlpha = bgAlpha * (1 - fgAlpha);
+        red = Math.floor((foreground.red * fgAlpha + background.red * premulBgAlpha) / alpha);
+        green = Math.floor((foreground.green * fgAlpha + background.green * premulBgAlpha) / alpha);
+        blue = Math.floor((foreground.blue * fgAlpha + background.blue * premulBgAlpha) / alpha);
         background = new Color(red, green, blue, alpha);
     }
     return background;

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

@@ -1,5 +1,6 @@
 import { Color } from "../color.js";
-import { denormalizeShade } from "../utils.js";
+import { denormalizeShade, normalizeShade } from "../utils.js";
+import { clamp, normalize } from "../../utils.js";
 export class BaseGradient {
     colors;
     constructor(...colors) {
@@ -40,19 +41,19 @@ export class BaseGradient {
             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 alphaDif = next.color.alpha - 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);
+            let alphaDifColor = color.alpha - 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)) &&
                 ((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 alphaCoef = ((color.alpha - prev.color.alpha) / (next.color.alpha - prev.color.alpha));
+                const redCoef = redDifColor / redDif;
+                const greenCoef = greenDifColor / greenDif;
+                const blueCoef = blueDifColor / blueDif;
+                const alphaCoef = (alphaDifColor / alphaDif);
                 const coefs = [redCoef, greenCoef, blueCoef, alphaCoef].filter(Boolean);
                 return (next.percentage - prev.percentage) * Math.min(...coefs) + prev.percentage;
             }
@@ -62,4 +63,25 @@ export class BaseGradient {
     isColorInRange(color) {
         return Boolean(this.getPercentageByColor(color));
     }
+    static restoreColor(startColor, endColor, value, startValue = 0, endValue = 1) {
+        if (value === startValue)
+            return startColor;
+        if (value === endValue)
+            return endColor;
+        value = normalize(value, endValue, startValue);
+        const color = new Color(0, 0, 0, 0);
+        let normalizedStart, normalizedEnd, resultShade;
+        for (let key of ['red', 'green', 'blue', 'alpha']) {
+            normalizedStart = startColor[key];
+            normalizedEnd = endColor[key];
+            if (key !== 'alpha') {
+                normalizedStart = normalizeShade(normalizedStart);
+                normalizedEnd = normalizeShade(normalizedEnd);
+            }
+            resultShade = normalizedStart + (normalizedEnd - normalizedStart) * value;
+            resultShade = clamp(resultShade);
+            color[key] = key === 'alpha' ? resultShade : denormalizeShade(resultShade);
+        }
+        return color;
+    }
 }

package/dist/bin/src/utils.js

@@ -32,3 +32,6 @@ export function isNatural(n) {
 export function isNonNegativeInteger(n) {
     return !isNegative(n) && isInteger(n);
 }
+export function clamp(value, min = 0, max = 1) {
+    return Math.min(Math.max(value, min), max);
+}

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

@@ -14,4 +14,5 @@ export declare abstract class BaseGradient {
     isColorInRange(color: Color): boolean;
     abstract toCanvas(ctx: CanvasRenderingContext2D, ...args: any): CanvasGradient;
     abstract toCSS(...args: any): string;
+    static restoreColor(startColor: Color, endColor: Color, value: number, startValue?: number, endValue?: number): Color;
 }

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

@@ -1,6 +1,6 @@
 import type { IPoint2 } from "../../figures/index.ts";
 import { BaseGradient } from "./base.gradient.ts";
-import { Color } from "../color.js";
+import { Color } from "../color.ts";
 export declare class ConicGradient extends BaseGradient {
     constructor(...colors: {
         percentage: number;

package/dist/types/src/utils.d.ts

@@ -8,3 +8,4 @@ export declare function isNegative(n: number): boolean;
 export declare function isInteger(n: number): boolean;
 export declare function isNatural(n: number): boolean;
 export declare function isNonNegativeInteger(n: number): boolean;
+export declare function clamp(value: number, min?: number, max?: number): number;

package/package.json

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