@atlaskit/codemod-cli 0.27.2 → 0.27.4

package/dist/esm/presets/remove-token-fallbacks/utils/normalize-values.js

@@ -0,0 +1,107 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import chalk from 'chalk';
+import { colorToHex, compareHex, isValidColor } from './color-utils';
+
+// so far allowing to remove only exact matches in values. Can be increased to auto-remove fallbacks with similar values
+var ACCEPTABLE_COLOR_DIFFERENCE = 0;
+var ACCEPTABLE_SPACE_DIFFERENCE = 0;
+var ACCEPTABLE_NUMERIC_DIFFERENCE = 0;
+export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
+  var tokenLogValue;
+  var fallbackLogValue;
+  var normalizedTokenValue = tokenValue;
+  var normalizedFallbackValue = fallbackValue;
+  var lowerCaseTokenKey = tokenKey === null || tokenKey === void 0 ? void 0 : tokenKey.toLowerCase();
+  var difference;
+  var isAcceptableDifference;
+  if (lowerCaseTokenKey.startsWith('color') || lowerCaseTokenKey.startsWith('elevation')) {
+    if (tokenValue && isValidColor(tokenValue)) {
+      var normalizedHex = colorToHex(tokenValue);
+      tokenLogValue = chalk.bgHex(normalizedHex)(tokenValue);
+      normalizedTokenValue = normalizedHex;
+    }
+    if (fallbackValue && isValidColor(fallbackValue)) {
+      var _normalizedHex = colorToHex(fallbackValue);
+      fallbackLogValue = chalk.bgHex(_normalizedHex)(fallbackValue);
+      normalizedFallbackValue = _normalizedHex;
+    }
+    if (normalizedTokenValue && normalizedFallbackValue) {
+      difference = compareHex(normalizedTokenValue, normalizedFallbackValue);
+      isAcceptableDifference = difference <= ACCEPTABLE_COLOR_DIFFERENCE;
+    }
+  } else if (lowerCaseTokenKey.startsWith('space')) {
+    var tokenValueInPx = tokenValue ? convertToPx(tokenValue) : undefined;
+    var fallbackValueInPx = fallbackValue ? convertToPx(fallbackValue) : undefined;
+    if (tokenValueInPx !== undefined && fallbackValueInPx !== undefined) {
+      var maxVal = Math.max(tokenValueInPx, fallbackValueInPx);
+      difference = Math.abs(tokenValueInPx - fallbackValueInPx) / maxVal * 100;
+      isAcceptableDifference = difference <= ACCEPTABLE_SPACE_DIFFERENCE;
+    }
+    // Log the normalized values
+    normalizedTokenValue = tokenValue;
+    normalizedFallbackValue = fallbackValue;
+    tokenLogValue = tokenValue;
+    fallbackLogValue = fallbackValue;
+  } else {
+    // Handle other numeric comparisons
+    var tokenValueNumber = parseFloat(tokenValue !== null && tokenValue !== void 0 ? tokenValue : '');
+    var fallbackValueNumber = parseFloat(fallbackValue !== null && fallbackValue !== void 0 ? fallbackValue : '');
+    if (!isNaN(tokenValueNumber) && !isNaN(fallbackValueNumber)) {
+      var _maxVal = Math.max(tokenValueNumber, fallbackValueNumber);
+      difference = Math.abs(tokenValueNumber - fallbackValueNumber) / _maxVal * 100;
+      isAcceptableDifference = difference <= ACCEPTABLE_NUMERIC_DIFFERENCE;
+    }
+    // Log the normalized values
+    normalizedTokenValue = tokenValue;
+    normalizedFallbackValue = fallbackValue;
+    tokenLogValue = tokenValue;
+    fallbackLogValue = fallbackValue;
+  }
+  if (tokenLogValue === undefined) {
+    tokenLogValue = chalk.magenta(tokenValue || '');
+  }
+  if (fallbackLogValue === undefined) {
+    fallbackLogValue = chalk.yellow(fallbackValue || '');
+  }
+  return {
+    difference: difference,
+    isAcceptableDifference: isAcceptableDifference,
+    tokenLogValue: tokenLogValue,
+    fallbackLogValue: fallbackLogValue,
+    normalizedTokenValue: normalizedTokenValue,
+    normalizedFallbackValue: normalizedFallbackValue
+  };
+}
+function convertToPx(value) {
+  // If the value is a number, return it directly
+  if (typeof value === 'number') {
+    return value;
+  }
+  // Check if the string is a plain number (without units)
+  var plainNumberRegex = /^-?\d+(\.\d+)?$/;
+  if (plainNumberRegex.test(value)) {
+    return parseFloat(value);
+  }
+  // Regular expression to match CSS units
+  var unitRegex = /^(-?\d+(\.\d+)?)(px|rem|em|%)$/;
+  var match = value.match(unitRegex);
+  if (!match) {
+    return undefined;
+  }
+  var _match = _slicedToArray(match, 4),
+    num = _match[1],
+    unit = _match[3];
+  var numericValue = parseFloat(num);
+  switch (unit) {
+    case 'px':
+      return numericValue;
+    case 'rem':
+      return numericValue * 16;
+    // Assuming 1rem = 16px
+    case 'em':
+      return numericValue * 16;
+    // Assuming 1em = 16px
+    default:
+      return undefined;
+  }
+}

