rafters 0.0.39 → 0.0.41

package/dist/index.js

@@ -46944,7 +46944,8 @@ function generateThemeBlock(groups) {
       const value2 = tokenValueToCSS(token);
       if (value2 === null) continue;
       const key = token.name.replace(/^spacing-/, "");
-      lines.push(`  --spacing-${key}: ${value2};`);
+      const themeValue = value2.replaceAll("var(--rafters-spacing-base)", "var(--spacing-base)");
+      lines.push(`  --spacing-${key}: ${themeValue};`);
     }
     lines.push("");
   }
@@ -61412,6 +61413,107 @@ var RaftersToolHandler = class _RaftersToolHandler {
     "highlight",
     "muted"
   ];
+  static SEMANTIC_FAMILY_SET = new Set(
+    _RaftersToolHandler.SEMANTIC_FAMILIES
+  );
+  /** Scale positions indexed 0-10, matching ColorValue.scale array indices */
+  static SCALE_POSITIONS = [
+    "50",
+    "100",
+    "200",
+    "300",
+    "400",
+    "500",
+    "600",
+    "700",
+    "800",
+    "900",
+    "950"
+  ];
+  static positionToIndex(position) {
+    const idx = _RaftersToolHandler.SCALE_POSITIONS.indexOf(
+      position
+    );
+    return idx >= 0 ? idx : 5;
+  }
+  /**
+   * Find an accessible foreground position against a given background position.
+   * Tries AAA first (7:1), falls back to AA (4.5:1), keeps default if both pass.
+   */
+  static findAccessibleFgPosition(bgPosition, defaultFgPosition, aaaPairs, aaPairs) {
+    const bgIdx = _RaftersToolHandler.positionToIndex(bgPosition);
+    const fgIdx = _RaftersToolHandler.positionToIndex(defaultFgPosition);
+    const pairValid = (pairs) => pairs.some(([a2, b2]) => a2 === bgIdx && b2 === fgIdx || a2 === fgIdx && b2 === bgIdx);
+    if (pairValid(aaaPairs) || pairValid(aaPairs)) return defaultFgPosition;
+    const bestPair = aaaPairs.find(([a2]) => a2 === bgIdx) ?? aaPairs.find(([a2]) => a2 === bgIdx);
+    if (bestPair && bestPair[1] !== void 0) {
+      return _RaftersToolHandler.SCALE_POSITIONS[bestPair[1]] ?? defaultFgPosition;
+    }
+    return defaultFgPosition;
+  }
+  /**
+   * When a semantic family is mapped to a color, cascade to all surface tokens
+   * that reference that family. Uses precomputed accessibility data from the
+   * ColorValue to verify WCAG AAA (fall back to AA) compliance for fg/bg pairs.
+   */
+  cascadeSemanticFamily(registry2, familyName, colorFamilyName, results) {
+    const tokensToUpdate = [];
+    const colorFamilyToken = registry2.get(colorFamilyName);
+    const colorValue = colorFamilyToken?.value && typeof colorFamilyToken.value === "object" && "scale" in colorFamilyToken.value ? colorFamilyToken.value : null;
+    const aaaPairs = colorValue?.accessibility?.wcagAAA?.normal ?? [];
+    const aaPairs = colorValue?.accessibility?.wcagAA?.normal ?? [];
+    for (const [name2, mapping] of Object.entries(DEFAULT_SEMANTIC_COLOR_MAPPINGS)) {
+      const belongsToFamily = familyName === "neutral" ? mapping.light.family === "neutral" && mapping.dark.family === "neutral" : name2 === familyName || name2.startsWith(`${familyName}-`);
+      if (!belongsToFamily) continue;
+      const existing = registry2.get(name2);
+      if (!existing) continue;
+      if (existing.userOverride?.reason && !existing.userOverride.reason.startsWith("Auto-cascaded")) {
+        continue;
+      }
+      let lightPos = mapping.light.position;
+      let darkPos = mapping.dark.position;
+      const isForeground = name2.endsWith("-foreground");
+      const tokenFamily = isForeground ? "neutral" : colorFamilyName;
+      if (isForeground && colorValue) {
+        const bgName = name2.replace(/-foreground$/, "");
+        const bgMapping = DEFAULT_SEMANTIC_COLOR_MAPPINGS[bgName];
+        if (bgMapping) {
+          lightPos = _RaftersToolHandler.findAccessibleFgPosition(
+            bgMapping.light.position,
+            lightPos,
+            aaaPairs,
+            aaPairs
+          );
+          darkPos = _RaftersToolHandler.findAccessibleFgPosition(
+            bgMapping.dark.position,
+            darkPos,
+            aaaPairs,
+            aaPairs
+          );
+        }
+      }
+      const lightRef = { family: tokenFamily, position: lightPos };
+      const lightTokenName = `${tokenFamily}-${lightPos}`;
+      const darkTokenName = `${tokenFamily}-${darkPos}`;
+      tokensToUpdate.push({
+        ...existing,
+        value: lightRef,
+        dependsOn: [lightTokenName, darkTokenName],
+        userOverride: {
+          previousValue: typeof existing.value === "string" ? existing.value : JSON.stringify(existing.value),
+          reason: `Auto-cascaded from ${familyName} -> ${colorFamilyName}`
+        }
+      });
+      results.push({
+        source: familyName,
+        target: name2,
+        action: "cascade",
+        ok: true,
+        persisted: { value: lightRef, dependsOn: [lightTokenName, darkTokenName] }
+      });
+    }
+    return tokensToUpdate;
+  }
   /**
    * Handle rafters_onboard tool calls
    */
