@motion-proto/live-tokens 0.47.0 → 0.48.0

package/dist-plugin/chunk-76TFDTJO.js

@@ -0,0 +1,556 @@
+// src/editor/core/storage/files/versionedFileResourceClient.ts
+function sanitizeFileName(name) {
+  return name.toLowerCase().trim().replace(/\s+/g, "-").replace(/[^a-z0-9\-_]/g, "").replace(/-+/g, "-").replace(/^[-_]+|-+$/g, "") || "unnamed";
+}
+
+// src/editor/core/palettes/oklch.ts
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function linearToSrgb(c) {
+  return c <= 31308e-7 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+}
+function hexToLinearRgb(hex) {
+  const r = parseInt(hex.slice(1, 3), 16) / 255;
+  const g = parseInt(hex.slice(3, 5), 16) / 255;
+  const b = parseInt(hex.slice(5, 7), 16) / 255;
+  return [srgbToLinear(r), srgbToLinear(g), srgbToLinear(b)];
+}
+function linearRgbToHex(r, g, b) {
+  const toHex = (c) => {
+    const v = Math.round(Math.max(0, Math.min(1, linearToSrgb(c))) * 255);
+    return v.toString(16).padStart(2, "0");
+  };
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function linearRgbToOklab(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 [
+    0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  ];
+}
+function oklabToLinearRgb(L, a, b) {
+  const l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+  const m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+  const s_ = L - 0.0894841775 * a - 1.291485548 * b;
+  const l = l_ * l_ * l_;
+  const m = m_ * m_ * m_;
+  const s = s_ * s_ * s_;
+  return [
+    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  ];
+}
+function oklabToOklch(L, a, b) {
+  const c = Math.sqrt(a * a + b * b);
+  let h = Math.atan2(b, a) * 180 / Math.PI;
+  if (h < 0) h += 360;
+  return { l: L, c, h };
+}
+function oklchToOklab(l, c, h) {
+  const hRad = h * Math.PI / 180;
+  return [l, c * Math.cos(hRad), c * Math.sin(hRad)];
+}
+function hexToOklch(hex) {
+  const [r, g, b] = hexToLinearRgb(hex);
+  const [L, a, bVal] = linearRgbToOklab(r, g, b);
+  return oklabToOklch(L, a, bVal);
+}
+function oklchToHex(l, c, h) {
+  const [L, a, b] = oklchToOklab(l, c, h);
+  const [r, g, bVal] = oklabToLinearRgb(L, a, b);
+  return linearRgbToHex(r, g, bVal);
+}
+function isInGamut(r, g, b) {
+  const eps = 1e-4;
+  return r >= -eps && r <= 1 + eps && g >= -eps && g <= 1 + eps && b >= -eps && b <= 1 + eps;
+}
+function oklchToHexClamped(l, c, h) {
+  const g = gamutClamp(l, c, h);
+  return oklchToHex(g.l, g.c, g.h);
+}
+function gamutClamp(l, c, h) {
+  if (l <= 0) return { l: 0, c: 0, h };
+  if (l >= 1) return { l: 1, c: 0, h };
+  const [L, a, b] = oklchToOklab(l, c, h);
+  const [r, g, bVal] = oklabToLinearRgb(L, a, b);
+  if (isInGamut(r, g, bVal)) return { l, c, h };
+  let lo = 0;
+  let hi = c;
+  for (let i = 0; i < 20; i++) {
+    const mid = (lo + hi) / 2;
+    const [La, aa, ba] = oklchToOklab(l, mid, h);
+    const [rr, gg, bb] = oklabToLinearRgb(La, aa, ba);
+    if (isInGamut(rr, gg, bb)) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  return { l, c: lo, h };
+}
+
+// src/editor/ui/curveEngine.ts
+function makeAnchor(x, y, tangentLen = 15) {
+  return { x, y, inDx: -tangentLen, inDy: 0, outDx: tangentLen, outDy: 0 };
+}
+var HANDLE_SPAN = 1 / 3;
+function tangentSlope(prev, x, y, next) {
+  const hPrev = prev ? x - prev.x : 0;
+  const hNext = next ? next.x - x : 0;
+  const dPrev = hPrev > 0 ? (y - prev.y) / hPrev : null;
+  const dNext = hNext > 0 ? (next.y - y) / hNext : null;
+  if (dPrev === null) return dNext ?? 0;
+  if (dNext === null) return dPrev;
+  if (dPrev * dNext <= 0) return 0;
+  const wPrev = 2 * hNext + hPrev;
+  const wNext = hNext + 2 * hPrev;
+  return (wPrev + wNext) / (wPrev / dPrev + wNext / dNext);
+}
+function tangentAnchor(x, y, prev, next) {
+  const m = tangentSlope(prev, x, y, next);
+  const inDx = prev ? -(x - prev.x) * HANDLE_SPAN : 0;
+  const outDx = next ? (next.x - x) * HANDLE_SPAN : 0;
+  return { x, y, inDx, inDy: m * inDx, outDx, outDy: m * outDx };
+}
+function evalBezier(p0x, p0y, c0x, c0y, c1x, c1y, p1x, p1y, t) {
+  const u = 1 - t, u2 = u * u, u3 = u2 * u;
+  const t2 = t * t, t3 = t2 * t;
+  return {
+    x: u3 * p0x + 3 * u2 * t * c0x + 3 * u * t2 * c1x + t3 * p1x,
+    y: u3 * p0y + 3 * u2 * t * c0y + 3 * u * t2 * c1y + t3 * p1y
+  };
+}
+function sampleCurve(anchors, xPos) {
+  if (anchors.length === 0) return 0;
+  if (anchors.length === 1) return anchors[0].y;
+  if (xPos <= anchors[0].x) return anchors[0].y;
+  if (xPos >= anchors[anchors.length - 1].x) return anchors[anchors.length - 1].y;
+  let seg = 0;
+  while (seg < anchors.length - 2 && anchors[seg + 1].x < xPos) seg++;
+  const a0 = anchors[seg], a1 = anchors[seg + 1];
+  const p0x = a0.x, p0y = a0.y;
+  const c0x = a0.x + a0.outDx, c0y = a0.y + a0.outDy;
+  const c1x = a1.x + a1.inDx, c1y = a1.y + a1.inDy;
+  const p1x = a1.x, p1y = a1.y;
+  let lo = 0, hi = 1;
+  for (let i = 0; i < 20; i++) {
+    const mid = (lo + hi) / 2;
+    const pt = evalBezier(p0x, p0y, c0x, c0y, c1x, c1y, p1x, p1y, mid);
+    if (pt.x < xPos) lo = mid;
+    else hi = mid;
+  }
+  return evalBezier(p0x, p0y, c0x, c0y, c1x, c1y, p1x, p1y, (lo + hi) / 2).y;
+}
+
+// src/editor/core/palettes/paletteDerivation.ts
+var PALETTE_SPECS = [
+  { label: "Brand", cssNamespace: "brand", initialColor: { l: 0.5573, c: 0.1841, h: 25.49 } },
+  { label: "Accent", cssNamespace: "accent", initialColor: { l: 0.7674, c: 0.164, h: 70.44 } },
+  { label: "Special", cssNamespace: "special", initialColor: { l: 0.6056, c: 0.2189, h: 292.72 } },
+  { label: "Canvas", cssNamespace: "canvas", emptySelector: true, initialColor: { l: 0.2284, c: 0.0384, h: 282.93 } },
+  { label: "Neutral", cssNamespace: "neutral", neutral: true, initialColor: { l: 0.5679, c: 0.0134, h: 240.07 } },
+  { label: "Alternate", cssNamespace: "alternate", neutral: true, displayLabel: "Alternate (neutral)", initialColor: { l: 0.5873, c: 87e-4, h: 48.57 } },
+  { label: "Info", cssNamespace: "info", initialColor: { l: 0.5871, c: 0.1855, h: 259.56 } },
+  { label: "Success", cssNamespace: "success", initialColor: { l: 0.7198, c: 0.1918, h: 149.52 } },
+  { label: "Warning", cssNamespace: "warning", initialColor: { l: 0.6704, c: 0.1716, h: 48.75 } },
+  { label: "Danger", cssNamespace: "danger", initialColor: { l: 0.6103, c: 0.2165, h: 18.1 } }
+];
+var PALETTE_STEPS = [
+  { label: "100" },
+  { label: "200" },
+  { label: "300" },
+  { label: "400" },
+  { label: "500" },
+  { label: "600" },
+  { label: "700" },
+  { label: "800" },
+  { label: "850" },
+  { label: "900" },
+  { label: "950" }
+];
+var SCALES = [
+  {
+    title: "Surfaces",
+    isText: false,
+    steps: [
+      { name: "lowest", position: -1 },
+      { name: "lower", position: -2 / 3 },
+      { name: "low", position: -1 / 3 },
+      { name: "default", position: 0 },
+      { name: "high", position: 1 / 3 },
+      { name: "higher", position: 2 / 3 },
+      { name: "highest", position: 1 }
+    ]
+  },
+  {
+    title: "Borders",
+    isText: false,
+    steps: [
+      { name: "faint", position: -1 },
+      { name: "subtle", position: -0.5 },
+      { name: "default", position: 0 },
+      { name: "medium", position: 0.5 },
+      { name: "strong", position: 1 }
+    ]
+  },
+  {
+    title: "Text",
+    isText: true,
+    steps: [
+      { name: "primary", position: 0 },
+      { name: "secondary", position: 0 },
+      { name: "tertiary", position: 0 },
+      { name: "muted", position: 0 },
+      { name: "disabled", position: 0 }
+    ]
+  }
+];
+var BW_GUARD_MIN_L = 0.17;
+var BW_GUARD_MAX_L = 0.93;
+var DEFAULT_PALETTE_LIGHTNESS = () => [makeAnchor(0, 95, 5), makeAnchor(100, 8, 5)];
+var DEFAULT_PALETTE_SATURATION = () => [makeAnchor(0, 100, 30), makeAnchor(100, 100, 30)];
+function scaleCurveDefaults(scheme = "dark") {
+  if (scheme === "light") {
+    return {
+      Surfaces: {
+        lightness: () => [makeAnchor(0, 98, 5), makeAnchor(100, 82, 5)],
+        saturation: () => [makeAnchor(0, 100, 30), makeAnchor(100, 100, 30)]
+      },
+      Borders: {
+        lightness: () => [makeAnchor(0, 92, 5), makeAnchor(100, 45, 5)],
+        saturation: () => [makeAnchor(0, 100, 30), makeAnchor(100, 100, 30)]
+      },
+      Text: {
+        lightness: () => [makeAnchor(0, 30, 30), makeAnchor(100, 120, 30)],
+        saturation: () => [makeAnchor(0, 100, 30), makeAnchor(100, 15, 30)]
+      }
+    };
+  }
+  return {
+    Surfaces: {
+      lightness: () => [makeAnchor(0, 15, 5), makeAnchor(100, 47, 5)],
+      saturation: () => [makeAnchor(0, 100, 30), makeAnchor(100, 100, 30)]
+    },
+    Borders: {
+      lightness: () => [makeAnchor(0, 25, 5), makeAnchor(100, 80, 5)],
+      saturation: () => [makeAnchor(0, 100, 30), makeAnchor(100, 100, 30)]
+    },
+    Text: {
+      lightness: () => [makeAnchor(0, 120, 30), makeAnchor(100, 55, 30)],
+      saturation: () => [makeAnchor(0, 100, 30), makeAnchor(100, 15, 30)]
+    }
+  };
+}
+var defaultScaleCurves = scaleCurveDefaults("dark");
+function paletteStepKey(label) {
+  return `Palette-${label}`;
+}
+function stepKey(scaleTitle, stepName) {
+  return `${scaleTitle}-${stepName}`;
+}
+function stepIndexToX(index) {
+  return index / (PALETTE_STEPS.length - 1) * 100;
+}
+function scaleStepToX(step, scale) {
+  const idx = scale.steps.indexOf(step);
+  return scale.steps.length > 1 ? idx / (scale.steps.length - 1) * 100 : 50;
+}
+function serializeDerivedValue(value) {
+  return value.kind === "raw" ? value.css : oklchToHexClamped(value.l, value.c, value.h);
+}
+function computePaletteOklch(index, base, lightnessCurve, saturationCurve, curveOffset) {
+  const { c: baseC, h } = base;
+  const xPos = stepIndexToX(index);
+  const targetL = Math.max(0, Math.min(100, sampleCurve(lightnessCurve, xPos) + (curveOffset.lightness ?? 0))) / 100;
+  const satMul = Math.max(0, Math.min(2, (sampleCurve(saturationCurve, xPos) + (curveOffset.saturation ?? 0)) / 100));
+  const targetC = baseC * satMul;
+  return gamutClamp(targetL, targetC, h);
+}
+function nearestPaletteStep(lightnessCurve, baseL) {
+  let best = 0;
+  let bestD = Infinity;
+  for (let i = 0; i < PALETTE_STEPS.length; i++) {
+    const d = Math.abs(sampleCurve(lightnessCurve, stepIndexToX(i)) - baseL * 100);
+    if (d < bestD) {
+      bestD = d;
+      best = i;
+    }
+  }
+  return best;
+}
+function setCurveAnchor(curve, x, y, smooth = false) {
+  if (smooth && curve.length === 2) {
+    const [p0, p2] = curve;
+    const mid = { x, y, inDx: 0, inDy: 0, outDx: 0, outDy: 0 };
+    if (Math.abs(p0.x - x) < 0.5) {
+      return {
+        curve: [tangentAnchor(x, y, null, p2), tangentAnchor(p2.x, p2.y, mid, null)],
+        displacedY: p0.y,
+        priorEndpoints: [p0, p2]
+      };
+    }
+    if (Math.abs(p2.x - x) < 0.5) {
+      return {
+        curve: [tangentAnchor(p0.x, p0.y, null, mid), tangentAnchor(x, y, p0, null)],
+        displacedY: p2.y,
+        priorEndpoints: [p0, p2]
+      };
+    }
+    return {
+      curve: [
+        tangentAnchor(p0.x, p0.y, null, mid),
+        tangentAnchor(x, y, p0, p2),
+        tangentAnchor(p2.x, p2.y, mid, null)
+      ],
+      priorEndpoints: [p0, p2]
+    };
+  }
+  const existing = curve.findIndex((a) => Math.abs(a.x - x) < 0.5);
+  if (existing >= 0) {
+    const displacedY = curve[existing].y;
+    return { curve: curve.map((a, i) => i === existing ? { ...a, x, y } : a), displacedY };
+  }
+  let insertAt = curve.findIndex((a) => a.x > x);
+  if (insertAt < 0) insertAt = curve.length;
+  const prev = curve[insertAt - 1] ?? null;
+  const next = curve[insertAt] ?? null;
+  const out = [...curve];
+  if (prev && next) {
+    const span = next.x - prev.x;
+    out[insertAt - 1] = scaleOutHandle(prev, (x - prev.x) / span);
+    out[insertAt] = scaleInHandle(next, (next.x - x) / span);
+  }
+  out.splice(insertAt, 0, fitBetween(tangentAnchor(x, y, prev, next), out[insertAt - 1] ?? null, out[insertAt] ?? null));
+  return { curve: out };
+}
+var scaleOutHandle = (a, k) => ({ ...a, outDx: a.outDx * k, outDy: a.outDy * k });
+var scaleInHandle = (a, k) => ({ ...a, inDx: a.inDx * k, inDy: a.inDy * k });
+function fitBetween(a, prev, next) {
+  let out = a;
+  if (prev) {
+    const room = a.x - (prev.x + prev.outDx);
+    if (room < -out.inDx) out = scaleInHandle(out, room <= 0 ? 0 : room / -out.inDx);
+  }
+  if (next) {
+    const room = next.x + next.inDx - a.x;
+    if (room < out.outDx) out = scaleOutHandle(out, room <= 0 ? 0 : room / out.outDx);
+  }
+  return out;
+}
+function liftCurveAnchor(curve, x, displacedY, priorEndpoints) {
+  if (priorEndpoints) return priorEndpoints;
+  const idx = curve.findIndex((a) => Math.abs(a.x - x) < 0.5);
+  if (idx < 0) return curve;
+  if (displacedY !== void 0) return curve.map((a, i) => i === idx ? { ...a, y: displacedY } : a);
+  if (idx === 0 || idx === curve.length - 1) return curve;
+  const out = curve.filter((_, i) => i !== idx);
+  const prev = curve[idx - 1];
+  const next = curve[idx + 1];
+  if (prev && next) {
+    const span = next.x - prev.x;
+    out[idx - 1] = scaleOutHandle(prev, span / (curve[idx].x - prev.x));
+    out[idx] = scaleInHandle(next, span / (next.x - curve[idx].x));
+  }
+  return out;
+}
+function syncBaseAnchor(cfg) {
+  if (cfg.anchorToBase === false) return;
+  const prev = cfg.anchorPlacement;
+  const fresh = prev === void 0;
+  let lCurve = cfg.lightnessCurve;
+  let sCurve = cfg.saturationCurve;
+  if (prev) {
+    const prevX = stepIndexToX(prev.step);
+    lCurve = liftCurveAnchor(lCurve, prevX, prev.displacedL);
+    sCurve = liftCurveAnchor(sCurve, prevX, prev.displacedS);
+  }
+  const step = nearestPaletteStep(lCurve, cfg.baseColor.l);
+  const x = stepIndexToX(step);
+  const l = setCurveAnchor(lCurve, x, cfg.baseColor.l * 100, fresh);
+  const s = setCurveAnchor(sCurve, x, 100, fresh);
+  cfg.lightnessCurve = l.curve;
+  cfg.saturationCurve = s.curve;
+  cfg.anchorPlacement = {
+    step,
+    displacedL: l.displacedY,
+    displacedS: s.displacedY,
+    priorLightnessEndpoints: prev?.priorLightnessEndpoints ?? l.priorEndpoints,
+    priorSaturationEndpoints: prev?.priorSaturationEndpoints ?? s.priorEndpoints
+  };
+}
+function computeDerivedOklch(step, base, scaleTitle, scaleCurves, curveOffset) {
+  const scale = SCALES.find((s) => s.title === scaleTitle);
+  const xPos = scaleStepToX(step, scale);
+  const defs = defaultScaleCurves[scaleTitle];
+  const lCurve = scaleCurves[scaleTitle]?.lightness ?? defs.lightness();
+  const sCurve = scaleCurves[scaleTitle]?.saturation ?? defs.saturation();
+  const lOff = curveOffset[`${scaleTitle}-lightness`] ?? 0;
+  const sOff = curveOffset[`${scaleTitle}-saturation`] ?? 0;
+  const { l: baseL, c: baseC, h: baseH } = base;
+  let targetL;
+  if (scale.isText) {
+    const lMul = Math.max(0, Math.min(2, (sampleCurve(lCurve, xPos) + lOff) / 100));
+    targetL = Math.max(0, Math.min(1, baseL * lMul));
+  } else {
+    targetL = Math.max(0, Math.min(100, sampleCurve(lCurve, xPos) + lOff)) / 100;
+  }
+  const satMul = Math.max(0, Math.min(2, (sampleCurve(sCurve, xPos) + sOff) / 100));
+  const targetC = baseC * satMul;
+  return gamutClamp(targetL, targetC, baseH);
+}
+function scaleToCssVar(scaleTitle, stepName, cssNamespace) {
+  if (cssNamespace === null) return null;
+  if (scaleTitle === "Surfaces") {
+    const suffix = stepName === "default" ? "" : `-${stepName}`;
+    return cssNamespace === "neutral" ? `--surface-neutral${suffix}` : `--surface-${cssNamespace}${suffix}`;
+  }
+  if (scaleTitle === "Borders") {
+    const suffix = stepName === "default" ? "" : `-${stepName}`;
+    return cssNamespace === "neutral" ? `--border-neutral${suffix}` : `--border-${cssNamespace}${suffix}`;
+  }
+  if (scaleTitle === "Text") {
+    if (cssNamespace === "neutral") return `--text-${stepName}`;
+    return stepName === "primary" ? `--text-${cssNamespace}` : `--text-${cssNamespace}-${stepName}`;
+  }
+  return null;
+}
+function derivePaletteValues(spec, config) {
+  const out = {};
+  if (!config) return out;
+  const baseColor = config.baseColor ?? spec.initialColor;
+  const overrides = config.overrides ?? {};
+  const curveOffset = config.curveOffset ?? {};
+  const scaleCurves = config.scaleCurves ?? {};
+  const lightnessCurve = config.lightnessCurve ?? DEFAULT_PALETTE_LIGHTNESS();
+  const saturationCurve = config.saturationCurve ?? DEFAULT_PALETTE_SATURATION();
+  PALETTE_STEPS.forEach((ps, index) => {
+    const k = paletteStepKey(ps.label);
+    const value = k in overrides ? { kind: "color", ...overrides[k] } : { kind: "color", ...computePaletteOklch(index, baseColor, lightnessCurve, saturationCurve, curveOffset) };
+    out[`--color-${spec.cssNamespace}-${ps.label}`] = value;
+  });
+  for (const scale of SCALES) {
+    for (const step of scale.steps) {
+      const k = stepKey(scale.title, step.name);
+      const value = k in overrides ? { kind: "color", ...overrides[k] } : { kind: "color", ...computeDerivedOklch(step, baseColor, scale.title, scaleCurves, curveOffset) };
+      const varName = scaleToCssVar(scale.title, step.name, spec.cssNamespace);
+      if (varName) out[varName] = value;
+    }
+  }
+  const textPrimary = out["--text-primary"];
+  if (textPrimary?.kind === "color") {
+    const mirroredL = Math.max(BW_GUARD_MIN_L, Math.min(BW_GUARD_MAX_L, 1 - textPrimary.l));
+    out["--text-inverted"] = { kind: "color", ...gamutClamp(mirroredL, textPrimary.c, textPrimary.h) };
+  }
+  if (spec.emptySelector) {
+    const emptyMode = config.emptyMode ?? "solid";
+    const gradientStyle = config.gradientStyle ?? "linear";
+    const gradientAngle = config.gradientAngle ?? 180;
+    const gradientReverse = config.gradientReverse ?? false;
+    const gradientSize = config.gradientSize ?? "page";
+    const gradientStops = config.gradientStops ?? [
+      { position: 0, paletteLabel: "800" },
+      { position: 100, paletteLabel: "950" }
+    ];
+    if (emptyMode === "solid") {
+      out["--page-bg"] = { kind: "color", ...baseColor };
+      out["--page-bg-attachment"] = { kind: "raw", css: "scroll" };
+    } else {
+      const sortedStops = [...gradientStops].sort(
+        (a, b) => gradientReverse ? b.position - a.position : a.position - b.position
+      );
+      const stopsCss = sortedStops.map((s) => {
+        const stopValue = out[`--color-${spec.cssNamespace}-${s.paletteLabel}`];
+        const hex = stopValue ? serializeDerivedValue(stopValue) : "#000000";
+        return `${hex} ${s.position}%`;
+      }).join(", ");
+      let gradient;
+      switch (gradientStyle) {
+        case "radial":
+          gradient = `radial-gradient(circle, ${stopsCss})`;
+          break;
+        case "conic":
+          gradient = `conic-gradient(from ${gradientAngle}deg, ${stopsCss})`;
+          break;
+        default:
+          gradient = `linear-gradient(${gradientAngle}deg, ${stopsCss})`;
+      }
+      out["--page-bg"] = { kind: "raw", css: gradient };
+      out["--page-bg-attachment"] = { kind: "raw", css: gradientSize === "window" ? "fixed" : "scroll" };
+    }
+  }
+  return out;
+}
+function derivePaletteVars(spec, config) {
+  const out = {};
+  for (const [k, v] of Object.entries(derivePaletteValues(spec, config))) {
+    out[k] = serializeDerivedValue(v);
+  }
+  return out;
+}
+function palettesToValues(palettes) {
+  const out = {};
+  for (const spec of PALETTE_SPECS) {
+    Object.assign(out, derivePaletteValues(spec, palettes[spec.label]));
+  }
+  return out;
+}
+function palettesToVars(palettes) {
+  const out = {};
+  for (const [k, v] of Object.entries(palettesToValues(palettes))) {
+    out[k] = serializeDerivedValue(v);
+  }
+  return out;
+}
+var HEX_RE = /^#[0-9a-f]{6}$/i;
+function reconcilePalettesFromCssVars(palettes, cssVars) {
+  const next = structuredClone(palettes);
+  const consumed = /* @__PURE__ */ new Set();
+  const snapped = /* @__PURE__ */ new Set();
+  for (const spec of PALETTE_SPECS) {
+    const current = next[spec.label];
+    if (current === void 0) continue;
+    if (current._imported === true) {
+      const anchorHex = cssVars[`--color-${spec.cssNamespace}-500`];
+      if (anchorHex && HEX_RE.test(anchorHex.trim())) {
+        next[spec.label] = { ...current, baseColor: hexToOklch(anchorHex.trim()), _imported: false };
+        syncBaseAnchor(next[spec.label]);
+        snapped.add(spec.label);
+      } else {
+        next[spec.label] = { ...current, _imported: false };
+      }
+    }
+    for (const k of Object.keys(derivePaletteVars(spec, next[spec.label]))) {
+      consumed.add(k);
+    }
+  }
+  return { palettes: next, consumed, snapped };
+}
+
+export {
+  sanitizeFileName,
+  hexToOklch,
+  oklchToHex,
+  gamutClamp,
+  makeAnchor,
+  PALETTE_SPECS,
+  PALETTE_STEPS,
+  SCALES,
+  DEFAULT_PALETTE_LIGHTNESS,
+  DEFAULT_PALETTE_SATURATION,
+  scaleCurveDefaults,
+  scaleStepToX,
+  setCurveAnchor,
+  syncBaseAnchor,
+  scaleToCssVar,
+  palettesToVars,
+  reconcilePalettesFromCssVars
+};

package/dist-plugin/chunk-D3ZVKOR4.js

@@ -0,0 +1,52 @@
+// vite-plugin/files/dataPaths.ts
+import fs from "fs";
+import path from "path";
+var DEFAULT_DATA_DIR = "src/live-tokens/data";
+var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "dataDir",
+  "colorsAndTypeDir",
+  "componentConfigsDir",
+  "themesDir",
+  "manifestsDir",
+  "tokensCssPath"
+]);
+var cached = null;
+function readLiveTokensConfig() {
+  if (cached) return cached;
+  try {
+    const configPath = path.resolve("live-tokens.config.json");
+    if (!fs.existsSync(configPath)) return cached = {};
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    if (!parsed || typeof parsed !== "object") return cached = {};
+    const unknown = Object.keys(parsed).filter(
+      (k) => k !== "$schema" && !KNOWN_CONFIG_KEYS.has(k)
+    );
+    if (unknown.length > 0) {
+      console.warn(
+        `[live-tokens] Unknown key(s) in live-tokens.config.json: ${unknown.join(", ")}. Known keys: ${Array.from(KNOWN_CONFIG_KEYS).join(", ")}.`
+      );
+    }
+    cached = parsed;
+    return cached;
+  } catch {
+    return cached = {};
+  }
+}
+function resolveDataDirs(opts = {}) {
+  const fileConfig = readLiveTokensConfig();
+  const dataDirRaw = opts.dataDir ?? fileConfig.dataDir ?? DEFAULT_DATA_DIR;
+  const dataDir = path.resolve(dataDirRaw);
+  const sub = (name) => path.resolve(dataDir, name);
+  return {
+    dataDir,
+    colorsAndTypeDir: opts.colorsAndTypeDir ? path.resolve(opts.colorsAndTypeDir) : fileConfig.colorsAndTypeDir ? path.resolve(fileConfig.colorsAndTypeDir) : sub("colors-and-type"),
+    componentConfigsDir: opts.componentConfigsDir ? path.resolve(opts.componentConfigsDir) : fileConfig.componentConfigsDir ? path.resolve(fileConfig.componentConfigsDir) : sub("component-configs"),
+    themesDir: opts.themesDir ? path.resolve(opts.themesDir) : fileConfig.themesDir ? path.resolve(fileConfig.themesDir) : sub("themes"),
+    legacyManifestsDir: fileConfig.manifestsDir ? path.resolve(fileConfig.manifestsDir) : void 0
+  };
+}
+
+export {
+  readLiveTokensConfig,
+  resolveDataDirs
+};

