@motion-proto/live-tokens 0.52.1 → 0.54.0

package/dist-plugin/adjust/index.d.cts

@@ -1,4 +1,5 @@
-import { A as AliasDiskValue, a as ComponentConfig } from '../themeTypes-Dky03HL9.cjs';
+import { A as AliasDiskValue, b as ComponentConfig } from '../index-DpTIRZ2H.cjs';
+export { C as CURRENT_COMPONENT_SCHEMA_VERSION } from '../index-DpTIRZ2H.cjs';
 export { r as readLiveTokensConfig, a as resolveDataDirs } from '../dataPaths-DBN0RPuT.cjs';
 
 type AdjustKind = 'radius' | 'padding' | 'gap' | 'border-width';

package/dist-plugin/adjust/index.d.ts

@@ -1,4 +1,5 @@
-import { A as AliasDiskValue, a as ComponentConfig } from '../themeTypes-Dky03HL9.js';
+import { A as AliasDiskValue, b as ComponentConfig } from '../index-DpTIRZ2H.js';
+export { C as CURRENT_COMPONENT_SCHEMA_VERSION } from '../index-DpTIRZ2H.js';
 export { r as readLiveTokensConfig, a as resolveDataDirs } from '../dataPaths-DBN0RPuT.js';
 
 type AdjustKind = 'radius' | 'padding' | 'gap' | 'border-width';

package/dist-plugin/adjust/index.js