@@ -61763,6 +61865,7 @@ var RaftersToolHandler = class _RaftersToolHandler {
       registry2.setAdapter(this.adapter);
       const results = [];
       const parseRef = _RaftersToolHandler.parseColorRef;
+      const allCascadeTokens = [];
       for (const mapping of mappings) {
         const { source, target, value: value2, reason, namespace, category } = mapping;
         const lightRef = mapping.light;
@@ -61938,12 +62041,29 @@ var RaftersToolHandler = class _RaftersToolHandler {
           registry2.add(newToken);
           results.push({ source, target, action: "create", ok: true, enriched });
         }
+        if (_RaftersToolHandler.SEMANTIC_FAMILY_SET.has(target)) {
+          if (!enriched) {
+            results.push({
+              source,
+              target,
+              action: "skipped",
+              ok: false,
+              error: `Cascade skipped for "${target}": value was not enriched. Provide a CSS color value so the color family can be created with accessibility data.`
+            });
+          } else {
+            allCascadeTokens.push(...this.cascadeSemanticFamily(registry2, target, target, results));
+          }
+        }
+      }
+      if (allCascadeTokens.length > 0) {
+        await registry2.setTokens(allCascadeTokens);
       }
       await this.adapter.save(registry2.list());
       const outputFiles = await this.regenerateOutputs(registry2);
       const setCount = results.filter((r) => r.action === "set" && r.ok).length;
       const createCount = results.filter((r) => r.action === "create" && r.ok).length;
       const remapCount = results.filter((r) => r.action === "remap" && r.ok).length;
+      const cascadeCount = results.filter((r) => r.action === "cascade" && r.ok).length;
       const enrichedCount = results.filter((r) => r.enriched).length;
       const failCount = results.filter((r) => !r.ok).length;
       return {
@@ -61957,6 +62077,7 @@ var RaftersToolHandler = class _RaftersToolHandler {
                   set: setCount,
                   created: createCount,
                   remapped: remapCount,
+                  cascaded: cascadeCount,
                   enriched: enrichedCount,
                   failed: failCount
                 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rafters",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "description": "CLI for Rafters design system - scaffold tokens and add components",
   "license": "MIT",
   "type": "module",