@clhaas/palette-kit 0.1.8 → 0.3.0

package/src/utils/parseColor.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { parseColor } from "./parseColor.js";
+
+describe("parseColor", () => {
+  it("parses #fff with alpha 1", () => {
+    const result = parseColor("#fff");
+
+    expect(result.input).toBe("#fff");
+    expect(result.srgb.space).toBe("srgb");
+    expect(result.srgb.alpha).toBe(1);
+    expect(result.srgb.channels[0]).toBeCloseTo(1, 6);
+    expect(result.srgb.channels[1]).toBeCloseTo(1, 6);
+    expect(result.srgb.channels[2]).toBeCloseTo(1, 6);
+  });
+
+  it("parses #112233", () => {
+    const result = parseColor("#112233");
+
+    expect(result.srgb.channels[0]).toBeCloseTo(0x11 / 255, 6);
+    expect(result.srgb.channels[1]).toBeCloseTo(0x22 / 255, 6);
+    expect(result.srgb.channels[2]).toBeCloseTo(0x33 / 255, 6);
+    expect(result.srgb.alpha).toBe(1);
+  });
+
+  it("parses #11223380 with alpha", () => {
+    const result = parseColor("#11223380");
+
+    expect(result.srgb.alpha).toBeCloseTo(0x80 / 255, 3);
+  });
+
+  it("normalizes okLch channels", () => {
+    const result = parseColor("#ffffff");
+    const [l, c, h] = result.okLch.channels;
+
+    expect(result.okLch.space).toBe("oklch");
+    expect(result.okLch.alpha).toBe(1);
+    expect(l).toBeGreaterThanOrEqual(0);
+    expect(l).toBeLessThanOrEqual(100);
+    expect(c).toBeGreaterThanOrEqual(0);
+    expect(h).toBeGreaterThanOrEqual(0);
+    expect(h).toBeLessThan(360);
+  });
+
+  it("preserves okLch alpha", () => {
+    const result = parseColor("#33669980");
+
+    expect(result.okLch.alpha).toBeCloseTo(0x80 / 255, 3);
+  });
+
+  it("throws on invalid input", () => {
+    expect(() => parseColor("#12")).toThrowError(/#12/);
+    expect(() => parseColor("#GGGGGG")).toThrowError(/#GGGGGG/);
+  });
+
+  it("includes rgb values when conversion fails", async () => {
+    vi.resetModules();
+    vi.doMock("culori", () => ({
+      converter: () => () => undefined,
+    }));
+
+    const { parseColor: mockedParseColor } = await import("./parseColor.js");
+
+    expect(() => mockedParseColor("#ffffff")).toThrowError(/r=1, g=1, b=1/);
+  });
+});

package/src/utils/parseColor.ts

@@ -0,0 +1,87 @@
+import { converter } from "culori";
+
+import type { CssColorString, RawColor } from "../types/index.js";
+
+const hexPattern = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const toOklch = converter("oklch");
+
+const OKLCH_L_MAX = 100;
+const OKLCH_H_MAX = 360;
+const MAX_OKLCH_CHROMA = 0.4;
+const NEGATIVE_CHROMA_EPSILON = 1e-6;
+
+const toChannel = (hex: string) => Number.parseInt(hex, 16) / 255;
+
+const normalizeHue = (hue: number) => ((hue % OKLCH_H_MAX) + OKLCH_H_MAX) % OKLCH_H_MAX;
+const clamp = (value: number, min: number, max: number) => Math.min(max, Math.max(min, value));
+
+export function parseColor(input: CssColorString): {
+  input: CssColorString;
+  okLch: RawColor;
+  srgb: RawColor;
+} {
+  const normalizedInput = input.trim();
+
+  if (!hexPattern.test(normalizedInput)) {
+    throw new Error(`Invalid color input: "${input}"`);
+  }
+
+  const hex = normalizedInput.slice(1);
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  let alpha = 1;
+
+  if (hex.length === 3) {
+    r = toChannel(`${hex[0]}${hex[0]}`);
+    g = toChannel(`${hex[1]}${hex[1]}`);
+    b = toChannel(`${hex[2]}${hex[2]}`);
+  } else if (hex.length === 6 || hex.length === 8) {
+    r = toChannel(hex.slice(0, 2));
+    g = toChannel(hex.slice(2, 4));
+    b = toChannel(hex.slice(4, 6));
+
+    if (hex.length === 8) {
+      alpha = toChannel(hex.slice(6, 8));
+    }
+  } else {
+    throw new Error(`Invalid hex length: "${normalizedInput}"`);
+  }
+
+  const oklchValue = toOklch({ mode: "rgb", r, g, b });
+
+  if (!oklchValue) {
+    throw new Error(`Unable to convert color input: "${normalizedInput}" (r=${r}, g=${g}, b=${b})`);
+  }
+
+  const l = typeof oklchValue.l === "number" && Number.isFinite(oklchValue.l) ? oklchValue.l : 0;
+  const c = typeof oklchValue.c === "number" && Number.isFinite(oklchValue.c) ? oklchValue.c : 0;
+  const h = typeof oklchValue.h === "number" && Number.isFinite(oklchValue.h) ? oklchValue.h : 0;
+  const scaledLightness = l * 100;
+
+  if (c < -NEGATIVE_CHROMA_EPSILON) {
+    throw new Error(`Invalid OKLCH chroma value: ${c} for "${input}"`);
+  }
+
+  const okLch: RawColor = {
+    space: "oklch",
+    channels: [
+      clamp(scaledLightness, 0, OKLCH_L_MAX),
+      clamp(Math.max(0, c), 0, MAX_OKLCH_CHROMA),
+      normalizeHue(h),
+    ],
+    alpha,
+  };
+
+  const srgb: RawColor = {
+    space: "srgb",
+    channels: [r, g, b],
+    alpha,
+  };
+
+  return {
+    input: normalizedInput,
+    okLch,
+    srgb,
+  };
+}

package/src/utils/smoothstep.ts

@@ -0,0 +1,6 @@
+import { clamp } from "./clamp.js";
+
+export const smoothstep = (t: number) => {
+  const x = clamp(t, 0, 1);
+  return x * x * (3 - 2 * x);
+};

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["tests/**", "examples/**", "node_modules/**"]
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "strict": true,
+    "types": ["node"],
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.ts"],
+  "exclude": ["examples/**", "tests/**", "node_modules/**"]
+}

package/dist/alpha/generateAlphaScale.d.ts

@@ -1,5 +0,0 @@
-import type { AlphaScale, ColorHex } from "../types.js";
-export declare function generateAlphaScale(base: ColorHex, _background: {
-    light: ColorHex;
-    dark: ColorHex;
-}): AlphaScale;

package/dist/alpha/generateAlphaScale.js

@@ -1,34 +0,0 @@
-import Color from "colorjs.io";
-const steps = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
-const alphaCurve = {
-    1: 0.05,
-    2: 0.1,
-    3: 0.15,
-    4: 0.2,
-    5: 0.3,
-    6: 0.4,
-    7: 0.5,
-    8: 0.6,
-    9: 0.7,
-    10: 0.8,
-    11: 0.9,
-    12: 0.95,
-};
-function mixWithAlpha(foreground, alpha) {
-    const color = new Color(foreground).to("srgb");
-    const [r, g, b] = color.coords;
-    const hex = new Color({ space: "srgb", coords: [r, g, b], alpha }).toString({
-        format: "hex",
-    });
-    return hex;
-}
-export function generateAlphaScale(base, _background) {
-    const light = {};
-    const dark = {};
-    for (const step of steps) {
-        const alpha = alphaCurve[step];
-        light[step] = mixWithAlpha(base, alpha);
-        dark[step] = mixWithAlpha(base, alpha);
-    }
-    return { light, dark };
-}

package/dist/contrast/onSolid.d.ts

@@ -1,6 +0,0 @@
-import type { ColorHex } from "../types.js";
-export declare function onSolidTextTokens(background: ColorHex): {
-    primary: ColorHex;
-    secondary: ColorHex;
-    disabled: ColorHex;
-};

package/dist/contrast/onSolid.js

@@ -1,28 +0,0 @@
-import { apcaContrast } from "./apca.js";
-const white = "#ffffff";
-const black = "#000000";
-const alphaLevels = {
-    primary: 0.92,
-    secondary: 0.72,
-    disabled: 0.48,
-};
-function withAlpha(hex, alpha) {
-    const normalized = hex.replace("#", "");
-    const alphaHex = Math.round(alpha * 255)
-        .toString(16)
-        .padStart(2, "0");
-    return `#${normalized}${alphaHex}`;
-}
-function chooseTextColor(background) {
-    const whiteScore = Math.abs(apcaContrast(white, background));
-    const blackScore = Math.abs(apcaContrast(black, background));
-    return whiteScore >= blackScore ? white : black;
-}
-export function onSolidTextTokens(background) {
-    const base = chooseTextColor(background);
-    return {
-        primary: withAlpha(base, alphaLevels.primary),
-        secondary: withAlpha(base, alphaLevels.secondary),
-        disabled: withAlpha(base, alphaLevels.disabled),
-    };
-}

package/dist/contrast/solveText.d.ts

@@ -1,2 +0,0 @@
-import type { ColorHex } from "../types.js";
-export declare function adjustTextColor(foreground: ColorHex, background: ColorHex, target: number): ColorHex;

package/dist/contrast/solveText.js

@@ -1,31 +0,0 @@
-import Color from "colorjs.io";
-import { compressToSrgb, oklchToHex } from "../engine/oklch.js";
-import { apcaContrast } from "./apca.js";
-function clamp(value, min, max) {
-    return Math.min(max, Math.max(min, value));
-}
-function adjustLightness(oklch, background, target, maxIterations = 24) {
-    const bg = new Color(background).to("oklch");
-    const bgL = bg.coords[0] ?? 0;
-    const direction = bgL > 0.5 ? -1 : 1;
-    let current = { ...oklch };
-    for (let i = 0; i < maxIterations; i += 1) {
-        const contrast = Math.abs(apcaContrast(oklchToHex(current), background));
-        if (contrast >= target) {
-            return current;
-        }
-        current = {
-            ...current,
-            l: clamp(current.l + direction * 0.02, 0, 1),
-        };
-    }
-    return current;
-}
-export function adjustTextColor(foreground, background, target) {
-    const fg = new Color(foreground).to("oklch");
-    const [l, c, h] = fg.coords;
-    let candidate = { l: l ?? 0, c: c ?? 0, h: h ?? 0 };
-    candidate = adjustLightness(candidate, background, target);
-    candidate = compressToSrgb(candidate);
-    return oklchToHex(candidate);
-}

package/dist/createTheme.d.ts

@@ -1,38 +0,0 @@
-import type { GenerateScaleOptions } from "./generateScale.js";
-import type { ColorHex, ColorSource, Theme } from "./types.js";
-export type TokenOverrides = {
-    light?: Record<string, ColorHex>;
-    dark?: Record<string, ColorHex>;
-};
-export type CreateThemeOptions = {
-    neutral: ColorSource;
-    accent: ColorSource;
-    semantic?: {
-        success?: ColorSource;
-        warning?: ColorSource;
-        danger?: ColorSource;
-    };
-    extras?: Record<string, ColorSource>;
-    tokens?: {
-        preset?: "radix-like-ui";
-        overrides?: TokenOverrides;
-    };
-    alpha?: {
-        enabled?: boolean;
-        background?: {
-            light?: ColorHex;
-            dark?: ColorHex;
-        };
-    };
-    text?: {
-        darkBase?: ColorHex;
-        lightBase?: ColorHex;
-    };
-    contrast?: {
-        textPrimary?: number;
-        textSecondary?: number;
-    };
-    scale?: Omit<GenerateScaleOptions, "source" | "mode" | "p3">;
-    p3?: boolean;
-};
-export declare function createTheme(options: CreateThemeOptions): Theme;

package/dist/createTheme.js

@@ -1,148 +0,0 @@
-import { generateAlphaScale } from "./alpha/generateAlphaScale.js";
-import { onSolidTextTokens } from "./contrast/onSolid.js";
-import { analyzeTheme } from "./diagnostics/analyzeTheme.js";
-import { generateScale } from "./generateScale.js";
-import { generateOverlayScale } from "./overlays/generateOverlayScale.js";
-import { generateTextScale } from "./text/generateTextScale.js";
-import { buildPresetTokens } from "./tokens/presetRadixLikeUi.js";
-export function createTheme(options) {
-    const includeP3 = options.p3 ?? false;
-    const scaleOptions = options.scale ?? {};
-    const scales = {
-        neutral: generateScale({ source: options.neutral, ...scaleOptions, p3: includeP3 }),
-        accent: generateScale({ source: options.accent, ...scaleOptions, p3: includeP3 }),
-    };
-    if (options.semantic?.success) {
-        scales.success = generateScale({
-            source: options.semantic.success,
-            ...scaleOptions,
-            p3: includeP3,
-        });
-    }
-    if (options.semantic?.warning) {
-        scales.warning = generateScale({
-            source: options.semantic.warning,
-            ...scaleOptions,
-            p3: includeP3,
-        });
-    }
-    if (options.semantic?.danger) {
-        scales.danger = generateScale({
-            source: options.semantic.danger,
-            ...scaleOptions,
-            p3: includeP3,
-        });
-    }
-    if (options.extras) {
-        for (const [key, source] of Object.entries(options.extras)) {
-            scales[key] = generateScale({ source, ...scaleOptions, p3: includeP3 });
-        }
-    }
-    const preset = options.tokens?.preset ?? "radix-like-ui";
-    const tokens = preset === "radix-like-ui" ? buildPresetTokens(scales) : { light: {}, dark: {} };
-    const accentScale = scales.accent;
-    const lightOnSolid = onSolidTextTokens(accentScale.light[9]);
-    const darkOnSolid = onSolidTextTokens(accentScale.dark[9]);
-    tokens.light["onSolid.primary"] = lightOnSolid.primary;
-    tokens.light["onSolid.secondary"] = lightOnSolid.secondary;
-    tokens.light["onSolid.disabled"] = lightOnSolid.disabled;
-    tokens.dark["onSolid.primary"] = darkOnSolid.primary;
-    tokens.dark["onSolid.secondary"] = darkOnSolid.secondary;
-    tokens.dark["onSolid.disabled"] = darkOnSolid.disabled;
-    const textScale = generateTextScale({
-        darkBase: options.text?.darkBase,
-        lightBase: options.text?.lightBase,
-    });
-    const darkTextSteps = {
-        primary: 12,
-        secondary: 10,
-        tertiary: 9,
-        disabled: 8,
-    };
-    const lightTextSteps = {
-        primary: 1,
-        secondary: 3,
-        tertiary: 4,
-        disabled: 5,
-    };
-    const midDarkTextSteps = {
-        primary: 12,
-        secondary: 11,
-    };
-    const midLightTextSteps = {
-        primary: 1,
-        secondary: 3,
-    };
-    const onBgLightMode = {
-        light: { scale: "dark", steps: darkTextSteps },
-        mid: { scale: "dark", steps: midDarkTextSteps },
-        dark: { scale: "light", steps: lightTextSteps },
-    };
-    const onBgDarkMode = {
-        light: { scale: "light", steps: lightTextSteps },
-        mid: { scale: "light", steps: midLightTextSteps },
-        dark: { scale: "dark", steps: darkTextSteps },
-    };
-    const applyOnBgTokens = (target, mapping) => {
-        for (const [zone, config] of Object.entries(mapping)) {
-            const scale = config.scale === "dark" ? textScale.dark : textScale.light;
-            for (const [role, step] of Object.entries(config.steps)) {
-                target[`text.onBg.${zone}.${role}`] = scale[step];
-            }
-        }
-    };
-    for (const [step, value] of Object.entries(textScale.dark)) {
-        tokens.light[`text.dark.${step}`] = value;
-        tokens.dark[`text.dark.${step}`] = value;
-    }
-    for (const [step, value] of Object.entries(textScale.light)) {
-        tokens.light[`text.light.${step}`] = value;
-        tokens.dark[`text.light.${step}`] = value;
-    }
-    for (const [key, step] of Object.entries(darkTextSteps)) {
-        const token = `text.dark.${key}`;
-        tokens.light[token] = textScale.dark[step];
-        tokens.dark[token] = textScale.dark[step];
-    }
-    for (const [key, step] of Object.entries(lightTextSteps)) {
-        const token = `text.light.${key}`;
-        tokens.light[token] = textScale.light[step];
-        tokens.dark[token] = textScale.light[step];
-    }
-    applyOnBgTokens(tokens.light, onBgLightMode);
-    applyOnBgTokens(tokens.dark, onBgDarkMode);
-    tokens.light["text.primary"] = tokens.light["text.onBg.light.primary"];
-    tokens.light["text.secondary"] = tokens.light["text.onBg.light.secondary"];
-    tokens.light["text.tertiary"] = tokens.light["text.onBg.light.tertiary"];
-    tokens.light["text.disabled"] = tokens.light["text.onBg.light.disabled"];
-    tokens.dark["text.primary"] = tokens.dark["text.onBg.light.primary"];
-    tokens.dark["text.secondary"] = tokens.dark["text.onBg.light.secondary"];
-    tokens.dark["text.tertiary"] = tokens.dark["text.onBg.light.tertiary"];
-    tokens.dark["text.disabled"] = tokens.dark["text.onBg.light.disabled"];
-    if (options.tokens?.overrides?.light) {
-        Object.assign(tokens.light, options.tokens.overrides.light);
-    }
-    if (options.tokens?.overrides?.dark) {
-        Object.assign(tokens.dark, options.tokens.overrides.dark);
-    }
-    let alpha;
-    if (options.alpha?.enabled !== false) {
-        const background = {
-            light: options.alpha?.background?.light ?? "#ffffff",
-            dark: options.alpha?.background?.dark ?? "#111111",
-        };
-        alpha = Object.fromEntries(Object.entries(scales).map(([slot, scale]) => [
-            slot,
-            generateAlphaScale(scale.light[9], background),
-        ]));
-    }
-    const overlay = generateOverlayScale();
-    const diagnostics = analyzeTheme({ scales, tokens, alpha, overlay });
-    return {
-        scales,
-        tokens,
-        alpha,
-        overlay,
-        diagnostics,
-    };
-}

package/dist/data/radixSeeds.d.ts

@@ -1,3 +0,0 @@
-import type { ColorHex, RadixSeedName } from "../types.js";
-export declare const radixSeeds: Record<RadixSeedName, ColorHex>;
-export declare const radixSeedNames: string[];

package/dist/data/radixSeeds.js

@@ -1,34 +0,0 @@
-export const radixSeeds = {
-    amber: "#ffc53d",
-    blue: "#0090ff",
-    bronze: "#a18072",
-    brown: "#ad7f58",
-    crimson: "#e93d82",
-    cyan: "#00a2c7",
-    gold: "#978365",
-    grass: "#46a758",
-    gray: "#8d8d8d",
-    green: "#30a46c",
-    indigo: "#3e63dd",
-    iris: "#5b5bd6",
-    jade: "#29a383",
-    lime: "#bdee63",
-    mauve: "#8e8c99",
-    mint: "#86ead4",
-    olive: "#898e87",
-    orange: "#f76b15",
-    pink: "#d6409f",
-    plum: "#ab4aba",
-    purple: "#8e4ec6",
-    red: "#e5484d",
-    ruby: "#e54666",
-    sage: "#868e8b",
-    sand: "#8d8d86",
-    sky: "#7ce2fe",
-    slate: "#8b8d98",
-    teal: "#12a594",
-    tomato: "#e54d2e",
-    violet: "#6e56cf",
-    yellow: "#ffe629",
-};
-export const radixSeedNames = Object.keys(radixSeeds).sort();

package/dist/diagnostics/analyzeScale.d.ts

@@ -1,2 +0,0 @@
-import type { Scale, ScaleDiagnostics } from "../types.js";
-export declare function analyzeScale(scale: Scale): ScaleDiagnostics;

package/dist/diagnostics/analyzeScale.js

@@ -1,7 +0,0 @@
-export function analyzeScale(scale) {
-    return {
-        outOfGamutCount: scale.meta?.outOfGamutCount ?? 0,
-        outOfP3GamutCount: scale.meta?.outOfP3GamutCount ?? 0,
-        anchorSteps: scale.meta?.anchorSteps,
-    };
-}

package/dist/diagnostics/analyzeTheme.d.ts

@@ -1,2 +0,0 @@
-import type { Theme, ThemeDiagnostics } from "../types.js";
-export declare function analyzeTheme(theme: Theme): ThemeDiagnostics;

package/dist/diagnostics/analyzeTheme.js

@@ -1,35 +0,0 @@
-import { apcaContrast } from "../contrast/apca.js";
-import { analyzeWarnings } from "./warnings.js";
-export function analyzeTheme(theme) {
-    const contrast = {};
-    const lightBg = theme.tokens.light["bg.app"];
-    const darkBg = theme.tokens.dark["bg.app"];
-    if (lightBg) {
-        if (theme.tokens.light["text.primary"]) {
-            contrast["light.text.primary"] = apcaContrast(theme.tokens.light["text.primary"], lightBg);
-        }
-        if (theme.tokens.light["text.secondary"]) {
-            contrast["light.text.secondary"] = apcaContrast(theme.tokens.light["text.secondary"], lightBg);
-        }
-    }
-    if (darkBg) {
-        if (theme.tokens.dark["text.primary"]) {
-            contrast["dark.text.primary"] = apcaContrast(theme.tokens.dark["text.primary"], darkBg);
-        }
-        if (theme.tokens.dark["text.secondary"]) {
-            contrast["dark.text.secondary"] = apcaContrast(theme.tokens.dark["text.secondary"], darkBg);
-        }
-    }
-    if (theme.tokens.light["onSolid.primary"] && theme.tokens.light["accent.solid"]) {
-        contrast["light.onSolid.primary"] = apcaContrast(theme.tokens.light["onSolid.primary"], theme.tokens.light["accent.solid"]);
-    }
-    if (theme.tokens.dark["onSolid.primary"] && theme.tokens.dark["accent.solid"]) {
-        contrast["dark.onSolid.primary"] = apcaContrast(theme.tokens.dark["onSolid.primary"], theme.tokens.dark["accent.solid"]);
-    }
-    let outOfGamutCount = 0;
-    for (const scale of Object.values(theme.scales)) {
-        outOfGamutCount += scale.meta?.outOfGamutCount ?? 0;
-    }
-    const warnings = analyzeWarnings(theme);
-    return { contrast, outOfGamutCount, warnings };
-}

package/dist/diagnostics/warnings.d.ts

@@ -1,2 +0,0 @@
-import type { Theme } from "../types.js";
-export declare function analyzeWarnings(theme: Theme): string[];

package/dist/diagnostics/warnings.js

@@ -1,20 +0,0 @@
-import Color from "colorjs.io";
-export function analyzeWarnings(theme) {
-    const warnings = [];
-    const accent = theme.scales.accent?.light?.[9];
-    if (accent) {
-        const { coords } = new Color(accent).to("oklch");
-        const l = coords[0] ?? 0;
-        const c = coords[1] ?? 0;
-        if (c < 0.03) {
-            warnings.push("Accent seed has very low chroma; the palette may look gray.");
-        }
-        if (l < 0.2) {
-            warnings.push("Accent seed is very dark; light mode solids may lack contrast.");
-        }
-        if (l > 0.9) {
-            warnings.push("Accent seed is very light; dark mode solids may lack contrast.");
-        }
-    }
-    return warnings;
-}

package/dist/engine/curves.d.ts

@@ -1,9 +0,0 @@
-import type { Step } from "../types.js";
-export type CurveConfig = {
-    lightness?: Partial<Record<Step, number>>;
-    chroma?: Partial<Record<Step, number>>;
-};
-export declare function resolveCurves(curves?: CurveConfig): {
-    lightness: Record<Step, number>;
-    chroma: Record<Step, number>;
-};

package/dist/engine/curves.js

@@ -1,48 +0,0 @@
-const steps = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
-const defaultLightness = {
-    1: 0.3,
-    2: 0.3,
-    3: 0.6,
-    4: 0.6,
-    5: 0.6,
-    6: 0.85,
-    7: 0.85,
-    8: 0.85,
-    9: 1,
-    10: 1,
-    11: 1,
-    12: 1,
-};
-const defaultChroma = {
-    1: 0.2,
-    2: 0.2,
-    3: 0.6,
-    4: 0.6,
-    5: 0.6,
-    6: 0.8,
-    7: 0.8,
-    8: 0.8,
-    9: 1,
-    10: 1,
-    11: 0.7,
-    12: 0.7,
-};
-export function resolveCurves(curves) {
-    const lightness = { ...defaultLightness };
-    const chroma = { ...defaultChroma };
-    if (curves?.lightness) {
-        for (const step of steps) {
-            if (curves.lightness[step] !== undefined) {
-                lightness[step] = curves.lightness[step];
-            }
-        }
-    }
-    if (curves?.chroma) {
-        for (const step of steps) {
-            if (curves.chroma[step] !== undefined) {
-                chroma[step] = curves.chroma[step];
-            }
-        }
-    }
-    return { lightness, chroma };
-}