package/dist/esm/presets/remove-token-fallbacks/utils/remove-unused-imports.js

@@ -0,0 +1,55 @@
+export function removeUnusedImports(importDeclarations, j) {
+  var removeIfUnused = function removeIfUnused(importSpecifier, importDeclaration) {
+    var _importSpecifier$valu;
+    var varName = (_importSpecifier$valu = importSpecifier.value.local) === null || _importSpecifier$valu === void 0 ? void 0 : _importSpecifier$valu.name;
+    if (varName === 'React' || varName === 'jsx') {
+      return false;
+    }
+    var isUsedInScopes = function isUsedInScopes() {
+      return j(importDeclaration).closestScope().find(j.Identifier, {
+        name: varName
+      }).filter(function (p) {
+        var _importSpecifier$valu2;
+        if (p.value.start === ((_importSpecifier$valu2 = importSpecifier.value.local) === null || _importSpecifier$valu2 === void 0 ? void 0 : _importSpecifier$valu2.start)) {
+          return false;
+        }
+        if (p.parentPath.value.type === 'Property' && p.name === 'key') {
+          return false;
+        }
+        if (p.name === 'property') {
+          return false;
+        }
+        return true;
+      }).size() > 0;
+    };
+    if (!isUsedInScopes()) {
+      j(importSpecifier).remove();
+      return true;
+    }
+    return false;
+  };
+  var removeUnusedDefaultImport = function removeUnusedDefaultImport(importDeclaration) {
+    return j(importDeclaration).find(j.ImportDefaultSpecifier).filter(function (s) {
+      return removeIfUnused(s, importDeclaration);
+    }).size() > 0;
+  };
+  var removeUnusedNonDefaultImports = function removeUnusedNonDefaultImports(importDeclaration) {
+    return j(importDeclaration).find(j.ImportSpecifier).filter(function (s) {
+      return removeIfUnused(s, importDeclaration);
+    }).size() > 0;
+  };
+  var processImportDeclaration = function processImportDeclaration(importDeclaration) {
+    var _importDeclaration$va, _importDeclaration$va2;
+    if (((_importDeclaration$va = importDeclaration.value.specifiers) === null || _importDeclaration$va === void 0 ? void 0 : _importDeclaration$va.length) === 0) {
+      return false;
+    }
+    var hadUnusedDefaultImport = removeUnusedDefaultImport(importDeclaration);
+    var hadUnusedNonDefaultImports = removeUnusedNonDefaultImports(importDeclaration);
+    if (((_importDeclaration$va2 = importDeclaration.value.specifiers) === null || _importDeclaration$va2 === void 0 ? void 0 : _importDeclaration$va2.length) === 0) {
+      j(importDeclaration).remove();
+      return true;
+    }
+    return hadUnusedDefaultImport || hadUnusedNonDefaultImports;
+  };
+  importDeclarations.forEach(processImportDeclaration);
+}

