@newtonedev/colors 0.0.1 → 1.1.0

package/dist/index.js

@@ -302,6 +302,13 @@ function contrastTextHex(background) {
 }
 
 // src/contrast/apca.ts
+var APCA_LC_MAX = 108;
+function apcaToNormalized(lc) {
+  return Math.max(-1, Math.min(1, lc / APCA_LC_MAX));
+}
+function normalizedToApca(normalized) {
+  return normalized * APCA_LC_MAX;
+}
 function apcaContrast(textColor, bgColor) {
   let txtY = APCA_SRGB_R * textColor.r ** APCA_MAIN_TRC + APCA_SRGB_G * textColor.g ** APCA_MAIN_TRC + APCA_SRGB_B * textColor.b ** APCA_MAIN_TRC;
   let bgY = APCA_SRGB_R * bgColor.r ** APCA_MAIN_TRC + APCA_SRGB_G * bgColor.g ** APCA_MAIN_TRC + APCA_SRGB_B * bgColor.b ** APCA_MAIN_TRC;
@@ -343,84 +350,147 @@ function mix(a, b, t) {
 }
 
 // src/config.ts
+var DEFAULT_SCALE_STEPS = 26;
+var DEFAULT_HUE = 0;
 var MIN_LIGHTEST_L = 0.96;
 var MAX_DARKEST_L = 0.16;
-var GRADE_REACH = 3 / 5;
-var MAX_GRADE_INTENSITY = 0.25;
-var LOCAL_GRADE_REACH = 2 / 3;
-var MAX_LOCAL_GRADE_INTENSITY = 0.5;
+var GRADING_REACH = 3 / 5;
+var MAX_GRADING_AMOUNT = 0.25;
+var GRADING_CHROMA_RATIO = 0.5;
+var SHIFT_REACH = 2 / 3;
+var MAX_SHIFT_AMOUNT = 0.5;
 var PERCEPTUAL_JND = 0.02;
 
 // src/scale/hue-grade.ts
-function gradeHue(baseHue, t, grade, reach = GRADE_REACH, maxIntensity = MAX_GRADE_INTENSITY) {
-  const { lightHue, lightValue, darkHue, darkValue } = grade;
-  const li = Math.max(0, Math.min(maxIntensity, lightValue));
-  const di = Math.max(0, Math.min(maxIntensity, darkValue));
+function gradeHue(baseHue, t, grade, reach = GRADING_REACH, maxIntensity = MAX_GRADING_AMOUNT) {
+  const li = Math.max(0, Math.min(maxIntensity, grade.light?.amount ?? 0));
+  const di = Math.max(0, Math.min(maxIntensity, grade.dark?.amount ?? 0));
   if (li === 0 && di === 0) return baseHue;
   const lightInfluence = t <= reach ? 0.5 * (1 + Math.cos(Math.PI * t / reach)) : 0;
   const darkInfluence = t >= 1 - reach ? 0.5 * (1 + Math.cos(Math.PI * (1 - t) / reach)) : 0;
-  const toRad = Math.PI / 180;
-  const baseRad = baseHue * toRad;
+  const toRad2 = Math.PI / 180;
+  const baseRad = baseHue * toRad2;
   const bx = Math.cos(baseRad);
   const by = Math.sin(baseRad);
   let dx = 0;
   let dy = 0;
   if (lightInfluence > 0 && li > 0) {
     const blend = lightInfluence * li;
-    const lRad = lightHue * toRad;
+    const lRad = grade.light.hue * toRad2;
     dx += blend * (Math.cos(lRad) - bx);
     dy += blend * (Math.sin(lRad) - by);
   }
   if (darkInfluence > 0 && di > 0) {
     const blend = darkInfluence * di;
-    const dRad = darkHue * toRad;
+    const dRad = grade.dark.hue * toRad2;
     dx += blend * (Math.cos(dRad) - bx);
     dy += blend * (Math.sin(dRad) - by);
   }
   const rx = bx + dx;
   const ry = by + dy;
   if (rx * rx + ry * ry < 1e-20) return baseHue;
-  return (Math.atan2(ry, rx) / toRad + 360) % 360;
+  return (Math.atan2(ry, rx) / toRad2 + 360) % 360;
+}
+function gradingInfluence(t, grading) {
+  const li = Math.max(0, Math.min(MAX_GRADING_AMOUNT, grading.light?.amount ?? 0));
+  const di = Math.max(0, Math.min(MAX_GRADING_AMOUNT, grading.dark?.amount ?? 0));
+  if (li === 0 && di === 0) return 0;
+  const lightInfluence = t <= GRADING_REACH ? 0.5 * (1 + Math.cos(Math.PI * t / GRADING_REACH)) : 0;
+  const darkInfluence = t >= 1 - GRADING_REACH ? 0.5 * (1 + Math.cos(Math.PI * (1 - t) / GRADING_REACH)) : 0;
+  const lightBlend = lightInfluence * (li / MAX_GRADING_AMOUNT);
+  const darkBlend = darkInfluence * (di / MAX_GRADING_AMOUNT);
+  return Math.max(lightBlend, darkBlend);
 }
 function resolveGradedHue(baseHue, t, globalGrade, localGrade) {
   let h = baseHue;
+  if (localGrade) h = gradeHue(h, t, localGrade, SHIFT_REACH, MAX_SHIFT_AMOUNT);
   if (globalGrade) h = gradeHue(h, t, globalGrade);
-  if (localGrade) h = gradeHue(h, t, localGrade, LOCAL_GRADE_REACH, MAX_LOCAL_GRADE_INTENSITY);
   return h;
 }
-function buildOneSidedGrade(hue, value, side) {
-  return side === "light" ? { lightHue: hue, lightValue: value, darkHue: 0, darkValue: 0 } : { lightHue: 0, lightValue: 0, darkHue: hue, darkValue: value };
+function buildOneSidedGrade(hue, amount, light = false) {
+  return light ? { light: { hue, amount } } : { dark: { hue, amount } };
+}
+
+// src/scale/dynamic-range.ts
+function resolveLightest(slider) {
+  const s = Math.max(0, Math.min(1, slider));
+  return MIN_LIGHTEST_L + s * (1 - MIN_LIGHTEST_L);
+}
+function resolveDarkest(slider) {
+  const s = Math.max(0, Math.min(1, slider));
+  return MAX_DARKEST_L * (1 - s);
+}
+function lightnessToScaleT(L, lightestL, darkestL) {
+  const range = lightestL - darkestL;
+  if (range <= 0) return 0.5;
+  return Math.max(0, Math.min(1, (lightestL - L) / range));
 }
 
 // src/scale/generate.ts
-function generateScale(options) {
+var toRad = Math.PI / 180;
+function applyGradingOverlay(C, h, L, t, grading, gamut) {
+  const li = Math.max(0, Math.min(MAX_GRADING_AMOUNT, grading.light?.amount ?? 0));
+  const di = Math.max(0, Math.min(MAX_GRADING_AMOUNT, grading.dark?.amount ?? 0));
+  if (li === 0 && di === 0) return { C, h };
+  const lightFade = t <= GRADING_REACH ? 0.5 * (1 + Math.cos(Math.PI * t / GRADING_REACH)) : 0;
+  const darkFade = t >= 1 - GRADING_REACH ? 0.5 * (1 + Math.cos(Math.PI * (1 - t) / GRADING_REACH)) : 0;
+  const lightBlend = lightFade * (li / MAX_GRADING_AMOUNT);
+  const darkBlend = darkFade * (di / MAX_GRADING_AMOUNT);
+  if (lightBlend === 0 && darkBlend === 0) return { C, h };
+  const hRad = h * toRad;
+  let a = C * Math.cos(hRad);
+  let b = C * Math.sin(hRad);
+  if (lightBlend > 0) {
+    const lh = grading.light.hue;
+    const lRad = lh * toRad;
+    const lC = maxChroma(L, lh, gamut) * GRADING_CHROMA_RATIO * lightBlend;
+    a += lC * Math.cos(lRad);
+    b += lC * Math.sin(lRad);
+  }
+  if (darkBlend > 0) {
+    const dh = grading.dark.hue;
+    const dRad = dh * toRad;
+    const dC = maxChroma(L, dh, gamut) * GRADING_CHROMA_RATIO * darkBlend;
+    a += dC * Math.cos(dRad);
+    b += dC * Math.sin(dRad);
+  }
+  let newC = Math.sqrt(a * a + b * b);
+  let newH = (Math.atan2(b, a) / toRad + 360) % 360;
+  newC = Math.min(newC, maxChroma(L, newH, gamut));
+  return { C: newC, h: newH };
+}
+function generateScale(options = {}) {
   const {
-    hue,
-    steps,
+    contrast,
+    hue = DEFAULT_HUE,
     chroma,
-    gamut = "srgb",
-    lightest = 1,
-    darkest = 0,
+    isP3 = false,
     grading,
-    gradient
+    shift
   } = options;
-  const chromaRatio = chroma?.value ?? 1;
-  const chromaPeak = chroma?.offset ?? 0.5;
+  const gamut = isP3 ? "display-p3" : "srgb";
+  const steps = DEFAULT_SCALE_STEPS;
+  const chromaRatio = chroma?.amount ?? 0;
+  const chromaPeak = chroma?.balance ?? 0.5;
   const hueGrade = grading;
-  const localHueGrade = gradient ? buildOneSidedGrade(gradient.hue, gradient.value, gradient.direction) : void 0;
-  if (steps < 2) return [];
+  const localHueGrade = shift ? buildOneSidedGrade(shift.hue, shift.amount, shift.light) : void 0;
   const ratio = Math.max(0, Math.min(1, chromaRatio));
   const peak = Math.max(0, Math.min(1, chromaPeak));
-  const lightestL = Math.max(0, Math.min(1, lightest));
-  const darkestL = Math.max(0, Math.min(1, darkest));
+  const lightestL = resolveLightest(contrast?.light ?? 1);
+  const darkestL = resolveDarkest(contrast?.dark ?? 1);
   const hueAt = (t) => resolveGradedHue(hue, t, hueGrade, localHueGrade);
   if (peak === 0.5 || ratio === 0 || ratio >= 1) {
     const scale2 = [];
     for (let i = 0; i < steps; i++) {
       const t = i / (steps - 1);
       const L = lightestL - t * (lightestL - darkestL);
-      const h = hueAt(t);
-      const C = maxChroma(L, h, gamut) * ratio;
+      let h = hueAt(t);
+      let C = Math.min(maxChroma(L, hue, gamut) * ratio, maxChroma(L, h, gamut));
+      if (hueGrade) {
+        const overlay = applyGradingOverlay(C, h, L, t, hueGrade, gamut);
+        C = overlay.C;
+        h = overlay.h;
+      }
       scale2.push({ L, C, h });
     }
     return scale2;
@@ -432,7 +502,7 @@ function generateScale(options) {
   for (let i = 0; i <= N; i++) {
     const t = i / N;
     const L = lightestL - t * (lightestL - darkestL);
-    const C = maxChroma(L, hueAt(t), gamut);
+    const C = maxChroma(L, hue, gamut);
     boundarySamples.push({ t, C });
     if (C > peakBoundaryC) {
       peakBoundaryC = C;
@@ -461,7 +531,7 @@ function generateScale(options) {
   for (let i = 0; i < steps; i++) {
     const t = i / (steps - 1);
     const L = lightestL - t * (lightestL - darkestL);
-    const h = hueAt(t);
+    let h = hueAt(t);
     let tWarped;
     if (t <= targetT) {
       tWarped = t * (peakT / targetT);
@@ -469,16 +539,22 @@ function generateScale(options) {
       tWarped = peakT + (t - targetT) * ((1 - peakT) / (1 - targetT));
     }
     const Lwarped = lightestL - tWarped * (lightestL - darkestL);
-    const warpedC = maxChroma(Lwarped, hueAt(tWarped), gamut) * ratio;
+    const warpedC = maxChroma(Lwarped, hue, gamut) * ratio;
     const boundaryC = maxChroma(L, h, gamut);
-    const C = Math.min(warpedC, boundaryC);
+    let C = Math.min(warpedC, boundaryC);
+    if (hueGrade) {
+      const overlay = applyGradingOverlay(C, h, L, t, hueGrade, gamut);
+      C = overlay.C;
+      h = overlay.h;
+    }
     scale.push({ L, C, h });
   }
   return scale;
 }
 
 // src/scale/resolve-color.ts
-function resolveColor(input, gamut = "srgb") {
+function resolveColor(input, isP3 = false) {
+  const gamut = isP3 ? "display-p3" : "srgb";
   const isHex = typeof input === "string";
   const original = isHex ? hexToOklch(input) : input;
   let inGamut;
@@ -501,53 +577,26 @@ function resolveColor(input, gamut = "srgb") {
     chromaRatio: Math.min(1, chromaRatio)
   };
 }
-function findNearest(target, scale) {
-  if (scale.length === 0) {
-    throw new Error("findNearest: scale must not be empty");
-  }
-  let bestIndex = 0;
-  let bestDistance = Infinity;
-  for (let i = 0; i < scale.length; i++) {
-    const d = deltaEOK(target, scale[i]);
-    if (d < bestDistance) {
-      bestDistance = d;
-      bestIndex = i;
-    }
-  }
-  return {
-    index: bestIndex,
-    color: scale[bestIndex],
-    distance: bestDistance
-  };
-}
-
-// src/scale/dynamic-range.ts
-function resolveLightest(slider) {
-  const s = Math.max(0, Math.min(1, slider));
-  return MIN_LIGHTEST_L + s * (1 - MIN_LIGHTEST_L);
-}
-function resolveDarkest(slider) {
-  const s = Math.max(0, Math.min(1, slider));
-  return MAX_DARKEST_L * (1 - s);
-}
-function lightnessToScaleT(L, lightestL, darkestL) {
-  const range = lightestL - darkestL;
-  if (range <= 0) return 0.5;
-  return Math.max(0, Math.min(1, (lightestL - L) / range));
-}
 
 // src/scale/key-color.ts
 function keyColor(color, options) {
-  const { gamut = "srgb", lightest = 1, darkest = 0 } = options ?? {};
-  const resolved = resolveColor(color, gamut);
-  const offset = lightnessToScaleT(resolved.oklch.L, lightest, darkest);
+  const { isP3 = false, contrast, steps = DEFAULT_SCALE_STEPS } = options ?? {};
+  const resolved = resolveColor(color, isP3);
+  const lightestL = resolveLightest(contrast?.light ?? 1);
+  const darkestL = resolveDarkest(contrast?.dark ?? 1);
+  const balance = lightnessToScaleT(resolved.oklch.L, lightestL, darkestL);
+  const stepIndex = Math.round(balance * Math.max(0, steps - 1));
   return {
     hue: resolved.hue,
-    chroma: { value: resolved.chromaRatio, offset },
-    resolved
+    chroma: { amount: resolved.chromaRatio, balance },
+    stepIndex,
+    hex: resolved.hex,
+    oklch: resolved.oklch,
+    wasRemapped: resolved.wasRemapped,
+    original: resolved.original
   };
 }
 
-export { GRADE_REACH, LOCAL_GRADE_REACH, MAX_DARKEST_L, MAX_GRADE_INTENSITY, MAX_LOCAL_GRADE_INTENSITY, MIN_LIGHTEST_L, PERCEPTUAL_JND, apcaContrast, buildOneSidedGrade, clampSrgb, contrastTextHex, deltaEOK, deltaEOKLab, findNearest, gamutMap, generateScale, gradeHue, hexToOklch, hexToSrgb, isInGamut, keyColor, lightnessToScaleT, linearChannelToSrgb, linearP3ToOklab, linearSrgbToOklab, linearSrgbToSrgb, maxChroma, mix, oklabToLinearP3, oklabToLinearSrgb, oklabToOklch, oklabToSrgb, oklchToHex, oklchToOklab, oklchToP3, oklchToSrgb, p3ToOklch, resolveColor, resolveDarkest, resolveGradedHue, resolveLightest, srgbChannelToLinear, srgbToHex, srgbToLinearSrgb, srgbToOklab, srgbToOklch, wcagContrast, wcagLuminance };
+export { APCA_LC_MAX, DEFAULT_HUE, DEFAULT_SCALE_STEPS, GRADING_CHROMA_RATIO, GRADING_REACH, MAX_DARKEST_L, MAX_GRADING_AMOUNT, MAX_SHIFT_AMOUNT, MIN_LIGHTEST_L, PERCEPTUAL_JND, SHIFT_REACH, apcaContrast, apcaToNormalized, buildOneSidedGrade, clampSrgb, contrastTextHex, deltaEOK, deltaEOKLab, gamutMap, generateScale, gradeHue, gradingInfluence, hexToOklch, hexToSrgb, isInGamut, keyColor, lightnessToScaleT, linearChannelToSrgb, linearP3ToOklab, linearSrgbToOklab, linearSrgbToSrgb, maxChroma, mix, normalizedToApca, oklabToLinearP3, oklabToLinearSrgb, oklabToOklch, oklabToSrgb, oklchToHex, oklchToOklab, oklchToP3, oklchToSrgb, p3ToOklch, resolveGradedHue, srgbChannelToLinear, srgbToHex, srgbToLinearSrgb, srgbToOklab, srgbToOklch, wcagContrast, wcagLuminance };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map