@ariaui/color 0.1.3 → 0.1.4

package/dist/tokens.cjs

@@ -0,0 +1,572 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// tokens.ts
+var tokens_exports = {};
+__export(tokens_exports, {
+  adjustHue: () => adjustHue,
+  complement: () => complement,
+  contrastRatio: () => contrastRatio,
+  darken: () => darken,
+  desaturate: () => desaturate,
+  grayscale: () => grayscale,
+  hexToOklch: () => hexToOklch,
+  invert: () => invert,
+  lighten: () => lighten,
+  listColorTokens: () => listColorTokens,
+  meetsAA: () => meetsAA,
+  meetsAAA: () => meetsAAA,
+  mix: () => mix,
+  oklabToOklch: () => oklabToOklch,
+  oklchToHex: () => oklchToHex,
+  oklchToOklab: () => oklchToOklab,
+  oklchToSrgb: () => oklchToSrgb,
+  parseHex: () => parseHex,
+  parseOklchChannels: () => parseOklchChannels,
+  parseOklchCss: () => parseOklchCss,
+  parseRgb: () => parseRgb,
+  resolveAllPrimitives: () => resolveAllPrimitives,
+  resolveAllSemantics: () => resolveAllSemantics,
+  resolveBase: () => resolveBase,
+  resolvePrimitive: () => resolvePrimitive,
+  resolveScale: () => resolveScale,
+  resolveSemantic: () => resolveSemantic,
+  saturate: () => saturate,
+  setAlpha: () => setAlpha,
+  srgbToHex: () => srgbToHex,
+  srgbToOklch: () => srgbToOklch,
+  suggestAccessible: () => suggestAccessible,
+  toCssChannels: () => toCssChannels,
+  toHexString: () => toHexString,
+  toOklchString: () => toOklchString,
+  toRgbString: () => toRgbString
+});
+module.exports = __toCommonJS(tokens_exports);
+
+// src/parse.ts
+function parseOklchChannels(channels) {
+  const normalised = channels.trim();
+  const [colorPart, alphaPart] = normalised.split("/").map((s) => s.trim());
+  const parts = colorPart.split(/\s+/);
+  if (parts.length !== 3) {
+    throw new Error(
+      `Invalid OKLCH channel string: expected "L C H", got "${channels}"`
+    );
+  }
+  const [rawL, rawC, rawH] = parts;
+  let l;
+  if (rawL.endsWith("%")) {
+    l = parseFloat(rawL) / 100;
+  } else {
+    l = parseFloat(rawL);
+  }
+  const c = parseFloat(rawC);
+  const h = parseFloat(rawH);
+  if (Number.isNaN(l) || Number.isNaN(c) || Number.isNaN(h)) {
+    throw new Error(
+      `Invalid OKLCH channel string: could not parse numbers from "${channels}"`
+    );
+  }
+  let alpha = 1;
+  if (alphaPart !== void 0) {
+    alpha = parseFloat(alphaPart);
+    if (Number.isNaN(alpha)) {
+      throw new Error(
+        `Invalid OKLCH alpha value: could not parse "${alphaPart}"`
+      );
+    }
+  }
+  return { l, c, h, alpha };
+}
+function parseOklchCss(css) {
+  const match = css.match(/oklch\(\s*(.+?)\s*\)/i);
+  if (!match) {
+    throw new Error(`Invalid oklch() CSS string: "${css}"`);
+  }
+  return parseOklchChannels(match[1]);
+}
+function parseHex(hex) {
+  let h = hex.startsWith("#") ? hex.slice(1) : hex;
+  if (h.length === 3) {
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+  } else if (h.length === 4) {
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2] + h[3] + h[3];
+  }
+  if (h.length !== 6 && h.length !== 8) {
+    throw new Error(`Invalid hex color: "${hex}"`);
+  }
+  if (!/^[0-9a-fA-F]+$/.test(h)) {
+    throw new Error(`Invalid hex color: "${hex}"`);
+  }
+  const r = parseInt(h.slice(0, 2), 16) / 255;
+  const g = parseInt(h.slice(2, 4), 16) / 255;
+  const b = parseInt(h.slice(4, 6), 16) / 255;
+  const alpha = h.length === 8 ? parseInt(h.slice(6, 8), 16) / 255 : 1;
+  return { r, g, b, alpha };
+}
+function parseRgb(css) {
+  const match = css.match(/rgba?\(\s*(.+?)\s*\)/i);
+  if (!match) {
+    throw new Error(`Invalid rgb()/rgba() CSS string: "${css}"`);
+  }
+  const inner = match[1];
+  if (inner.includes("/")) {
+    const [colorPart, alphaPart] = inner.split("/").map((s) => s.trim());
+    const [r, g, b] = colorPart.split(/\s+/).map(Number);
+    const alpha = parseFloat(alphaPart);
+    return { r: r / 255, g: g / 255, b: b / 255, alpha };
+  }
+  if (inner.includes(",")) {
+    const parts2 = inner.split(",").map((s) => parseFloat(s.trim()));
+    return {
+      r: parts2[0] / 255,
+      g: parts2[1] / 255,
+      b: parts2[2] / 255,
+      alpha: parts2.length === 4 ? parts2[3] : 1
+    };
+  }
+  const parts = inner.split(/\s+/).map(Number);
+  if (parts.length !== 3) {
+    throw new Error(`Invalid rgb() CSS string: "${css}"`);
+  }
+  return { r: parts[0] / 255, g: parts[1] / 255, b: parts[2] / 255, alpha: 1 };
+}
+
+// src/convert.ts
+function oklchToOklab(c) {
+  const hRad = c.h * Math.PI / 180;
+  return {
+    L: c.l,
+    a: c.c * Math.cos(hRad),
+    b: c.c * Math.sin(hRad),
+    alpha: c.alpha
+  };
+}
+function oklabToOklch(lab) {
+  const c = Math.sqrt(lab.a * lab.a + lab.b * lab.b);
+  let h = Math.atan2(lab.b, lab.a) * 180 / Math.PI;
+  if (h < 0) h += 360;
+  if (c < 1e-8) h = 0;
+  return { l: lab.L, c, h, alpha: lab.alpha };
+}
+function oklabToLinearSrgb(lab) {
+  const l_ = lab.L + 0.3963377774 * lab.a + 0.2158037573 * lab.b;
+  const m_ = lab.L - 0.1055613458 * lab.a - 0.0638541728 * lab.b;
+  const s_ = lab.L - 0.0894841775 * lab.a - 1.291485548 * lab.b;
+  const l = l_ * l_ * l_;
+  const m = m_ * m_ * m_;
+  const s = s_ * s_ * s_;
+  const r = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+  const g = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+  const b = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+  return [r, g, b];
+}
+function linearSrgbToOklab(r, g, b) {
+  const l = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+  const m = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+  const s = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+  const l_ = Math.cbrt(l);
+  const m_ = Math.cbrt(m);
+  const s_ = Math.cbrt(s);
+  return {
+    L: 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,
+    a: 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,
+    b: 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_,
+    alpha: 1
+  };
+}
+function linearToGamma(c) {
+  if (c <= 31308e-7) return 12.92 * c;
+  return 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+}
+function gammaToLinear(c) {
+  if (c <= 0.04045) return c / 12.92;
+  return Math.pow((c + 0.055) / 1.055, 2.4);
+}
+var GAMUT_EPSILON = 1e-6;
+var DELTA_E_TOLERANCE = 0.02;
+var CHROMA_STEP = 0.01;
+function deltaEOK(a, b) {
+  const dL = a.L - b.L;
+  const da = a.a - b.a;
+  const db = a.b - b.b;
+  return Math.sqrt(dL * dL + da * da + db * db);
+}
+function isInGamut(r, g, b) {
+  return r >= -GAMUT_EPSILON && r <= 1 + GAMUT_EPSILON && g >= -GAMUT_EPSILON && g <= 1 + GAMUT_EPSILON && b >= -GAMUT_EPSILON && b <= 1 + GAMUT_EPSILON;
+}
+function clampChannel(v) {
+  return Math.max(0, Math.min(1, v));
+}
+function gamutMapOklchToSrgb(color) {
+  if (color.l <= 0) return { r: 0, g: 0, b: 0, alpha: color.alpha };
+  if (color.l >= 1) return { r: 1, g: 1, b: 1, alpha: color.alpha };
+  const lab = oklchToOklab(color);
+  const [lr, lg, lb] = oklabToLinearSrgb(lab);
+  if (isInGamut(lr, lg, lb)) {
+    return {
+      r: linearToGamma(clampChannel(lr)),
+      g: linearToGamma(clampChannel(lg)),
+      b: linearToGamma(clampChannel(lb)),
+      alpha: color.alpha
+    };
+  }
+  let min = 0;
+  let max = color.c;
+  let mappedChroma = 0;
+  const zeroChromaLab = oklchToOklab(__spreadProps(__spreadValues({}, color), { c: 0 }));
+  const [zr, zg, zb] = oklabToLinearSrgb(zeroChromaLab);
+  if (!isInGamut(zr, zg, zb)) {
+    return {
+      r: linearToGamma(clampChannel(zr)),
+      g: linearToGamma(clampChannel(zg)),
+      b: linearToGamma(clampChannel(zb)),
+      alpha: color.alpha
+    };
+  }
+  while (max - min > CHROMA_STEP) {
+    const mid = (min + max) / 2;
+    const testColor = __spreadProps(__spreadValues({}, color), { c: mid });
+    const testLab = oklchToOklab(testColor);
+    const [tr, tg, tb] = oklabToLinearSrgb(testLab);
+    if (isInGamut(tr, tg, tb)) {
+      min = mid;
+      mappedChroma = mid;
+    } else {
+      const clampedR = clampChannel(tr);
+      const clampedG = clampChannel(tg);
+      const clampedB = clampChannel(tb);
+      const clampedLab = linearSrgbToOklab(clampedR, clampedG, clampedB);
+      const dE = deltaEOK(testLab, clampedLab);
+      if (dE <= DELTA_E_TOLERANCE) {
+        min = mid;
+        mappedChroma = mid;
+      } else {
+        max = mid;
+      }
+    }
+  }
+  const finalLab = oklchToOklab(__spreadProps(__spreadValues({}, color), { c: mappedChroma }));
+  const [fr, fg, fb] = oklabToLinearSrgb(finalLab);
+  return {
+    r: linearToGamma(clampChannel(fr)),
+    g: linearToGamma(clampChannel(fg)),
+    b: linearToGamma(clampChannel(fb)),
+    alpha: color.alpha
+  };
+}
+function oklchToSrgb(color) {
+  return gamutMapOklchToSrgb(color);
+}
+function srgbToOklch(color) {
+  const lr = gammaToLinear(color.r);
+  const lg = gammaToLinear(color.g);
+  const lb = gammaToLinear(color.b);
+  const lab = linearSrgbToOklab(lr, lg, lb);
+  return __spreadValues({}, oklabToOklch(__spreadProps(__spreadValues({}, lab), { alpha: color.alpha })));
+}
+function srgbToHex(color) {
+  const r = Math.round(clampChannel(color.r) * 255);
+  const g = Math.round(clampChannel(color.g) * 255);
+  const b = Math.round(clampChannel(color.b) * 255);
+  const hex = `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  if (color.alpha < 1) {
+    const a = Math.round(clampChannel(color.alpha) * 255);
+    return `${hex}${a.toString(16).padStart(2, "0")}`;
+  }
+  return hex;
+}
+function oklchToHex(color) {
+  return srgbToHex(oklchToSrgb(color));
+}
+function hexToOklch(hex) {
+  return srgbToOklch(parseHex(hex));
+}
+
+// src/manipulate.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function normaliseHue(h) {
+  return (h % 360 + 360) % 360;
+}
+function lighten(color, amount) {
+  return __spreadProps(__spreadValues({}, color), { l: clamp(color.l + amount, 0, 1) });
+}
+function darken(color, amount) {
+  return __spreadProps(__spreadValues({}, color), { l: clamp(color.l - amount, 0, 1) });
+}
+function saturate(color, amount) {
+  return __spreadProps(__spreadValues({}, color), { c: Math.max(0, color.c + amount) });
+}
+function desaturate(color, amount) {
+  return __spreadProps(__spreadValues({}, color), { c: Math.max(0, color.c - amount) });
+}
+function setAlpha(color, alpha) {
+  return __spreadProps(__spreadValues({}, color), { alpha: clamp(alpha, 0, 1) });
+}
+function adjustHue(color, degrees) {
+  return __spreadProps(__spreadValues({}, color), { h: normaliseHue(color.h + degrees) });
+}
+function mix(color1, color2, ratio = 0.5) {
+  const t = clamp(ratio, 0, 1);
+  const l = color1.l + (color2.l - color1.l) * t;
+  const c = color1.c + (color2.c - color1.c) * t;
+  const alpha = color1.alpha + (color2.alpha - color1.alpha) * t;
+  let h1 = normaliseHue(color1.h);
+  let h2 = normaliseHue(color2.h);
+  let dh = h2 - h1;
+  if (dh > 180) dh -= 360;
+  if (dh < -180) dh += 360;
+  const h = normaliseHue(h1 + dh * t);
+  return { l, c, h, alpha };
+}
+function complement(color) {
+  return adjustHue(color, 180);
+}
+function invert(color) {
+  return __spreadProps(__spreadValues({}, color), { l: 1 - color.l });
+}
+function grayscale(color) {
+  return __spreadProps(__spreadValues({}, color), { c: 0, h: 0 });
+}
+
+// src/contrast.ts
+function relativeLuminance(color) {
+  const toLinear = (c) => c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  const r = toLinear(color.r);
+  const g = toLinear(color.g);
+  const b = toLinear(color.b);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contrastRatio(fg, bg) {
+  const fgSrgb = "l" in fg ? oklchToSrgb(fg) : fg;
+  const bgSrgb = "l" in bg ? oklchToSrgb(bg) : bg;
+  const l1 = relativeLuminance(fgSrgb);
+  const l2 = relativeLuminance(bgSrgb);
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function meetsAA(fg, bg, size = "normal") {
+  const ratio = contrastRatio(fg, bg);
+  return size === "large" ? ratio >= 3 : ratio >= 4.5;
+}
+function meetsAAA(fg, bg, size = "normal") {
+  const ratio = contrastRatio(fg, bg);
+  return size === "large" ? ratio >= 4.5 : ratio >= 7;
+}
+function suggestAccessible(fg, bg, target = "AA", size = "normal") {
+  const checker = target === "AAA" ? meetsAAA : meetsAA;
+  if (checker(fg, bg, size)) return fg;
+  const bgSrgb = "l" in bg ? oklchToSrgb(bg) : bg;
+  const bgLum = relativeLuminance(bgSrgb);
+  const directions = bgLum > 0.5 ? [(l, s) => l - s, (l, s) => l + s] : [(l, s) => l + s, (l, s) => l - s];
+  const step = 5e-3;
+  for (const adjust of directions) {
+    let testL = fg.l;
+    for (let i = 0; i < 220; i++) {
+      testL = adjust(testL, step);
+      if (testL < 0 || testL > 1) break;
+      testL = Math.max(0, Math.min(1, testL));
+      const candidate = __spreadProps(__spreadValues({}, fg), { l: testL });
+      if (checker(candidate, bg, size)) {
+        return candidate;
+      }
+    }
+  }
+  const blackRatio = contrastRatio({ l: 0, c: 0, h: 0, alpha: 1 }, bg);
+  const whiteRatio = contrastRatio({ l: 1, c: 0, h: 0, alpha: 1 }, bg);
+  return blackRatio > whiteRatio ? __spreadProps(__spreadValues({}, fg), { l: 0, c: 0 }) : __spreadProps(__spreadValues({}, fg), { l: 1, c: 0 });
+}
+
+// src/format.ts
+function toOklchString(color) {
+  const l = `${roundTo(color.l * 100, 2)}%`;
+  const c = roundTo(color.c, 4);
+  const h = roundTo(color.h, 2);
+  if (color.alpha < 1) {
+    return `oklch(${l} ${c} ${h} / ${roundTo(color.alpha, 3)})`;
+  }
+  return `oklch(${l} ${c} ${h})`;
+}
+function toRgbString(color) {
+  const r = Math.round(clamp01(color.r) * 255);
+  const g = Math.round(clamp01(color.g) * 255);
+  const b = Math.round(clamp01(color.b) * 255);
+  if (color.alpha < 1) {
+    return `rgb(${r} ${g} ${b} / ${roundTo(color.alpha, 3)})`;
+  }
+  return `rgb(${r} ${g} ${b})`;
+}
+function toHexString(color) {
+  const srgb = "l" in color ? oklchToSrgb(color) : color;
+  return srgbToHex(srgb);
+}
+function toCssChannels(color) {
+  const l = `${roundTo(color.l * 100, 2)}%`;
+  const c = roundTo(color.c, 4);
+  const h = roundTo(color.h, 2);
+  return `${l} ${c} ${h}`;
+}
+function roundTo(value, decimals) {
+  const factor = Math.pow(10, decimals);
+  return Math.round(value * factor) / factor;
+}
+function clamp01(v) {
+  return Math.max(0, Math.min(1, v));
+}
+
+// src/palette.ts
+var import_tokens = require("@ariaui/tokens");
+function resolvePrimitive(scale, step) {
+  const scaleObj = import_tokens.primitives[scale];
+  const channels = scaleObj[step];
+  if (channels === void 0) {
+    throw new Error(
+      `Primitive not found: ${String(scale)}-${step}`
+    );
+  }
+  return parseOklchChannels(channels);
+}
+function resolveScale(scale) {
+  const scaleObj = import_tokens.primitives[scale];
+  const result = {};
+  for (const [key, value] of Object.entries(scaleObj)) {
+    result[Number(key)] = parseOklchChannels(value);
+  }
+  return result;
+}
+function resolveAllPrimitives() {
+  const result = {};
+  for (const scale of Object.keys(import_tokens.primitives)) {
+    result[scale] = resolveScale(scale);
+  }
+  return result;
+}
+function resolveBase(name) {
+  const channels = import_tokens.base[name];
+  if (!channels) {
+    throw new Error(`Base color not found: "${name}"`);
+  }
+  return parseOklchChannels(channels);
+}
+
+// src/resolve.ts
+var import_tokens2 = require("@ariaui/tokens");
+function resolveVarToChannels(value) {
+  const varMatch = value.match(/^var\(--color-(.+)\)$/);
+  if (!varMatch) return null;
+  const ref = varMatch[1];
+  if (ref in import_tokens2.base) {
+    return import_tokens2.base[ref];
+  }
+  const lastDash = ref.lastIndexOf("-");
+  if (lastDash === -1) return null;
+  const scale = ref.slice(0, lastDash);
+  const stepStr = ref.slice(lastDash + 1);
+  const step = parseInt(stepStr, 10);
+  if (Number.isNaN(step)) return null;
+  const scaleObj = import_tokens2.primitives[scale];
+  if (!scaleObj) return null;
+  const channels = scaleObj[step];
+  if (channels === void 0) return null;
+  return channels;
+}
+function resolveSemantic(tokenKey, mode = "light") {
+  var _a;
+  const map = mode === "dark" ? import_tokens2.dark : import_tokens2.light;
+  const value = (_a = map[tokenKey]) != null ? _a : import_tokens2.light[tokenKey];
+  if (value === void 0) return null;
+  const channels = resolveVarToChannels(value);
+  if (channels === null) return null;
+  return parseOklchChannels(channels);
+}
+function listColorTokens(mode = "light") {
+  const map = mode === "dark" ? __spreadValues(__spreadValues({}, import_tokens2.light), import_tokens2.dark) : import_tokens2.light;
+  return Object.keys(map).filter((key) => {
+    const value = map[key];
+    return resolveVarToChannels(value) !== null;
+  });
+}
+function resolveAllSemantics(mode = "light") {
+  const keys = listColorTokens(mode);
+  const result = {};
+  for (const key of keys) {
+    const color = resolveSemantic(key, mode);
+    if (color) result[key] = color;
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  adjustHue,
+  complement,
+  contrastRatio,
+  darken,
+  desaturate,
+  grayscale,
+  hexToOklch,
+  invert,
+  lighten,
+  listColorTokens,
+  meetsAA,
+  meetsAAA,
+  mix,
+  oklabToOklch,
+  oklchToHex,
+  oklchToOklab,
+  oklchToSrgb,
+  parseHex,
+  parseOklchChannels,
+  parseOklchCss,
+  parseRgb,
+  resolveAllPrimitives,
+  resolveAllSemantics,
+  resolveBase,
+  resolvePrimitive,
+  resolveScale,
+  resolveSemantic,
+  saturate,
+  setAlpha,
+  srgbToHex,
+  srgbToOklch,
+  suggestAccessible,
+  toCssChannels,
+  toHexString,
+  toOklchString,
+  toRgbString
+});

package/dist/tokens.d.cts

@@ -0,0 +1,59 @@
+import { OklchColor, ColorMode } from './index.cjs';
+export { HexString, OklabColor, SrgbColor, adjustHue, complement, contrastRatio, darken, desaturate, grayscale, hexToOklch, invert, lighten, meetsAA, meetsAAA, mix, oklabToOklch, oklchToHex, oklchToOklab, oklchToSrgb, parseHex, parseOklchChannels, parseOklchCss, parseRgb, saturate, setAlpha, srgbToHex, srgbToOklch, suggestAccessible, toCssChannels, toHexString, toOklchString, toRgbString } from './index.cjs';
+import { PrimitiveScale } from '@ariaui/tokens';
+
+/** Scale names available in primitives. */
+type ScaleName = keyof PrimitiveScale;
+/** Step numbers in a typical 50–950 scale. */
+type Step = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;
+/**
+ * Resolve a single primitive to an OklchColor.
+ *
+ * @example resolvePrimitive("brand", 600)
+ *          → { l: 0.541, c: 0.247, h: 293, alpha: 1 }
+ */
+declare function resolvePrimitive(scale: ScaleName, step: Step): OklchColor;
+/**
+ * Resolve an entire scale to a Record of OklchColors.
+ *
+ * @example resolveScale("brand")
+ *          → { 50: OklchColor, 100: OklchColor, ... }
+ */
+declare function resolveScale(scale: ScaleName): Record<Step, OklchColor>;
+/**
+ * Resolve all primitives into structured color objects.
+ */
+declare function resolveAllPrimitives(): Record<ScaleName, Record<Step, OklchColor>>;
+/**
+ * Resolve a base color ("white" or "black") to an OklchColor.
+ */
+declare function resolveBase(name: "white" | "black"): OklchColor;
+
+/**
+ * Resolve a semantic token key to a concrete OklchColor.
+ *
+ * Only resolves **color** tokens (those whose values are `var(--color-*)`)
+ * — not gradients, px values, or composite tokens.
+ *
+ * @param tokenKey - Semantic token key, e.g. "bg-brand-solid", "text-primary"
+ * @param mode     - "light" or "dark"
+ * @returns OklchColor, or `null` if the token is not a resolvable color.
+ *
+ * @example
+ * resolveSemantic("bg-brand-solid", "light")
+ * // → { l: 0.541, c: 0.247, h: 293, alpha: 1 }  (brand-600)
+ *
+ * resolveSemantic("bg-brand-solid", "dark")
+ * // → { l: 0.709, c: 0.159, h: 294, alpha: 1 }  (brand-400)
+ */
+declare function resolveSemantic(tokenKey: string, mode?: ColorMode): OklchColor | null;
+/**
+ * List all semantic token keys that are resolvable to colors.
+ */
+declare function listColorTokens(mode?: ColorMode): string[];
+/**
+ * Resolve all color semantic tokens for a given mode.
+ */
+declare function resolveAllSemantics(mode?: ColorMode): Record<string, OklchColor>;
+
+export { ColorMode, OklchColor, type ScaleName, type Step, listColorTokens, resolveAllPrimitives, resolveAllSemantics, resolveBase, resolvePrimitive, resolveScale, resolveSemantic };

package/dist/tokens.d.ts

@@ -0,0 +1,59 @@
+import { OklchColor, ColorMode } from './index.js';
+export { HexString, OklabColor, SrgbColor, adjustHue, complement, contrastRatio, darken, desaturate, grayscale, hexToOklch, invert, lighten, meetsAA, meetsAAA, mix, oklabToOklch, oklchToHex, oklchToOklab, oklchToSrgb, parseHex, parseOklchChannels, parseOklchCss, parseRgb, saturate, setAlpha, srgbToHex, srgbToOklch, suggestAccessible, toCssChannels, toHexString, toOklchString, toRgbString } from './index.js';
+import { PrimitiveScale } from '@ariaui/tokens';
+
+/** Scale names available in primitives. */
+type ScaleName = keyof PrimitiveScale;
+/** Step numbers in a typical 50–950 scale. */
+type Step = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;
+/**
+ * Resolve a single primitive to an OklchColor.
+ *
+ * @example resolvePrimitive("brand", 600)
+ *          → { l: 0.541, c: 0.247, h: 293, alpha: 1 }
+ */
+declare function resolvePrimitive(scale: ScaleName, step: Step): OklchColor;
+/**
+ * Resolve an entire scale to a Record of OklchColors.
+ *
+ * @example resolveScale("brand")
+ *          → { 50: OklchColor, 100: OklchColor, ... }
+ */
+declare function resolveScale(scale: ScaleName): Record<Step, OklchColor>;
+/**
+ * Resolve all primitives into structured color objects.
+ */
+declare function resolveAllPrimitives(): Record<ScaleName, Record<Step, OklchColor>>;
+/**
+ * Resolve a base color ("white" or "black") to an OklchColor.
+ */
+declare function resolveBase(name: "white" | "black"): OklchColor;
+
+/**
+ * Resolve a semantic token key to a concrete OklchColor.
+ *
+ * Only resolves **color** tokens (those whose values are `var(--color-*)`)
+ * — not gradients, px values, or composite tokens.
+ *
+ * @param tokenKey - Semantic token key, e.g. "bg-brand-solid", "text-primary"
+ * @param mode     - "light" or "dark"
+ * @returns OklchColor, or `null` if the token is not a resolvable color.
+ *
+ * @example
+ * resolveSemantic("bg-brand-solid", "light")
+ * // → { l: 0.541, c: 0.247, h: 293, alpha: 1 }  (brand-600)
+ *
+ * resolveSemantic("bg-brand-solid", "dark")
+ * // → { l: 0.709, c: 0.159, h: 294, alpha: 1 }  (brand-400)
+ */
+declare function resolveSemantic(tokenKey: string, mode?: ColorMode): OklchColor | null;
+/**
+ * List all semantic token keys that are resolvable to colors.
+ */
+declare function listColorTokens(mode?: ColorMode): string[];
+/**
+ * Resolve all color semantic tokens for a given mode.
+ */
+declare function resolveAllSemantics(mode?: ColorMode): Record<string, OklchColor>;
+
+export { ColorMode, OklchColor, type ScaleName, type Step, listColorTokens, resolveAllPrimitives, resolveAllSemantics, resolveBase, resolvePrimitive, resolveScale, resolveSemantic };