package/dist/esm/presets/remove-token-fallbacks/utils/remove-unused-variables.js

@@ -0,0 +1,31 @@
+export function removeUnusedVariables(variableDeclarations, j) {
+  var removeIfUnused = function removeIfUnused(varDeclarator) {
+    var _varDeclarator$value;
+    if (((_varDeclarator$value = varDeclarator.value) === null || _varDeclarator$value === void 0 ? void 0 : _varDeclarator$value.id.type) !== 'Identifier') {
+      return false;
+    }
+    var varName = varDeclarator.value.id.name;
+    var isUsedInScopes = function isUsedInScopes() {
+      return j(varDeclarator).closestScope().find(j.Identifier, {
+        name: varName
+      }).filter(function (p) {
+        if (p.value.start === varDeclarator.value.id.start) {
+          return false;
+        }
+        if (p.parentPath.value.type === 'Property' && p.name === 'key') {
+          return false;
+        }
+        if (p.name === 'property') {
+          return false;
+        }
+        return true;
+      }).size() > 0;
+    };
+    if (!isUsedInScopes()) {
+      j(varDeclarator).remove();
+      return true;
+    }
+    return false;
+  };
+  variableDeclarations.forEach(removeIfUnused);
+}

package/dist/esm/presets/remove-token-fallbacks/utils/reporter.js

