@skbkontur/colors 2.0.4 → 2.0.6-alpha.0

package/lib/helpers/get-palette.js

@@ -19,14 +19,14 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { clampChroma, converter } from 'culori';
-import { calcAPCA } from 'apca-w3';
-import * as DefaultSwatch from '../consts/default-swatch.js';
 import { CHROMA_PARAMS } from '../consts/params/chroma-params.js';
 import { ABNEY_CORRECTION } from '../consts/params/abney-correction.js';
 import { PROMO_HUE_SHIFTS } from '../consts/params/promo-hue-shift.js';
 import { WARNING_HUE_PATCH } from '../consts/params/warning-hue-patch.js';
+var toOklch = converter('oklch');
 export function getPalette(_a) {
-    var color = _a.color, _b = _a.type, type = _b === void 0 ? 'default' : _b, customSettings = _a.settings;
+    var _b;
+    var color = _a.color, _c = _a.type, type = _c === void 0 ? 'default' : _c, customSettings = _a.settings;
     var defaultSettings = {
         chromaSettings: CHROMA_PARAMS,
         abneyCorrection: ABNEY_CORRECTION,
@@ -34,9 +34,6 @@ export function getPalette(_a) {
         warningHuePatch: WARNING_HUE_PATCH,
     };
     var settings = __assign(__assign({}, defaultSettings), customSettings);
-    var toOklch = converter('oklch');
-    var oklchColor = toOklch(color);
-    var currentHue = (oklchColor === null || oklchColor === void 0 ? void 0 : oklchColor.h) || 0;
     var toNorm = function (x) { return x / 100; };
     var calculateChromaValue = function (rel, min, max, baseChromaMax) {
         var raw = (baseChromaMax * rel) / 100;
@@ -55,6 +52,8 @@ export function getPalette(_a) {
         dim: {},
     };
     var isWarning = type === 'warning';
+    var baseHue = calcBaseHue(color, settings.abneyCorrection);
+    var correctionHueRange = calcCorrectionRange(color, settings.abneyCorrection);
     for (var Lstr in settings.chromaSettings) {
         var L = +Lstr;
         if (L === 100) {
@@ -63,52 +62,30 @@ export function getPalette(_a) {
             result.dim[L] = "oklch(100% 0 0)";
             continue;
         }
-        var hueAfterWarningPatch = applyWarningHuePatch(currentHue, L, settings.warningHuePatch, isWarning);
-        var appliedHueShift = applyAbneyShift(L, hueAfterWarningPatch, settings.abneyCorrection);
-        var chromaMax = clampChroma({ mode: 'oklch', l: L / 100, c: 1, h: appliedHueShift }, 'oklch').c;
+        var hue = baseHue;
+        var lightnessCorrectionData = settings.abneyCorrection[L];
+        if (lightnessCorrectionData && correctionHueRange !== undefined) {
+            var shift = (_b = lightnessCorrectionData[correctionHueRange]) !== null && _b !== void 0 ? _b : 0;
+            hue = (baseHue + shift + 360) % 360;
+        }
+        if (isWarning) {
+            hue = calcWarningHuePatch(hue, L, settings.warningHuePatch);
+        }
+        var chromaMax = clampChroma({ mode: 'oklch', l: L / 100, c: 1, h: hue }, 'oklch').c;
         var currentParams = settings.chromaSettings[L];
         var vividN = calculateChromaValue(currentParams.vivid.rel, currentParams.vivid.min, currentParams.vivid.max, chromaMax);
         var normN = calculateChromaValue(currentParams.normal.rel, currentParams.normal.min, currentParams.normal.max, chromaMax);
         var dimN = calculateChromaValue(currentParams.dim.rel, currentParams.dim.min, currentParams.dim.max, chromaMax);
-        result.vivid[L] = "oklch(".concat(L, "% ").concat(vividN.toFixed(3), " ").concat(appliedHueShift.toFixed(0), ")");
-        result.normal[L] = "oklch(".concat(L, "% ").concat(normN.toFixed(3), " ").concat(appliedHueShift.toFixed(0), ")");
-        result.dim[L] = "oklch(".concat(L, "% ").concat(dimN.toFixed(3), " ").concat(appliedHueShift.toFixed(0), ")");
+        result.vivid[L] = "oklch(".concat(L, "% ").concat(vividN.toFixed(3), " ").concat(hue.toFixed(0), ")");
+        result.normal[L] = "oklch(".concat(L, "% ").concat(normN.toFixed(3), " ").concat(hue.toFixed(0), ")");
+        result.dim[L] = "oklch(".concat(L, "% ").concat(dimN.toFixed(3), " ").concat(hue.toFixed(0), ")");
     }
     return result;
 }
-export function getAbneyHueShift(lightness, currentHue, abneyData) {
-    var lightnessData = abneyData[lightness];
-    if (!lightnessData) {
-        return 0;
-    }
-    var hueRanges = Object.keys(lightnessData)
-        .map(Number)
-        .sort(function (a, b) { return a - b; });
-    var selectedHueRange = hueRanges[0];
-    for (var i = 0; i < hueRanges.length; i++) {
-        var startRange = hueRanges[i];
-        var endRange = hueRanges[i + 1] !== undefined ? hueRanges[i + 1] : 360;
-        if (currentHue >= startRange && currentHue < endRange) {
-            selectedHueRange = startRange;
-            break;
-        }
-        if (i === hueRanges.length - 1 && currentHue >= startRange && currentHue < 360) {
-            selectedHueRange = startRange;
-            break;
-        }
-    }
-    return lightnessData[selectedHueRange] !== undefined ? lightnessData[selectedHueRange] : 0;
-}
-export function applyAbneyShift(lightness, currentHue, abneyData) {
-    var abneyShift = getAbneyHueShift(lightness, currentHue, abneyData);
-    return (currentHue + abneyShift + 360) % 360;
-}
-export function applyWarningHuePatch(currentHue, lightness, warningHuePatchData, isWarningMode) {
-    if (isWarningMode) {
-        var patch = warningHuePatchData[lightness];
-        if (patch !== undefined) {
-            return (currentHue + patch + 360) % 360;
-        }
+export function calcWarningHuePatch(currentHue, lightness, warningHuePatchData) {
+    var patch = warningHuePatchData[lightness];
+    if (patch !== undefined) {
+        return (currentHue + patch + 360) % 360;
     }
     return currentHue;
 }
@@ -129,30 +106,13 @@ function findClosestLightnessStep(targetL, availableLightnessSteps) {
     }
     return closestStep;
 }
-export function calculateBaseHueAndCorrectionRange(inputColorString, abneyData) {
-    var toOklch = converter('oklch');
-    var oklch = toOklch(inputColorString);
-    if (!oklch) {
-        console.warn("Could not parse color string: ".concat(inputColorString));
-        return null;
-    }
-    var targetLightness = Math.round(oklch.l * 100);
-    var targetHue = oklch.h;
-    if (isNaN(targetHue)) {
-        console.warn("Achromatic color detected (".concat(inputColorString, "). Defaulting hue to 0."));
-        targetHue = 0;
-    }
+export function calcBaseHue(inputColorString, abneyData) {
+    var colorOKLCH = toOklch(inputColorString);
+    var targetLightness = colorOKLCH.l * 100;
+    var targetHue = colorOKLCH.h;
     var availableLightnessSteps = Object.keys(abneyData).map(Number);
-    if (availableLightnessSteps.length === 0) {
-        console.warn('Abney correction data is empty, cannot calculate base hue.');
-        return null;
-    }
     var closestLightness = findClosestLightnessStep(targetLightness, availableLightnessSteps);
     var lightnessCorrectionData = abneyData[closestLightness];
-    if (!lightnessCorrectionData) {
-        console.warn("No Abney correction data for lightness ".concat(closestLightness, "."));
-        return null;
-    }
     var correctedHueMap = Object.entries(lightnessCorrectionData).map(function (_a) {
         var rawHueStr = _a[0], shift = _a[1];
         var rawHue = Number(rawHueStr);
@@ -162,43 +122,50 @@ export function calculateBaseHueAndCorrectionRange(inputColorString, abneyData)
             correctedHue: (rawHue + shift + 360) % 360,
         };
     });
-    correctedHueMap.sort(function (a, b) {
-        if (a.correctedHue !== b.correctedHue) {
-            return a.correctedHue - b.correctedHue;
-        }
-        return a.rawHue - b.rawHue;
-    });
+    correctedHueMap.sort(function (a, b) { return a.correctedHue - b.correctedHue; });
     if (correctedHueMap.length === 0) {
-        console.warn("No hue ranges defined for lightness ".concat(closestLightness, "."));
-        return null;
+        return targetHue;
     }
-    var findCorrectRange = function () {
-        var nextRangeIndex = correctedHueMap.findIndex(function (range) { return range.correctedHue > targetHue; });
-        if (nextRangeIndex === 0) {
-            return correctedHueMap[correctedHueMap.length - 1];
+    var selectedRange = correctedHueMap[correctedHueMap.length - 1];
+    for (var i = 0; i < correctedHueMap.length; i++) {
+        var current = correctedHueMap[i];
+        var next = correctedHueMap[i + 1];
+        if (!next) {
+            selectedRange = current;
+            break;
         }
-        if (nextRangeIndex > 0) {
-            return correctedHueMap[nextRangeIndex - 1];
+        if (targetHue >= current.correctedHue && targetHue < next.correctedHue) {
+            selectedRange = current;
+            break;
         }
-        return correctedHueMap[correctedHueMap.length - 1];
-    };
-    var selectedRange = findCorrectRange();
-    if (!selectedRange) {
-        console.error('Could not determine the correct hue range.');
-        return null;
     }
-    var baseHue = (targetHue - selectedRange.shift + 360) % 360;
-    return {
-        baseHue: baseHue,
-        correctionLightness: closestLightness,
-        correctionHueRange: selectedRange.rawHue,
-    };
+    return (targetHue - selectedRange.shift + 360) % 360;
 }
-export function calcOnBrand(hex) {
-    var whiteContrast = Math.abs(Number(calcAPCA('#fff', hex)));
-    var blackContrast = Math.abs(Number(calcAPCA('#000', hex)));
-    if (whiteContrast + 10 >= blackContrast) {
-        return DefaultSwatch.whiteAlpha;
+export function calcCorrectionRange(inputColorString, abneyData) {
+    var colorOKLCH = toOklch(inputColorString);
+    var targetLightness = colorOKLCH.l * 100;
+    var targetHue = colorOKLCH.h;
+    var availableLightnessSteps = Object.keys(abneyData).map(Number);
+    var closestLightness = findClosestLightnessStep(targetLightness, availableLightnessSteps);
+    var lightnessCorrectionData = abneyData[closestLightness];
+    var correctedHueMap = Object.entries(lightnessCorrectionData).map(function (_a) {
+        var rawHueStr = _a[0], shift = _a[1];
+        var rawHue = Number(rawHueStr);
+        return {
+            rawHue: rawHue,
+            shift: shift,
+            correctedHue: (rawHue + shift + 360) % 360,
+        };
+    });
+    correctedHueMap.sort(function (a, b) { return a.correctedHue - b.correctedHue; });
+    var selectedRange = correctedHueMap[correctedHueMap.length - 1];
+    for (var i = 0; i < correctedHueMap.length; i++) {
+        var current = correctedHueMap[i];
+        var next = correctedHueMap[i + 1];
+        if (targetHue >= current.correctedHue && targetHue < next.correctedHue) {
+            selectedRange = current;
+            break;
+        }
     }
-    return DefaultSwatch.blackAlpha;
+    return selectedRange.rawHue;
 }

package/lib/helpers/get-palette.ts

@@ -1,5 +1,4 @@
 import { clampChroma, converter } from 'culori';
-import { calcAPCA } from 'apca-w3';
 
 import type {
   GeneratorColorAbneyCorrection,
@@ -7,12 +6,13 @@ import type {
   GeneratorColorPalette,
   GeneratorColorWarningHuePatch,
 } from '../types/tokens-base-generator.js';
-import * as DefaultSwatch from '../consts/default-swatch.js';
 import { CHROMA_PARAMS } from '../consts/params/chroma-params.js';
 import { ABNEY_CORRECTION } from '../consts/params/abney-correction.js';
 import { PROMO_HUE_SHIFTS } from '../consts/params/promo-hue-shift.js';
 import { WARNING_HUE_PATCH } from '../consts/params/warning-hue-patch.js';
 
+const toOklch = converter('oklch');
+
 interface GeneratePaletteParams {
   color: string;
   type?: 'default' | 'warning';
@@ -41,10 +41,6 @@ export function getPalette({
     ...customSettings,
   };
 
-  const toOklch = converter('oklch');
-  const oklchColor = toOklch(color);
-  const currentHue = oklchColor?.h || 0;
-
   const toNorm = (x: number) => x / 100;
 
   const calculateChromaValue = (
@@ -70,6 +66,8 @@ export function getPalette({
     dim: {},
   };
   const isWarning = type === 'warning';
+  const baseHue = calcBaseHue(color, settings.abneyCorrection);
+  const correctionHueRange = calcCorrectionRange(color, settings.abneyCorrection);
 
   for (const Lstr in settings.chromaSettings) {
     const L = +Lstr;
@@ -80,10 +78,18 @@ export function getPalette({
       continue;
     }
 
-    const hueAfterWarningPatch = applyWarningHuePatch(currentHue, L, settings.warningHuePatch, isWarning);
-    const appliedHueShift = applyAbneyShift(L, hueAfterWarningPatch, settings.abneyCorrection);
+    let hue = baseHue;
+    const lightnessCorrectionData = settings.abneyCorrection[L];
+    if (lightnessCorrectionData && correctionHueRange !== undefined) {
+      const shift = lightnessCorrectionData[correctionHueRange] ?? 0;
+      hue = (baseHue + shift + 360) % 360;
+    }
 
-    const chromaMax = clampChroma({ mode: 'oklch', l: L / 100, c: 1, h: appliedHueShift }, 'oklch').c;
+    if (isWarning) {
+      hue = calcWarningHuePatch(hue, L, settings.warningHuePatch);
+    }
+
+    const chromaMax = clampChroma({ mode: 'oklch', l: L / 100, c: 1, h: hue }, 'oklch').c;
     const currentParams = settings.chromaSettings[L];
 
     const vividN = calculateChromaValue(
@@ -100,62 +106,22 @@ export function getPalette({
     );
     const dimN = calculateChromaValue(currentParams.dim.rel, currentParams.dim.min, currentParams.dim.max, chromaMax);
 
-    result.vivid[L] = `oklch(${L}% ${vividN.toFixed(3)} ${appliedHueShift.toFixed(0)})`;
-    result.normal[L] = `oklch(${L}% ${normN.toFixed(3)} ${appliedHueShift.toFixed(0)})`;
-    result.dim[L] = `oklch(${L}% ${dimN.toFixed(3)} ${appliedHueShift.toFixed(0)})`;
+    result.vivid[L] = `oklch(${L}% ${vividN.toFixed(3)} ${hue.toFixed(0)})`;
+    result.normal[L] = `oklch(${L}% ${normN.toFixed(3)} ${hue.toFixed(0)})`;
+    result.dim[L] = `oklch(${L}% ${dimN.toFixed(3)} ${hue.toFixed(0)})`;
   }
 
   return result;
 }
 
-export function getAbneyHueShift(
-  lightness: number,
-  currentHue: number,
-  abneyData: GeneratorColorAbneyCorrection
-): number {
-  const lightnessData = abneyData[lightness];
-  if (!lightnessData) {
-    return 0;
-  }
-  const hueRanges = Object.keys(lightnessData)
-    .map(Number)
-    .sort((a, b) => a - b);
-  let selectedHueRange = hueRanges[0];
-  for (let i = 0; i < hueRanges.length; i++) {
-    const startRange = hueRanges[i];
-    const endRange = hueRanges[i + 1] !== undefined ? hueRanges[i + 1] : 360;
-    if (currentHue >= startRange && currentHue < endRange) {
-      selectedHueRange = startRange;
-      break;
-    }
-    if (i === hueRanges.length - 1 && currentHue >= startRange && currentHue < 360) {
-      selectedHueRange = startRange;
-      break;
-    }
-  }
-  return lightnessData[selectedHueRange] !== undefined ? lightnessData[selectedHueRange] : 0;
-}
-
-export function applyAbneyShift(
-  lightness: number,
-  currentHue: number,
-  abneyData: GeneratorColorAbneyCorrection
-): number {
-  const abneyShift = getAbneyHueShift(lightness, currentHue, abneyData);
-  return (currentHue + abneyShift + 360) % 360;
-}
-
-export function applyWarningHuePatch(
+export function calcWarningHuePatch(
   currentHue: number,
   lightness: number,
-  warningHuePatchData: GeneratorColorWarningHuePatch,
-  isWarningMode: boolean
+  warningHuePatchData: GeneratorColorWarningHuePatch
 ): number {
-  if (isWarningMode) {
-    const patch = warningHuePatchData[lightness];
-    if (patch !== undefined) {
-      return (currentHue + patch + 360) % 360;
-    }
+  const patch = warningHuePatchData[lightness];
+  if (patch !== undefined) {
+    return (currentHue + patch + 360) % 360;
   }
   return currentHue;
 }
@@ -178,37 +144,13 @@ function findClosestLightnessStep(targetL: number, availableLightnessSteps: numb
   return closestStep;
 }
 
-export function calculateBaseHueAndCorrectionRange(
-  inputColorString: string,
-  abneyData: GeneratorColorAbneyCorrection
-): {
-  baseHue: number;
-  correctionLightness: number;
-  correctionHueRange: number;
-} | null {
-  const toOklch = converter('oklch');
-  const oklch = toOklch(inputColorString) as { l: number; c: number; h: number };
-  if (!oklch) {
-    console.warn(`Could not parse color string: ${inputColorString}`);
-    return null;
-  }
-  const targetLightness = Math.round(oklch.l * 100);
-  let targetHue = oklch.h;
-  if (isNaN(targetHue)) {
-    console.warn(`Achromatic color detected (${inputColorString}). Defaulting hue to 0.`);
-    targetHue = 0;
-  }
+export function calcBaseHue(inputColorString: string, abneyData: GeneratorColorAbneyCorrection): number {
+  const colorOKLCH = toOklch(inputColorString) as { l: number; c: number; h: number };
+  const targetLightness = colorOKLCH.l * 100;
+  const targetHue = colorOKLCH.h;
   const availableLightnessSteps = Object.keys(abneyData).map(Number);
-  if (availableLightnessSteps.length === 0) {
-    console.warn('Abney correction data is empty, cannot calculate base hue.');
-    return null;
-  }
   const closestLightness = findClosestLightnessStep(targetLightness, availableLightnessSteps);
   const lightnessCorrectionData = abneyData[closestLightness];
-  if (!lightnessCorrectionData) {
-    console.warn(`No Abney correction data for lightness ${closestLightness}.`);
-    return null;
-  }
   const correctedHueMap = Object.entries(lightnessCorrectionData).map(([rawHueStr, shift]) => {
     const rawHue = Number(rawHueStr);
     return {
@@ -217,45 +159,59 @@ export function calculateBaseHueAndCorrectionRange(
       correctedHue: (rawHue + shift + 360) % 360,
     };
   });
-  correctedHueMap.sort((a, b) => {
-    if (a.correctedHue !== b.correctedHue) {
-      return a.correctedHue - b.correctedHue;
-    }
-    return a.rawHue - b.rawHue;
-  });
+
+  correctedHueMap.sort((a, b) => a.correctedHue - b.correctedHue);
   if (correctedHueMap.length === 0) {
-    console.warn(`No hue ranges defined for lightness ${closestLightness}.`);
-    return null;
+    return targetHue;
   }
-  const findCorrectRange = () => {
-    const nextRangeIndex = correctedHueMap.findIndex((range) => range.correctedHue > targetHue);
-    if (nextRangeIndex === 0) {
-      return correctedHueMap[correctedHueMap.length - 1];
+
+  let selectedRange = correctedHueMap[correctedHueMap.length - 1];
+  for (let i = 0; i < correctedHueMap.length; i++) {
+    const current = correctedHueMap[i];
+    const next = correctedHueMap[i + 1];
+
+    if (!next) {
+      selectedRange = current;
+      break;
     }
-    if (nextRangeIndex > 0) {
-      return correctedHueMap[nextRangeIndex - 1];
+
+    if (targetHue >= current.correctedHue && targetHue < next.correctedHue) {
+      selectedRange = current;
+      break;
     }
-    return correctedHueMap[correctedHueMap.length - 1];
-  };
-  const selectedRange = findCorrectRange();
-  if (!selectedRange) {
-    console.error('Could not determine the correct hue range.');
-    return null;
   }
-  const baseHue = (targetHue - selectedRange.shift + 360) % 360;
-  return {
-    baseHue,
-    correctionLightness: closestLightness,
-    correctionHueRange: selectedRange.rawHue,
-  };
+
+  return (targetHue - selectedRange.shift + 360) % 360;
 }
 
-export function calcOnBrand(hex: string) {
-  const whiteContrast = Math.abs(Number(calcAPCA('#fff', hex)));
-  const blackContrast = Math.abs(Number(calcAPCA('#000', hex)));
+export function calcCorrectionRange(inputColorString: string, abneyData: GeneratorColorAbneyCorrection): number {
+  const colorOKLCH = toOklch(inputColorString) as { l: number; c: number; h: number };
+  const targetLightness = colorOKLCH.l * 100;
+  const targetHue = colorOKLCH.h;
+  const availableLightnessSteps = Object.keys(abneyData).map(Number);
+  const closestLightness = findClosestLightnessStep(targetLightness, availableLightnessSteps);
+  const lightnessCorrectionData = abneyData[closestLightness];
+  const correctedHueMap = Object.entries(lightnessCorrectionData).map(([rawHueStr, shift]) => {
+    const rawHue = Number(rawHueStr);
+    return {
+      rawHue,
+      shift,
+      correctedHue: (rawHue + shift + 360) % 360,
+    };
+  });
+
+  correctedHueMap.sort((a, b) => a.correctedHue - b.correctedHue);
+
+  let selectedRange = correctedHueMap[correctedHueMap.length - 1];
+  for (let i = 0; i < correctedHueMap.length; i++) {
+    const current = correctedHueMap[i];
+    const next = correctedHueMap[i + 1];
 
-  if (whiteContrast + 10 >= blackContrast) {
-    return DefaultSwatch.whiteAlpha;
+    if (targetHue >= current.correctedHue && targetHue < next.correctedHue) {
+      selectedRange = current;
+      break;
+    }
   }
-  return DefaultSwatch.blackAlpha;
+
+  return selectedRange.rawHue;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skbkontur/colors",
-  "version": "2.0.4",
+  "version": "2.0.6-alpha.0",
   "author": "Kontur",
   "publishConfig": {
     "access": "public",
@@ -18,12 +18,12 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./colors.d.ts",
-      "default": "./colors.js"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     },
     "./get-colors": {
-      "types": "./lib/get-colors.d.ts",
-      "default": "./lib/get-colors.js"
+      "types": "./get-colors.d.ts",
+      "default": "./get-colors.js"
     },
     "./default-light": {
       "types": "./default-light.d.ts",