@@ -1,3 +1,6 @@
+import {
+  CURRENT_COMPONENT_SCHEMA_VERSION
+} from "../chunk-NE6N66EE.js";
 import {
   readLiveTokensConfig,
   resolveDataDirs
@@ -31,9 +34,12 @@ var MATCHER_BY_KIND = Object.fromEntries(
   KIND_PATTERNS.map((p) => [p.kind, p.matches])
 );
 var SIDE_SUFFIXES = ["-top", "-right", "-bottom", "-left"];
-function matchesKind(variable, kind) {
+function stripSide(variable) {
   const side = SIDE_SUFFIXES.find((s) => variable.endsWith(s));
-  return MATCHER_BY_KIND[kind](side ? variable.slice(0, -side.length) : variable);
+  return side ? variable.slice(0, -side.length) : variable;
+}
+function matchesKind(variable, kind) {
+  return MATCHER_BY_KIND[kind](stripSide(variable));
 }
 
 // src/editor/core/components/adjustAliases.ts
@@ -48,7 +54,7 @@ var RADIUS_RUNGS = [
   "--radius-3xl",
   "--radius-4xl"
 ];
-var SPACE_RUNGS = [
+var SPACE_SETTABLE = [
   "--space-0",
   "--space-2",
   "--space-4",
@@ -62,7 +68,10 @@ var SPACE_RUNGS = [
   "--space-32",
   "--space-48"
 ];
-var SPACE_FAMILY = [...SPACE_RUNGS, "--space-40", "--space-64", "--space-96", "--space-128"];
+var SPACE_RUNGS = SPACE_SETTABLE;
+var INSET_RUNGS = SPACE_SETTABLE.slice(SPACE_SETTABLE.indexOf("--space-4"));
+var TEXT_INSET_RUNGS = SPACE_SETTABLE.slice(SPACE_SETTABLE.indexOf("--space-6"));
+var SPACE_FAMILY = [...SPACE_SETTABLE, "--space-40", "--space-64", "--space-96", "--space-128"];
 var BORDER_WIDTH_RUNGS = [
   "--border-width-0",
   "--border-width-1",
@@ -79,37 +88,53 @@ var BORDER_WIDTH_RUNGS = [
   "--border-width-24"
 ];
 var LADDERS = {
-  radius: { rungs: RADIUS_RUNGS, family: [...RADIUS_RUNGS, RADIUS_FULL] },
-  padding: { rungs: SPACE_RUNGS, family: SPACE_FAMILY },
-  gap: { rungs: SPACE_RUNGS, family: SPACE_FAMILY },
-  "border-width": { rungs: BORDER_WIDTH_RUNGS, family: BORDER_WIDTH_RUNGS }
+  radius: {
+    rungs: RADIUS_RUNGS,
+    settable: [...RADIUS_RUNGS, RADIUS_FULL],
+    family: [...RADIUS_RUNGS, RADIUS_FULL]
+  },
+  padding: { rungs: SPACE_RUNGS, settable: SPACE_SETTABLE, family: SPACE_FAMILY },
+  gap: { rungs: SPACE_RUNGS, settable: SPACE_SETTABLE, family: SPACE_FAMILY },
+  "border-width": {
+    rungs: BORDER_WIDTH_RUNGS,
+    settable: BORDER_WIDTH_RUNGS,
+    family: BORDER_WIDTH_RUNGS
+  }
 };
 var TOKEN_NAME = /^--[a-z0-9-]+$/;
-function rungsFor(op) {
-  return op.kind === "radius" && op.full ? [...RADIUS_RUNGS, RADIUS_FULL] : LADDERS[op.kind].rungs;
+function rungsFor(op, variable, aliases) {
+  if (op.kind === "radius") return op.full ? [...RADIUS_RUNGS, RADIUS_FULL] : RADIUS_RUNGS;
+  if (op.kind !== "padding") return LADDERS[op.kind].rungs;
+  const base = stripSide(variable);
+  if (!base.endsWith("-padding")) return LADDERS.padding.rungs;
+  const variant = base.slice(0, -"-padding".length);
+  return `${variant}-text-font-size` in aliases ? TEXT_INSET_RUNGS : INSET_RUNGS;
 }
 function spaceStep(token) {
   return Number(token.slice("--space-".length));
 }
-function nearestSpaceRung(token, rungs) {
+function snapRung(token, rungs, direction) {
   const step = spaceStep(token);
-  let best = 0;
-  for (let i = 1; i < rungs.length; i++) {
-    if (Math.abs(spaceStep(rungs[i]) - step) <= Math.abs(spaceStep(rungs[best]) - step)) best = i;
+  if (direction > 0) return rungs.findIndex((rung) => spaceStep(rung) > step);
+  for (let index = rungs.length - 1; index >= 0; index--) {
+    if (spaceStep(rungs[index]) < step) return index;
   }
-  return best;
+  return -1;
 }
-function resolve(op, value) {
+function resolve(op, variable, value, aliases) {
   if (typeof value !== "string" || !TOKEN_NAME.test(value)) return { skip: "raw-value" };
   if (!LADDERS[op.kind].family.includes(value)) return { skip: "off-ladder" };
   if (op.set !== void 0) return { from: value, to: op.set };
-  const rungs = rungsFor(op);
+  const rungs = rungsFor(op, variable, aliases);
   let index = rungs.indexOf(value);
+  let shift = op.shift;
   if (index < 0) {
     if (value === RADIUS_FULL) return { skip: "pill-preserved" };
-    index = nearestSpaceRung(value, rungs);
+    index = snapRung(value, rungs, shift);
+    if (index < 0) return { skip: "clamped" };
+    shift -= Math.sign(shift);
   }
-  const wanted = index + op.shift;
+  const wanted = index + shift;
   const landed = Math.min(Math.max(wanted, 0), rungs.length - 1);
   if (landed !== wanted && rungs[landed] === value) return { skip: "clamped" };
   return { from: value, to: rungs[landed] };
@@ -123,7 +148,7 @@ function validateOp(op, configs) {
   const hasSet = op.set !== void 0;
   const hasShift = op.shift !== void 0;
   if (hasSet === hasShift) throw new Error(`A ${op.kind} op needs exactly one of "set" or "shift"`);
-  const settable = op.kind === "radius" ? ladder.family : ladder.rungs;
+  const settable = ladder.settable;
   if (hasSet && !settable.includes(op.set)) {
     throw new Error(`"${op.set}" is not on the ${op.kind} ladder`);
   }
@@ -153,7 +178,7 @@ function adjustAliases(configs, ops, now) {
       let changed = false;
       for (const [variable, value] of Object.entries(config.aliases)) {
         if (!matchesKind(variable, op.kind)) continue;
-        const outcome = resolve(op, value);
+        const outcome = resolve(op, variable, value, config.aliases);
         if ("skip" in outcome) {
           reportFor(component).skips.push({ variable, value, reason: outcome.skip });
           continue;
@@ -169,6 +194,7 @@ function adjustAliases(configs, ops, now) {
   return { configs: next, report: { components: [...reports.values()] } };
 }
 export {
+  CURRENT_COMPONENT_SCHEMA_VERSION,
   adjustAliases,
   matchesKind,
   readLiveTokensConfig,

package/dist-plugin/{chunk-6OZFXIQI.js → chunk-232GZGQU.js}

@@ -1,3 +1,8 @@
+import {
+  CURRENT_COMPONENT_SCHEMA_VERSION,
+  runMigrations
+} from "./chunk-NE6N66EE.js";
+
 // vite-plugin/files/versionedFileResourceServer.ts
 import fs from "fs";
 import path from "path";
@@ -129,8 +134,141 @@ function versionedFileResourceServer(opts) {
   };
 }
 
+// src/editor/core/themes/themeTypes.ts
+var THEME_SCHEMA_VERSION = 4;
+
+// src/editor/core/themes/migrateComponentConfig.ts
+function migrateComponentConfig(component, aliasesIn, rawConfig, fileVersion) {
+  const stringPart = {};
+  const objectPart = {};
+  for (const [k, v] of Object.entries(aliasesIn)) {
+    if (typeof v === "string") stringPart[k] = v;
+    else objectPart[k] = v;
+  }
+  const configOut = {};
+  for (const [k, v] of Object.entries(rawConfig ?? {})) {
+    if (typeof v === "string") stringPart[k] = v;
+    else configOut[k] = v;
+  }
+  if (component === "sectiondivider") {
+    synthesizeSectionDividerGradients(stringPart, objectPart);
+  }
+  const migratedString = runMigrations("component-config", fileVersion, stringPart, { component });
+  const migratedObject = component === "sectiondivider" ? renameSectionDividerObjectSlots(objectPart) : objectPart;
+  return {
+    aliases: { ...migratedString, ...migratedObject },
+    config: configOut
+  };
+}
+var FAMILIES = ["canvas", "neutral", "alternate", "primary", "accent", "special"];
+var SIZE_VARIANTS = ["lg", "md", "sm"];
+function renameSectionDividerObjectSlots(objectPart) {
+  const canvasSourceKeys = [
+    "--sectiondivider-canvas-background",
+    "--sectiondivider-canvas-gradient",
+    "--sectiondivider-color-canvas-background"
+  ];
+  let canvasGradient;
+  for (const key of canvasSourceKeys) {
+    if (objectPart[key] !== void 0) {
+      canvasGradient = objectPart[key];
+      break;
+    }
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(objectPart)) {
+    let isFamilyGradient = false;
+    for (const f of FAMILIES) {
+      if (key === `--sectiondivider-${f}-background` || key === `--sectiondivider-${f}-gradient` || key === `--sectiondivider-color-${f}-background`) {
+        isFamilyGradient = true;
+        break;
+      }
+    }
+    if (isFamilyGradient) continue;
+    out[key] = value;
+  }
+  if (canvasGradient !== void 0) {
+    for (const v of SIZE_VARIANTS) {
+      out[`--sectiondivider-${v}-background`] = canvasGradient;
+    }
+  }
+  return out;
+}
+var SECTIONDIVIDER_VARIANTS = ["canvas", "neutral", "alternate", "primary", "accent", "special"];
+function synthesizeSectionDividerGradients(stringPart, objectPart) {
+  const GRADIENT_ANGLE_TOKENS = {
+    "--gradient-angle-horizontal": 90,
+    "--gradient-angle-vertical": 180,
+    "--gradient-angle-diagonal": 135,
+    "--gradient-angle-counter-diagonal": 45
+  };
+  const GRADIENT_STOP_POSITIONS = {
+    "--gradient-stop-start": 0,
+    "--gradient-stop-mid": 50,
+    "--gradient-stop-end": 100
+  };
+  const parseAngle = (raw) => {
+    if (!raw) return 135;
+    if (raw.startsWith("--")) return GRADIENT_ANGLE_TOKENS[raw] ?? 135;
+    const m = raw.match(/^(-?\d+(?:\.\d+)?)\s*deg$/i);
+    return m ? parseFloat(m[1]) : 135;
+  };
+  const parsePosition = (raw, fallback) => {
+    if (!raw) return fallback;
+    if (raw.startsWith("--")) return GRADIENT_STOP_POSITIONS[raw] ?? fallback;
+    const m = raw.match(/^(-?\d+(?:\.\d+)?)\s*%$/);
+    return m ? parseFloat(m[1]) : fallback;
+  };
+  const parseStopColor = (raw) => {
+    if (!raw) return null;
+    if (raw.startsWith("--")) return { color: raw };
+    const mix = raw.match(/^color-mix\(\s*in\s+srgb\s*,\s*var\((--[a-z0-9-]+)\)\s+([\d.]+)%\s*,\s*transparent\s*\)$/i);
+    if (mix) return { color: mix[1], opacity: parseFloat(mix[2]) };
+    return null;
+  };
+  for (const v of SECTIONDIVIDER_VARIANTS) {
+    const slot = `--sectiondivider-${v}-gradient`;
+    if (slot in objectPart) continue;
+    const angleKey = `${slot}-angle`;
+    const has1 = stringPart[`${slot}-stop-1-color`] !== void 0;
+    const has2 = stringPart[`${slot}-stop-2-color`] !== void 0;
+    const has3 = stringPart[`${slot}-stop-3-color`] !== void 0;
+    if (!has1 && !has2 && !has3) continue;
+    const stops = [];
+    const positionDefaults = [0, 50, 100];
+    for (let i = 1; i <= 3; i++) {
+      const c = parseStopColor(stringPart[`${slot}-stop-${i}-color`]);
+      if (!c) continue;
+      const pos = parsePosition(stringPart[`${slot}-stop-${i}-position`], positionDefaults[i - 1]);
+      stops.push({ position: pos, color: c.color, ...c.opacity !== void 0 ? { opacity: c.opacity } : {} });
+    }
+    if (stops.length < 2) continue;
+    objectPart[slot] = {
+      kind: "gradient",
+      value: {
+        type: "linear",
+        angle: parseAngle(stringPart[angleKey]),
+        stops
+      }
+    };
+  }
+}
+
+// src/editor/core/components/componentConfigKeys.ts
+var KNOWN_COMPONENT_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "--dialog-confirm-variant",
+  "--dialog-cancel-variant",
+  // SectionDivider per-variant `color-family` is editor metadata that drives
+  // the family-swap rewrite on aliases. It is not a runtime CSS value, so it
+  // stays in the config bucket. The other intrinsics (align, hairline,
+  // eyebrow/description visibility, eyebrow text-transform) now flow through
+  // the alias bucket as cascading CSS vars — see the 2026-05-22 migration.
+  "--sectiondivider-lg-color-family",
+  "--sectiondivider-md-color-family",
+  "--sectiondivider-sm-color-family"
+]);
+
 // vite-plugin/themes/normalizeTheme.ts
-var THEME_SCHEMA_VERSION = 3;
 function asObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -152,10 +290,41 @@ function migrateEmbeddedKey(src) {
   const { theme, ...rest } = src;
   return { ...rest, colorsAndType: theme };
 }
+function routeKnownConfigKeys(aliases, config) {
+  const outAliases = { ...aliases };
+  const outConfig = { ...config };
+  for (const key of Object.keys(outAliases)) {
+    if (!KNOWN_COMPONENT_CONFIG_KEYS.has(key)) continue;
+    if (outConfig[key] === void 0) outConfig[key] = outAliases[key];
+    delete outAliases[key];
+  }
+  return { aliases: outAliases, config: outConfig };
+}
+function migrateEmbeddedComponentConfig(comp, config, fileVersion) {
+  const { schemaVersion: _entryStamp, aliases: rawAliases, config: rawConfig, ...rest } = config;
+  const aliasesIn = asObject(rawAliases);
+  if (!aliasesIn) {
+    return rawConfig !== void 0 ? { ...rest, config: rawConfig } : rest;
+  }
+  const migratedConfig = migrateComponentConfig(
+    comp,
+    aliasesIn,
+    asObject(rawConfig) ?? void 0,
+    fileVersion
+  );
+  const split = routeKnownConfigKeys(migratedConfig.aliases, migratedConfig.config);
+  const out = { ...rest, aliases: split.aliases };
+  if (rawConfig !== void 0 || Object.keys(split.config).length > 0) {
+    out.config = split.config;
+  }
+  return out;
+}
 function normalizeTheme(raw, resolvers) {
   const input = asObject(raw) ?? {};
   const migrated = input.schemaVersion !== THEME_SCHEMA_VERSION;
-  const src = migrated ? migrateEmbeddedKey(input) : input;
+  const inputVersion = typeof input.schemaVersion === "number" ? input.schemaVersion : 0;
+  const src = inputVersion < 3 ? migrateEmbeddedKey(input) : input;
+  const componentSchemaVersion = typeof input.componentSchemaVersion === "number" ? input.componentSchemaVersion : 0;
   const dropped = [];
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const embeddedColorsAndType = asObject(src.colorsAndType);
@@ -174,18 +343,42 @@ function normalizeTheme(raw, resolvers) {
   const componentConfigs = {};
   for (const [comp, value] of Object.entries(asObject(src.componentConfigs) ?? {})) {
     const embedded = asObject(value);
+    let resolvedConfig;
     if (embedded) {
-      componentConfigs[comp] = stripFileMarker(embedded);
-      continue;
+      resolvedConfig = stripFileMarker(embedded);
+    } else {
+      const configName = asString(value, "default");
+      const resolved = asObject(resolvers.readComponentConfig(comp, configName));
+      if (!resolved) {
+        dropped.push(`${comp}/${configName}`);
+        continue;
+      }
+      resolvedConfig = stripFileMarker(resolved);
     }
-    const configName = asString(value, "default");
-    if (configName === "default") continue;
-    const resolved = asObject(resolvers.readComponentConfig(comp, configName));
-    if (!resolved) {
-      dropped.push(`${comp}/${configName}`);
+    componentConfigs[comp] = migrateEmbeddedComponentConfig(comp, resolvedConfig, componentSchemaVersion);
+  }
+  const filled = { components: [], aliases: 0, orphans: 0 };
+  for (const comp of resolvers.listComponentNames()) {
+    const base = asObject(resolvers.readComponentConfig(comp, "default"));
+    const baseAliases = base ? asObject(base.aliases) : null;
+    if (!base || !baseAliases) continue;
+    const entry = componentConfigs[comp];
+    if (!entry) {
+      const { schemaVersion: _standaloneStamp, ...rest } = stripFileMarker(base);
+      componentConfigs[comp] = structuredClone(rest);
+      filled.components.push(comp);
       continue;
     }
-    componentConfigs[comp] = stripFileMarker(resolved);
+    const entryAliases = asObject(entry.aliases) ?? {};
+    for (const key of Object.keys(baseAliases)) {
+      if (key in entryAliases) continue;
+      entryAliases[key] = structuredClone(baseAliases[key]);
+      filled.aliases++;
+    }
+    entry.aliases = entryAliases;
+    for (const key of Object.keys(entryAliases)) {
+      if (!(key in baseAliases)) filled.orphans++;
+    }
   }
   return {
     theme: {
@@ -194,10 +387,12 @@ function normalizeTheme(raw, resolvers) {
       updatedAt: asString(src.updatedAt, now),
       schemaVersion: THEME_SCHEMA_VERSION,
       colorsAndType,
-      componentConfigs
+      componentConfigs,
+      componentSchemaVersion: CURRENT_COMPONENT_SCHEMA_VERSION
     },
     dropped,
-    migrated
+    migrated,
+    filled
   };
 }