@@ -0,0 +1,302 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+/* eslint-disable no-console */
+import fs from 'fs/promises';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+function writeToCsv(_x, _x2) {
+  return _writeToCsv.apply(this, arguments);
+}
+function _writeToCsv() {
+  _writeToCsv = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(filePath, data) {
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return fs.writeFile(filePath, data.join('\n'), 'utf-8');
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _writeToCsv.apply(this, arguments);
+}
+function readCsv(_x3) {
+  return _readCsv.apply(this, arguments);
+}
+function _readCsv() {
+  _readCsv = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(filePath) {
+    var data;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return fs.readFile(filePath, 'utf-8');
+        case 2:
+          data = _context2.sent;
+          return _context2.abrupt("return", data.split('\n').filter(function (line) {
+            return line.trim() !== '';
+          }));
+        case 4:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _readCsv.apply(this, arguments);
+}
+function escapeCsvValue(value) {
+  if (!value) {
+    return value;
+  }
+  if (value.includes('"')) {
+    // Escape double quotes by doubling them
+    value = value.replace(/"/g, '""');
+  }
+  if (value.includes(',') || value.includes('"') || value.includes('\n')) {
+    // Surround the value with double quotes if it contains a comma, double quotes, or newlines
+    value = "\"".concat(value, "\"");
+  }
+  return value;
+}
+export function clearFolder(_x4) {
+  return _clearFolder.apply(this, arguments);
+}
+function _clearFolder() {
+  _clearFolder = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(reportFolder) {
+    var filesToDelete, _iterator, _step, file, filePath;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          console.log('Clearing report folder:', reportFolder);
+          _context3.next = 3;
+          return fs.readdir(reportFolder);
+        case 3:
+          filesToDelete = _context3.sent;
+          _iterator = _createForOfIteratorHelper(filesToDelete);
+          _context3.prev = 5;
+          _iterator.s();
+        case 7:
+          if ((_step = _iterator.n()).done) {
+            _context3.next = 14;
+            break;
+          }
+          file = _step.value;
+          filePath = path.join(reportFolder, file);
+          _context3.next = 12;
+          return fs.unlink(filePath);
+        case 12:
+          _context3.next = 7;
+          break;
+        case 14:
+          _context3.next = 19;
+          break;
+        case 16:
+          _context3.prev = 16;
+          _context3.t0 = _context3["catch"](5);
+          _iterator.e(_context3.t0);
+        case 19:
+          _context3.prev = 19;
+          _iterator.f();
+          return _context3.finish(19);
+        case 22:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[5, 16, 19, 22]]);
+  }));
+  return _clearFolder.apply(this, arguments);
+}
+function saveFilePaths(_x5, _x6) {
+  return _saveFilePaths.apply(this, arguments);
+}
+function _saveFilePaths() {
+  _saveFilePaths = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(reportFolder, files) {
+    var filesTxtPath;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          filesTxtPath = path.join(reportFolder, 'files.txt');
+          _context4.next = 3;
+          return fs.writeFile(filesTxtPath, Array.from(files).map(function (filePath) {
+            return "\"".concat(filePath, "\"");
+          }).join(' '), 'utf-8');
+        case 3:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _saveFilePaths.apply(this, arguments);
+}
+export function combineReports(_x7) {
+  return _combineReports.apply(this, arguments);
+}
+function _combineReports() {
+  _combineReports = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(reportFolder) {
+    var files, totalReplaced, totalNotReplaced, combinedReplacements, combinedNonReplacements, affectedPaths, _iterator2, _step2, file, filePath, replacements, codeFilePaths, _iterator3, _step3, codeFilePath, nonReplacements, totalTokens, percentageReplaced, combinedSummaryPath, summaryData, sortCsvLines, sortedReplacements, sortedNonReplacements, combinedReplacementsPath, header, combinedNonReplacementsPath;
+    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          console.log('Combining reports in folder:', reportFolder);
+          _context5.next = 3;
+          return fs.readdir(reportFolder);
+        case 3:
+          files = _context5.sent;
+          totalReplaced = 0;
+          totalNotReplaced = 0;
+          combinedReplacements = [];
+          combinedNonReplacements = [];
+          affectedPaths = new Set();
+          _iterator2 = _createForOfIteratorHelper(files);
+          _context5.prev = 10;
+          _iterator2.s();
+        case 12:
+          if ((_step2 = _iterator2.n()).done) {
+            _context5.next = 34;
+            break;
+          }
+          file = _step2.value;
+          filePath = path.join(reportFolder, file);
+          if (!file.endsWith('_success.csv')) {
+            _context5.next = 26;
+            break;
+          }
+          _context5.next = 18;
+          return readCsv(filePath);
+        case 18:
+          replacements = _context5.sent;
+          codeFilePaths = replacements.map(function (x) {
+            return x.split(',')[2];
+          });
+          _iterator3 = _createForOfIteratorHelper(codeFilePaths);
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              codeFilePath = _step3.value;
+              affectedPaths.add(codeFilePath);
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+          totalReplaced += replacements.length;
+          combinedReplacements.push.apply(combinedReplacements, _toConsumableArray(replacements));
+          _context5.next = 32;
+          break;
+        case 26:
+          if (!file.endsWith('_failed.csv')) {
+            _context5.next = 32;
+            break;
+          }
+          _context5.next = 29;
+          return readCsv(filePath);
+        case 29:
+          nonReplacements = _context5.sent;
+          totalNotReplaced += nonReplacements.length;
+          combinedNonReplacements.push.apply(combinedNonReplacements, _toConsumableArray(nonReplacements));
+        case 32:
+          _context5.next = 12;
+          break;
+        case 34:
+          _context5.next = 39;
+          break;
+        case 36:
+          _context5.prev = 36;
+          _context5.t0 = _context5["catch"](10);
+          _iterator2.e(_context5.t0);
+        case 39:
+          _context5.prev = 39;
+          _iterator2.f();
+          return _context5.finish(39);
+        case 42:
+          totalTokens = totalReplaced + totalNotReplaced;
+          percentageReplaced = totalTokens > 0 ? totalReplaced / totalTokens * 100 : 0;
+          _context5.next = 46;
+          return clearFolder(reportFolder);
+        case 46:
+          // Write combined summary as JSON
+          combinedSummaryPath = path.join(reportFolder, 'summary.json');
+          summaryData = {
+            totalReplaced: totalReplaced,
+            totalNotReplaced: totalNotReplaced,
+            percentageReplaced: percentageReplaced
+          };
+          _context5.next = 50;
+          return fs.writeFile(combinedSummaryPath, JSON.stringify(summaryData, null, 2), 'utf-8');
+        case 50:
+          // Sort the combined arrays
+          sortCsvLines = function sortCsvLines(lines) {
+            return lines.sort(function (a, b) {
+              var aCols = a.split(',');
+              var bCols = b.split(',');
+              for (var i = 0; i < 4; i++) {
+                var comparison = aCols[i].localeCompare(bCols[i]);
+                if (comparison !== 0) {
+                  return comparison;
+                }
+              }
+              return 0;
+            });
+          };
+          sortedReplacements = sortCsvLines(combinedReplacements);
+          sortedNonReplacements = sortCsvLines(combinedNonReplacements); // Write combined replacements
+          combinedReplacementsPath = path.join(reportFolder, 'success.csv');
+          header = 'Team,Package,File,Line Number,Raw Token Key,Raw Fallback Value,Resolved Token Value,Resolved Fallback Value,Difference %';
+          _context5.next = 57;
+          return fs.writeFile(combinedReplacementsPath, [header].concat(_toConsumableArray(sortedReplacements)).join('\n'), 'utf-8');
+        case 57:
+          // Write combined non-replacements
+          combinedNonReplacementsPath = path.join(reportFolder, 'failed.csv');
+          _context5.next = 60;
+          return fs.writeFile(combinedNonReplacementsPath, [header].concat(_toConsumableArray(sortedNonReplacements)).join('\n'), 'utf-8');
+        case 60:
+          _context5.next = 62;
+          return saveFilePaths(reportFolder, affectedPaths);
+        case 62:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5, null, [[10, 36, 39, 42]]);
+  }));
+  return _combineReports.apply(this, arguments);
+}
+function prepareCsvData(items) {
+  return items.map(function (item) {
+    var _item$difference$toFi, _item$difference;
+    return [escapeCsvValue(item.teamInfo.teamName), escapeCsvValue(item.teamInfo.packageName), escapeCsvValue(item.filePath), escapeCsvValue(String(item.lineNumber)), escapeCsvValue(item.tokenKey), escapeCsvValue(item.rawFallbackValue), escapeCsvValue(item.resolvedTokenValue), escapeCsvValue(item.resolvedFallbackValue), escapeCsvValue((_item$difference$toFi = (_item$difference = item.difference) === null || _item$difference === void 0 ? void 0 : _item$difference.toFixed(1)) !== null && _item$difference$toFi !== void 0 ? _item$difference$toFi : '')].join(',');
+  });
+}
+export function writeReports(_x8, _x9) {
+  return _writeReports.apply(this, arguments);
+}
+function _writeReports() {
+  _writeReports = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(details, reportFolder) {
+    var replacementsFilePath, nonReplacementsFilePath, replacementData, nonReplacementData;
+    return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          replacementsFilePath = path.join(reportFolder, "".concat(uuidv4(), "_success.csv"));
+          nonReplacementsFilePath = path.join(reportFolder, "".concat(uuidv4(), "_failed.csv"));
+          _context6.next = 4;
+          return fs.mkdir(reportFolder, {
+            recursive: true
+          });
+        case 4:
+          replacementData = prepareCsvData(details.replaced);
+          nonReplacementData = prepareCsvData(details.notReplaced);
+          _context6.next = 8;
+          return Promise.all([writeToCsv(replacementsFilePath, replacementData), writeToCsv(nonReplacementsFilePath, nonReplacementData)]);
+        case 8:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  }));
+  return _writeReports.apply(this, arguments);
+}