figma-tokens-flattener 1.0.13 → 1.0.15

package/index.js

@@ -76,7 +76,7 @@ function flattenSeedTokens(seedTokens) {
 
         flattened[tokenName] = valueToUse;
     })
-    
+
     return flattened;
 }
 
@@ -198,34 +198,26 @@ function flattenMapTokensWrapper(mapTokens, seedContext) {
 
 function processSingleShadow(shadowDef, contextTokens) {
     if (!shadowDef || typeof shadowDef !== 'object') {
-        console.warn('  processSingleShadow: Ожидаемый объект тени, получен:', shadowDef);
         return undefined;
     }
 
-    // Проверим наличие необходимых свойств (используем 'in' или 'hasOwn' как рекомендовал тимлид)
-    // Но для простоты и т.к. структура известна, можно просто проверить тип.
-    // Проверим, есть ли хотя бы 'x', 'y', 'color' как минимум.
     if (typeof shadowDef.x === 'undefined' || typeof shadowDef.y === 'undefined' || typeof shadowDef.color === 'undefined') {
-        console.warn('  processSingleShadow: Неверная структура тени, отсутствуют x, y или color:', shadowDef);
+        console.warn('Invalid shadow structure, missing x, y or color:', shadowDef);
         return undefined;
     }
 
-    // Извлекаем и обрабатываем значения
-    // Используем flattenMapTokens для разрешения ссылок и вычисления выражений
     const x = flattenMapTokens(shadowDef.x, contextTokens);
     const y = flattenMapTokens(shadowDef.y, contextTokens);
-    const blur = flattenMapTokens(shadowDef.blur || '0', contextTokens); // Значение по умолчанию
-    const spread = flattenMapTokens(shadowDef.spread || '0', contextTokens); // Значение по умолчанию
+    const blur = flattenMapTokens(shadowDef.blur || '0', contextTokens);
+    const spread = flattenMapTokens(shadowDef.spread || '0', contextTokens);
     const color = flattenMapTokens(shadowDef.color, contextTokens);
 
-    // Проверяем, все ли значения числовые (или цвет для color)
-    // flattenMapTokens может вернуть число, строку или undefined
     if (typeof x !== 'number' || typeof y !== 'number' || typeof blur !== 'number' || typeof spread !== 'number' || typeof color !== 'string') {
-        console.warn(`    Неверный тип значения в тени: x=${x}(${typeof x}), y=${y}(${typeof y}), blur=${blur}(${typeof blur}), spread=${spread}(${typeof spread}), color=${color}(${typeof color})`);
-        return undefined; // Возвращаем undefined, чтобы пропустить эту тень
+        console.warn(`Invalid value type in shadow: x=${x}(${typeof x}), y=${y}(${typeof y}), blur=${blur}(${typeof blur}), spread=${spread}(${typeof spread}), color=${color}(${typeof color})`);
+        return undefined;
     }
 
-    // Формируем строку для одной тени
+    // Forming a line for one shadow
     return `${x}px ${y}px ${blur}px ${spread}px ${color}`;
 }
 
@@ -233,13 +225,13 @@ function processBoxShadow(shadowData, contextTokens) {
     let shadowsArray;
 
     if (Array.isArray(shadowData)) {
-        // Это массив теней
+        // This is an array of shadows
         shadowsArray = shadowData;
     } else if (typeof shadowData === 'object' && shadowData !== null) {
-        // Это одиночный объект тени, обернём в массив для унификации
+        // This is a single shadow object
         shadowsArray = [shadowData];
     } else {
-        console.warn('  processBoxShadow: Ожидаемый массив или объект тени, получен:', shadowData);
+        console.warn('Expected array or shadow object, received::', shadowData);
         return undefined;
     }
 
@@ -252,24 +244,20 @@ function processBoxShadow(shadowData, contextTokens) {
     }
 
     if (processedShadows.length === 0) {
-        console.warn('  processBoxShadow: Не удалось обработать ни одной тени.');
         return undefined;
     }
 
-    // Объединяем все строки теней в одну строку boxShadow
+    // Combining all the shadow lines into one boxShadow line
     return processedShadows.join(', ');
 }
 
 function flattenAliasTokens(aliasTokens, contextTokens) {
     const flattened = {};
     if (!aliasTokens || typeof aliasTokens !== 'object') {
-        console.warn('  Ожидался объект с alias токенами, но получен:', aliasTokens);
+        console.warn('An object with alias tokens was expected, but received:', aliasTokens);
         return flattened;
     }
 
-    console.log('    Вычисление alias токенов...');
-
-    // --- ЗАМЕНЕНО: for...in на Object.keys().forEach() ---
     Object.keys(aliasTokens).forEach((tokenName) => {
         const tokenContent = aliasTokens[tokenName];
 
@@ -277,226 +265,31 @@ function flattenAliasTokens(aliasTokens, contextTokens) {
             return;
         }
 
-        // Проверяем, что объект имеет ожидаемую структуру { "value": "..." }
-        // --- ИСПРАВЛЕНО: Используем Object.hasOwn вместо hasOwnProperty ---
         if (tokenContent && typeof tokenContent === 'object' && Object.hasOwn(tokenContent, 'value')) {
-            // --- НОВАЯ ПРОВЕРКА: boxShadow (новый формат) ---
-            // Проверим, является ли value массивом или объектом с x, y, color
             if (
                 (Array.isArray(tokenContent.value) && tokenContent.value.length > 0) ||
                 (typeof tokenContent.value === 'object' && tokenContent.value !== null && Object.hasOwn(tokenContent.value, 'x'))
             ) {
-                // Обработка новой структуры boxShadow (одиночный или множественный)
                 const boxShadowValue = processBoxShadow(tokenContent.value, contextTokens);
                 if (boxShadowValue !== undefined) {
                     flattened[tokenName] = boxShadowValue;
-                    console.log(`      ${tokenName}: (boxShadow array/object structure) -> ${boxShadowValue}`);
                 } else {
-                    console.warn(`      ${tokenName}: Не удалось обработать boxShadow структуру.`, tokenContent.value);
-                    // Можно добавить как есть или пропустить
-                    // flattened[tokenName] = tokenContent.value;
+                    console.warn(`${tokenName}: The boxShadow structure could not be processed.`, tokenContent.value);
                 }
             }
-            // --- КОНЕЦ НОВОЙ ПРОВЕРКИ ---
             else {
-                // Это стандартный токен: { "value": "..." }
                 const rawValue = tokenContent.value;
-                // Обрабатываем значение с помощью вспомогательной функции, аналогичной для map
-                // Она должна уметь разрешать ссылки и вычислять выражения
                 const processedValue = flattenMapTokens(rawValue, contextTokens);
                 flattened[tokenName] = processedValue;
-                // console.log(`      ${tokenName}: ${rawValue} -> ${processedValue}`); // Опционально: подробное логирование
             }
         } else {
-            // --- УБРАНО: Проверки на { "style": { "value": ... } } ---
-            // Неизвестная структура, просто добавим как есть или выведем предупреждение
-            console.warn(`    Неподдерживаемая структура для alias токена ${tokenName}:`, tokenContent);
-            // Можно добавить как есть, если нужно сохранить:
-            // flattened[tokenName] = tokenContent;
+            console.warn(`Unsupported structure for alias token ${tokenName}:`, tokenContent);
         }
     });
-    // --- КОНЕЦ ИЗМЕНЕНИЯ: Закрывающая скобка для forEach ---
-    console.log(`    Вычислено ${Object.keys(flattened).length} alias токенов.`);
+
     return flattened;
 }
 
-// function isDropShadowStructure(obj) {
-//     if (!obj || typeof obj !== 'object') {
-//         return false;
-//     }
-
-//     const keys = Object.keys(obj);
-//     if (keys.length === 0) {
-//         return false;
-//     }
-
-//     for (const key of keys) {
-//         if (isNaN(key)) {
-//             return false;
-//         }
-//     }
-
-//     const firstShadow = obj[keys[0]];
-//     if (!firstShadow || typeof firstShadow !== 'object') {
-//         return false;
-//     }
-
-//     const expectedProps = ['x', 'y', 'blur', 'spread', 'color', 'type'];
-//     for (const prop of expectedProps) {
-//         if (!firstShadow.hasOwnProperty(prop)) {
-//             return false;
-//         }
-//     }
-
-//     for (const coordProp of ['x', 'y', 'blur', 'spread']) {
-//         if (!firstShadow[coordProp] || typeof firstShadow[coordProp] !== 'object' || !firstShadow[coordProp].hasOwnProperty('value')) {
-//             return false;
-//         }
-//     }
-
-//     if (!firstShadow.color || typeof firstShadow.color !== 'object' || !firstShadow.color.hasOwnProperty('value')) {
-//         return false;
-//     }
-
-//     if (firstShadow.type?.value !== 'dropShadow' && firstShadow.type !== 'dropShadow') {
-//         return false;
-//     }
-
-//     // If the first shadow has passed the test, we will check the rest.
-//     for (const key of keys) {
-//         const shadow = obj[key];
-//         if (!shadow || typeof shadow !== 'object') {
-//             return false;
-//         }
-//         for (const coordProp of ['x', 'y', 'blur', 'spread']) {
-//             if (!shadow[coordProp] || typeof shadow[coordProp] !== 'object' || !shadow[coordProp].hasOwnProperty('value')) {
-//                 return false;
-//             }
-//         }
-//         if (!shadow.color || typeof shadow.color !== 'object' || !shadow.color.hasOwnProperty('value')) {
-//             return false;
-//         }
-//         if (shadow.type?.value !== 'dropShadow' && shadow.type !== 'dropShadow') {
-//             return false;
-//         }
-//     }
-
-//     return true;
-// }
-
-// /* Checks whether the object is a single dropShadow structure. */
-// function isSingleDropShadowStructure(obj) {
-//     if (!obj || typeof obj !== 'object') {
-//         return false;
-//     }
-
-//     const expectedProps = ['x', 'y', 'blur', 'spread', 'color', 'type'];
-//     for (const prop of expectedProps) {
-//         if (!obj.hasOwnProperty(prop)) {
-//             return false;
-//         }
-//     }
-
-//     for (const coordProp of ['x', 'y', 'blur', 'spread']) {
-//         if (!obj[coordProp] || typeof obj[coordProp] !== 'object' || !obj[coordProp].hasOwnProperty('value')) {
-//             return false;
-//         }
-//     }
-
-//     if (!obj.color || typeof obj.color !== 'object' || !obj.color.hasOwnProperty('value')) {
-//         return false;
-//     }
-
-//     if (obj.type?.value !== 'dropShadow' && obj.type !== 'dropShadow') {
-//         return false;
-//     }
-
-//     return true;
-// }
-
-// /* Collects the boxShadow string from the dropShadow structure (multiple). */
-// function buildBoxShadowString(shadowStructure, contextTokens) {
-//     const shadowParts = [];
-//     const keys = Object.keys(shadowStructure).sort((a, b) => parseInt(a) - parseInt(b));
-
-//     for (const key of keys) {
-//         const shadowDef = shadowStructure[key];
-//         const shadowString = buildSingleShadowString(shadowDef, contextTokens);
-//         if (shadowString) {
-//             shadowParts.push(shadowString);
-//         }
-//     }
-
-//     // Combine all the shadows into one line
-//     return shadowParts.join(', ');
-// }
-
-// /* Collects a row for one shadow from the dropShadow structure. */
-// function buildSingleShadowString(singleShadowDef, contextTokens) {
-//     // Extracting and calculating the values
-//     const x = flattenMapTokens(singleShadowDef.x.value, contextTokens);
-//     const y = flattenMapTokens(singleShadowDef.y.value, contextTokens);
-//     const blur = flattenMapTokens(singleShadowDef.blur.value, contextTokens);
-//     const spread = flattenMapTokens(singleShadowDef.spread.value, contextTokens);
-//     const color = flattenMapTokens(singleShadowDef.color.value, contextTokens);
-
-//     // Checking if all values are numeric (or color)
-//     if (typeof x !== 'number' || typeof y !== 'number' || typeof blur !== 'number' || typeof spread !== 'number' || typeof color !== 'string') {
-//         console.warn(`Invalid value type in dropShadow: x=${x}(${typeof x}), y=${y}(${typeof y}), blur=${blur}(${typeof blur}), spread=${spread}(${typeof spread}), color=${color}(${typeof color})`);
-//         return undefined; // Returning undefined to skip this shadow
-//     }
-
-//     // Forming a row for one shadow
-//     return `${x}px ${y}px ${blur}px ${spread}px ${color}`;
-// }
-
-
-// /* An auxiliary function for converting the alias token structure. */
-// function flattenAliasTokens(aliasTokens, contextTokens) {
-//     const flattened = {};
-//     if (!aliasTokens || typeof aliasTokens !== 'object') {
-//         console.warn('An object with alias tokens was expected, but received:', aliasTokens);
-//         return flattened;
-//     }
-
-//     Object.keys(aliasTokens).forEach((tokenName) => {
-//         const tokenContent = aliasTokens[tokenName];
-
-//         if (tokenName[0] === tokenName[0].toUpperCase()) {
-//             return;
-//         }
-
-//         if (tokenContent && typeof tokenContent === 'object' && tokenContent.hasOwnProperty('value')) {
-//             const rawValue = tokenContent.value;
-//             const processedValue = flattenMapTokens(rawValue, contextTokens);
-
-//             flattened[tokenName] = processedValue;
-//         } else {
-//             // It can be a complex token, for example, a boxShadow (multiple or single)
-//             if (isDropShadowStructure(tokenContent)) {
-
-//                 // boxShadow structure processing (multiple)
-//                 const boxShadowValue = buildBoxShadowString(tokenContent, contextTokens);
-//                 flattened[tokenName] = boxShadowValue;
-
-//             } else if (isSingleDropShadowStructure(tokenContent)) {
-//                 // Processing the structure of a single shadow
-//                 const singleShadowValue = buildSingleShadowString(tokenContent, contextTokens);
-
-//                 if (singleShadowValue) {
-//                     flattened[tokenName] = singleShadowValue;
-//                 } else {
-//                     console.warn(`Couldn't form a line for a single shadow ${tokenName}:`, tokenContent);
-//                 }
-//             } else {
-//                 console.warn(`Unsupported structure for alias token ${tokenName}:`, tokenContent);
-//             }
-//         }
-//     })
-
-//     return flattened;
-// };
-
 function checkAndResolveVarValues(contextTokens) {
     const resolved = {};
 

package/package.json

@@ -1,16 +1,24 @@
-{
-  "name": "figma-tokens-flattener",
-  "version": "1.0.13",
-  "description": "A tool for transforming Ant Design tokens from Tokens Studio for Figma (Single file) into flat style mappings for light and dark themes.",
-  "main": "index.js",
-    "bin": {
-    "figma-tokens-flattener": "index.js"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "test:local": "node index.js"
-  },
-  "keywords": ["figma", "design-tokens", "tokens", "json", "flattener", "transformer", "parser"],
-  "author": "Yurii Sudarskii",
-  "license": "ISC"
-}
+{
+  "name": "figma-tokens-flattener",
+  "version": "1.0.15",
+  "description": "A tool for transforming Ant Design tokens from Tokens Studio for Figma (Single file) into flat style mappings for light and dark themes.",
+  "main": "index.js",
+    "bin": {
+    "figma-tokens-flattener": "index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jurassic-period/figma-tokens-flattener.git"
+  },
+  "homepage": "https://github.com/jurassic-period/figma-tokens-flattener#readme",
+  "bugs": {
+    "url": "https://github.com/jurassic-period/figma-tokens-flattener/issues"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "test:local": "node index.js"
+  },
+  "keywords": ["figma", "design-tokens", "tokens", "json", "flattener", "transformer", "parser"],
+  "author": "Yurii Sudarskii",
+  "license": "ISC"
+}