@servicetitan/hammer-token 2.5.2 → 3.0.1

package/src/utils/figma/sync-primitives.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+
+/**
+ * Primitive Token Sync
+ *
+ * Functions for building variable requests for primitive tokens.
+ */
+
+const {
+  convertTokenValueToFigma,
+  getFigmaVariableType,
+} = require("./token-conversion");
+const { valuesEqual, getVariableIdByName } = require("./figma-api");
+const { getTokenDescription } = require("./token-resolution");
+/**
+ * Get Figma variable scopes from token $extensions["com.figma.scopes"]. Missing or empty = ["ALL_SCOPES"].
+ * @param {Object} [token] - Leaf token object
+ * @returns {string[]} Scopes array
+ */
+function getScopesForVariable(token) {
+  const fromToken = token?.$extensions?.["com.figma.scopes"];
+  return Array.isArray(fromToken) && fromToken.length > 0
+    ? fromToken
+    : ["ALL_SCOPES"];
+}
+
+/**
+ * Build bulk request for primitive variable changes only
+ * Returns an object with variables array and variableModeValues array
+ * @param {Map} resolvedTokens - Map of resolved tokens
+ * @param {Array} existingVariables - Array of existing variables
+ * @param {string} collectionId - Collection ID
+ * @param {Object} modes - Modes object with light and dark
+ * @param {Map} tempIdMap - Temporary ID map for tracking created variables
+ * @returns {Object} Object with variableChanges, variableModeValues, stats, errors, and tempIdMap
+ */
+function buildPrimitiveVariableRequest(
+  resolvedTokens,
+  existingVariables,
+  collectionId,
+  modes,
+  tempIdMap = new Map(),
+) {
+  const variableChanges = [];
+  const variableModeValues = [];
+  const stats = { created: 0, updated: 0, skipped: 0, deleted: 0, errors: 0 };
+  const errors = [];
+
+  // Filter to only primitive tokens (exclude font/line-height - Figma doesn't accept string line-height)
+  const primitiveTokens = [];
+  for (const [tokenPath, tokenData] of resolvedTokens.entries()) {
+    if (tokenData.isPrimitive && !tokenPath.startsWith("font/line-height/")) {
+      primitiveTokens.push([tokenPath, tokenData]);
+    }
+  }
+
+  const keptPrimitiveNames = new Set(
+    primitiveTokens.map(([path]) => `primitive/${path}`),
+  );
+
+  // Process primitives
+  for (const [tokenPath, tokenData] of primitiveTokens) {
+    try {
+      const { token, resolvedLight, resolvedDark } = tokenData;
+      const tokenType = token.$type || "string";
+
+      // Add "primitive/" prefix to variable name for organization
+      const variableName = `primitive/${tokenPath}`;
+
+      // Get existing variable (check both with and without prefix for backward compatibility)
+      // Optimize: Use getVariableIdByName for better performance
+      const existingId =
+        getVariableIdByName(variableName, existingVariables) ||
+        getVariableIdByName(tokenPath, existingVariables);
+      // Optimize: Use Map for O(1) lookup if we have many variables
+      let existing = null;
+      if (existingId) {
+        if (existingVariables.length > 100) {
+          const variableIdMap = new Map();
+          for (const v of existingVariables) {
+            if (v.id) variableIdMap.set(v.id, v);
+          }
+          existing = variableIdMap.get(existingId) || null;
+        } else {
+          existing = existingVariables.find((v) => v.id === existingId);
+        }
+      }
+
+      // Convert values (pass tokenPath for context e.g. line-height → %)
+      const scopes = getScopesForVariable(token);
+      const lightFigmaValue = convertTokenValueToFigma(
+        tokenType,
+        resolvedLight,
+        { tokenPath, scopes },
+      );
+      const darkFigmaValue = convertTokenValueToFigma(tokenType, resolvedDark, {
+        tokenPath,
+        scopes,
+      });
+
+      if (lightFigmaValue === null || darkFigmaValue === null) {
+        errors.push(`Could not convert values for ${tokenPath}`);
+        stats.errors++;
+        continue;
+      }
+
+      if (existing) {
+        // Check if values are the same
+        const existingValues = existing.valuesByMode || {};
+        const existingLight = existingValues[modes.light.id];
+        const existingDark = existingValues[modes.dark.id];
+
+        const lightSame = valuesEqual(existingLight, lightFigmaValue);
+        const darkSame = valuesEqual(existingDark, darkFigmaValue);
+
+        // Line-height is sent as % string; Figma variable type must be STRING
+        const updateScopes = getScopesForVariable(tokenData.token);
+        const existingScopes = existing.scopes ?? [];
+        const sortedUpdate = [...updateScopes].sort();
+        const sortedExisting = [...existingScopes].sort();
+        const scopesDiffer =
+          sortedUpdate.length !== sortedExisting.length ||
+          sortedUpdate.some((s, i) => s !== sortedExisting[i]);
+
+        const tokenDescription = getTokenDescription(token, resolvedTokens);
+        const descriptionSame =
+          (existing.description || "") === tokenDescription;
+
+        if (lightSame && darkSame && !scopesDiffer && descriptionSame) {
+          stats.skipped++;
+          // Store existing ID for alias resolution (use both paths for lookup)
+          tempIdMap.set(tokenPath, existing.id);
+          tempIdMap.set(variableName, existing.id);
+          continue;
+        }
+
+        // Update variable (scopes and/or values) — always send our scopes so Figma matches code
+        const updatePayload = {
+          action: "UPDATE",
+          id: existing.id,
+          name: variableName,
+          scopes: updateScopes,
+          description: tokenDescription,
+        };
+        variableChanges.push(updatePayload);
+
+        if (!lightSame || !darkSame) {
+          variableModeValues.push(
+            {
+              variableId: existing.id,
+              modeId: modes.light.id,
+              value: lightFigmaValue,
+            },
+            {
+              variableId: existing.id,
+              modeId: modes.dark.id,
+              value: darkFigmaValue,
+            },
+          );
+        }
+
+        stats.updated++;
+        tempIdMap.set(tokenPath, existing.id);
+        tempIdMap.set(variableName, existing.id);
+      } else {
+        // Create new variable with temporary ID (use a counter to ensure uniqueness)
+        const tempIdCounter = tempIdMap.size + variableChanges.length + 1;
+        const tempId = `temp_var_${tempIdCounter}_${variableName.replace(/\//g, "_").replace(/[^a-zA-Z0-9_]/g, "_")}`;
+        tempIdMap.set(tokenPath, tempId);
+        tempIdMap.set(variableName, tempId);
+
+        // Line-height is sent as % string; Figma variable type must be STRING
+        const resolvedType =
+          tokenPath.startsWith("font/line-height/") &&
+          typeof lightFigmaValue === "string"
+            ? "STRING"
+            : getFigmaVariableType(tokenType);
+        const createScopes = getScopesForVariable(tokenData.token);
+        const createPayload = {
+          action: "CREATE",
+          id: tempId,
+          name: variableName,
+          variableCollectionId: collectionId,
+          resolvedType,
+          description: getTokenDescription(token, resolvedTokens),
+        };
+        createPayload.scopes = createScopes;
+        variableChanges.push(createPayload);
+
+        variableModeValues.push(
+          {
+            variableId: tempId,
+            modeId: modes.light.id,
+            value: lightFigmaValue,
+          },
+          {
+            variableId: tempId,
+            modeId: modes.dark.id,
+            value: darkFigmaValue,
+          },
+        );
+
+        stats.created++;
+      }
+    } catch (error) {
+      errors.push(`${tokenPath}: ${error.message}`);
+      stats.errors++;
+    }
+  }
+
+  // Delete primitive variables that are no longer in token source (or were excluded)
+  for (const v of existingVariables) {
+    if (v.name?.startsWith("primitive/") && !keptPrimitiveNames.has(v.name)) {
+      variableChanges.push({ action: "DELETE", id: v.id });
+      stats.deleted++;
+    }
+  }
+
+  return {
+    variableChanges,
+    variableModeValues,
+    stats,
+    errors,
+    tempIdMap,
+  };
+}
+
+module.exports = {
+  buildPrimitiveVariableRequest,
+};