package/dist-plugin/dataPaths-DBN0RPuT.d.cts

@@ -0,0 +1,54 @@
+interface LiveTokensFileConfig {
+    dataDir?: string;
+    colorsAndTypeDir?: string;
+    componentConfigsDir?: string;
+    themesDir?: string;
+    /**
+     * Retired in 0.48, where `themesDir` took over the meaning. Still recognised
+     * so an unmigrated project is not told its key is a typo, and so the
+     * migration can find (or refuse to guess at) a whole-look directory the
+     * consumer moved.
+     */
+    manifestsDir?: string;
+    /**
+     * Path to the developer-authored `tokens.css`. The dev plugin takes this from
+     * its `themeFileApi({ tokensCssPath })` option; the standalone `live-tokens
+     * migrate` CLI has no plugin options, so it reads this key to locate the file.
+     */
+    tokensCssPath?: string;
+}
+interface ResolveDataDirsInput {
+    dataDir?: string;
+    colorsAndTypeDir?: string;
+    componentConfigsDir?: string;
+    themesDir?: string;
+}
+interface ResolvedDataDirs {
+    dataDir: string;
+    colorsAndTypeDir: string;
+    componentConfigsDir: string;
+    themesDir: string;
+    /** Absolute path of the retired `manifestsDir` key, when the config sets it.
+     *  Only the pre-0.48 layout detector and the migration read it. */
+    legacyManifestsDir?: string;
+}
+declare function readLiveTokensConfig(): LiveTokensFileConfig;
+/**
+ * Resolve the four data directories for a single plugin/preprocessor.
+ *
+ * Per-folder resolution order (most specific wins):
+ *   1. explicit opts (e.g. `opts.colorsAndTypeDir`)
+ *   2. `live-tokens.config.json` field (e.g. `fileConfig.colorsAndTypeDir`)
+ *   3. `<dataDir>/<sub>` where dataDir comes from opts > config file > the
+ *      package default (`src/live-tokens/data`)
+ *
+ * This lets a consumer set `dataDir` once and have all three subfolders move
+ * together, while still allowing per-folder overrides for unusual layouts
+ * (e.g. a monorepo where colors and type are shared across packages but
+ * component-configs aren't).
+ *
+ * All returned paths are absolute (resolved via `path.resolve` against cwd).
+ */
+declare function resolveDataDirs(opts?: ResolveDataDirsInput): ResolvedDataDirs;
+
+export { resolveDataDirs as a, readLiveTokensConfig as r };