@atlaskit/codemod-cli 0.27.2 → 0.27.3

package/dist/esm/main.js

@@ -128,7 +128,7 @@ var resolveTransform = /*#__PURE__*/function () {
 }();
 var runTransform = /*#__PURE__*/function () {
   var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(filePaths, transform, flags) {
-    var logger, codemodDirs, transformPath, args, jscodeshiftContent, jscodeshiftContentNew;
+    var logger, codemodDirs, transformPath, args, jscodeshiftContent, jscodeshiftContentNew, transformModule;
     return _regeneratorRuntime.wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
@@ -172,11 +172,31 @@ var runTransform = /*#__PURE__*/function () {
           jscodeshiftContent = fs.readFileSync(jscodeshift, 'utf8');
           jscodeshiftContentNew = fixLineEnding(jscodeshiftContent, 'LF');
           fs.writeFileSync(jscodeshift, jscodeshiftContentNew);
-          _context3.next = 18;
+          try {
+            transformModule = require(transformPath);
+          } catch (error) {
+            // eslint-disable-next-line no-console
+            console.warn("Error loading transform module: ".concat(transformPath, ". Skipping lifecycle hooks."));
+          }
+          if (!transformModule) {
+            _context3.next = 20;
+            break;
+          }
+          _context3.next = 20;
+          return processLifecycleHook('beforeAll', transformModule, logger, transform, flags);
+        case 20:
+          _context3.next = 22;
           return spawn(jscodeshift, args, {
             stdio: 'inherit'
           });
-        case 18:
+        case 22:
+          if (!transformModule) {
+            _context3.next = 25;
+            break;
+          }
+          _context3.next = 25;
+          return processLifecycleHook('afterAll', transformModule, logger, transform, flags);
+        case 25:
         case "end":
           return _context3.stop();
       }
@@ -282,23 +302,55 @@ var defaultFlags = {
   ignorePattern: 'node_modules',
   logger: console
 };
-export default function main(_x9, _x10) {
+function processLifecycleHook(_x9, _x10, _x11, _x12, _x13) {
+  return _processLifecycleHook.apply(this, arguments);
+}
+function _processLifecycleHook() {
+  _processLifecycleHook = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(hookName, transformModule, logger, transform, flags) {
+    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          if (!(typeof transformModule[hookName] === 'function')) {
+            _context5.next = 11;
+            break;
+          }
+          _context5.prev = 1;
+          logger.log(chalk.green("Executing ".concat(hookName, " for transform '").concat(transform.name, "'...")));
+          _context5.next = 5;
+          return transformModule[hookName](flags);
+        case 5:
+          _context5.next = 11;
+          break;
+        case 7:
+          _context5.prev = 7;
+          _context5.t0 = _context5["catch"](1);
+          logger.log(chalk.red("Error in ".concat(hookName, " for transform '").concat(transform.name, "': ").concat(_context5.t0)));
+          throw _context5.t0;
+        case 11:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5, null, [[1, 7]]);
+  }));
+  return _processLifecycleHook.apply(this, arguments);
+}
+export default function main(_x14, _x15) {
   return _main.apply(this, arguments);
 }
 function _main() {
-  _main = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(input, userFlags) {
+  _main = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(input, userFlags) {
     var flags, logger, _yield$parseArgs, packages, _process$env$_PACKAGE, _PACKAGE_VERSION_, shouldHavePackages, availableTransforms, transforms, transformsWithModule, _iterator, _step, transform;
-    return _regeneratorRuntime.wrap(function _callee5$(_context5) {
-      while (1) switch (_context5.prev = _context5.next) {
+    return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
         case 0:
           flags = _objectSpread(_objectSpread({}, defaultFlags), userFlags);
           logger = flags.logger;
-          _context5.next = 4;
+          _context6.next = 4;
           return parseArgs(input, flags);
         case 4:
-          _yield$parseArgs = _context5.sent;
+          _yield$parseArgs = _context6.sent;
           packages = _yield$parseArgs.packages;
-          _process$env$_PACKAGE = "0.27.2", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+          _process$env$_PACKAGE = "0.27.3", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
           logger.log(chalk.bgBlue(chalk.black("\uD83D\uDCDA Atlassian-Frontend codemod library @ ".concat(_PACKAGE_VERSION_, " \uD83D\uDCDA"))));
           if (packages && packages.length > 0) {
             logger.log(chalk.gray("Searching for codemods for newer versions of the following packages: ".concat(packages.map(function (pkg) {
@@ -307,36 +359,36 @@ function _main() {
           }
           shouldHavePackages = flags.sinceRef || flags.packages && flags.packages.length > 0;
           if (!(shouldHavePackages && (packages === null || packages === void 0 ? void 0 : packages.length) === 0)) {
-            _context5.next = 13;
+            _context6.next = 13;
             break;
           }
           logger.log(chalk.gray("Did not find updated packages, exiting"));
-          return _context5.abrupt("return", {
+          return _context6.abrupt("return", {
             transforms: []
           });
         case 13:
           availableTransforms = getTransforms(packages);
           if (!(availableTransforms.length === 0)) {
-            _context5.next = 16;
+            _context6.next = 16;
             break;
           }
           throw new NoTransformsExistError('No codemods available. Please make sure you have the latest version of the packages you are trying to upgrade before running the codemod');
         case 16:
           if (!packages) {
-            _context5.next = 20;
+            _context6.next = 20;
             break;
           }
-          _context5.t0 = availableTransforms;
-          _context5.next = 24;
+          _context6.t0 = availableTransforms;
+          _context6.next = 24;
           break;
         case 20:
-          _context5.next = 22;
+          _context6.next = 22;
           return resolveTransform(flags, availableTransforms);
         case 22:
-          _context5.t1 = _context5.sent;
-          _context5.t0 = [_context5.t1];
+          _context6.t1 = _context6.sent;
+          _context6.t0 = [_context6.t1];
         case 24:
-          transforms = _context5.t0;
+          transforms = _context6.t0;
           transformsWithModule = transforms.map(function (transform) {
             return _objectSpread(_objectSpread({}, transform), {}, {
               module: getTransformModule(transform)
@@ -346,39 +398,39 @@ function _main() {
             return "".concat(transform.module, ": ").concat(transform.name);
           }).join('\n')))));
           _iterator = _createForOfIteratorHelper(transformsWithModule);
-          _context5.prev = 28;
+          _context6.prev = 28;
           _iterator.s();
         case 30:
           if ((_step = _iterator.n()).done) {
-            _context5.next = 36;
+            _context6.next = 36;
             break;
           }
           transform = _step.value;
-          _context5.next = 34;
+          _context6.next = 34;
           return runTransform(input, transform, flags);
         case 34:
-          _context5.next = 30;
+          _context6.next = 30;
           break;
         case 36:
-          _context5.next = 41;
+          _context6.next = 41;
           break;
         case 38:
-          _context5.prev = 38;
-          _context5.t2 = _context5["catch"](28);
-          _iterator.e(_context5.t2);
+          _context6.prev = 38;
+          _context6.t2 = _context6["catch"](28);
+          _iterator.e(_context6.t2);
         case 41:
-          _context5.prev = 41;
+          _context6.prev = 41;
           _iterator.f();
-          return _context5.finish(41);
+          return _context6.finish(41);
         case 44:
-          return _context5.abrupt("return", {
+          return _context6.abrupt("return", {
             transforms: transformsWithModule
           });
         case 45:
         case "end":
-          return _context5.stop();
+          return _context6.stop();
       }
-    }, _callee5, null, [[28, 38, 41, 44]]);
+    }, _callee6, null, [[28, 38, 41, 44]]);
   }));
   return _main.apply(this, arguments);
 }

package/dist/esm/presets/index.js

@@ -10,7 +10,8 @@ import './migrate-to-link/migrate-to-link';
 import './migrate-to-new-buttons/migrate-to-new-buttons';
 import './upgrade-pragmatic-drag-and-drop-to-stable/upgrade-pragmatic-drag-and-drop-to-stable';
 import './remove-dark-theme-vr-options/remove-dark-theme-vr-options';
-var presets = ['styled-to-emotion', 'theme-remove-deprecated-mixins', 'migrate-to-link', 'migrate-to-new-buttons', 'upgrade-pragmatic-drag-and-drop-to-stable', 'remove-dark-theme-vr-options'].map(function (preset) {
+import './remove-token-fallbacks/remove-token-fallbacks';
+var presets = ['styled-to-emotion', 'theme-remove-deprecated-mixins', 'migrate-to-link', 'migrate-to-new-buttons', 'upgrade-pragmatic-drag-and-drop-to-stable', 'remove-dark-theme-vr-options', 'remove-token-fallbacks'].map(function (preset) {
   return path.join(__dirname, preset, "".concat(preset, ".@(ts|js|tsx)"));
 });
 export default presets;

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

@@ -0,0 +1,215 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+/* eslint-disable no-console */
+import { exec } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { promisify } from 'util';
+import { hasImportDeclaration } from '@hypermod/utils';
+import { findRoot } from '@manypkg/find-root';
+import chalk from 'chalk';
+import { getTokenMap } from './utils/all-tokens';
+import { getTeamInfo } from './utils/get-team-info';
+import { removeUnusedImports } from './utils/remove-unused-imports';
+import { removeUnusedVariables } from './utils/remove-unused-variables';
+import { clearFolder, combineReports, writeReports } from './utils/reporter';
+import { TokenProcessor } from './utils/token-processor';
+var execAsync = promisify(exec);
+
+/**
+ * Transforms the source code of a file by removing fallback values from the @atlaskit/tokens/token functions.
+ * By default removes only the fallbacks that have the same values as the tokens.
+ *
+ * @param {FileInfo} fileInfo - Information about the file to be transformed.
+ * @param {API} api - The jscodeshift API, providing utilities for AST transformations.
+ * @param {RemoveTokenFallbackOptions} options - Options for the transformation, including:
+ *   @param {boolean} [options.verbose] - If true, enables verbose logging.
+ *   @param {boolean} [options.forceUpdate] - If true, removes the fallbacks regardless of the difference between token and fallback. Otherwise removes only the fallbacks that are equal to the token values.
+ *   @param {boolean} [options.addEslintComments] - If true, adds the eslint ignore comment for the rule @atlaskit/design-system/no-unsafe-design-token-usage for the fallbacks that weren't removed.
+ *   @param {boolean} [options.useLegacyColorTheme] - If true, uses the legacy theme for color token mapping.
+ *   @param {string} [options.reportFolder] - Directory path to output transformation reports. Reports will be generated only if this option is provided.
+ *   @param {boolean} [options.dry] - If true, performs a dry run without modifying the files.
+ *
+ * @returns {Promise<string>} A promise that resolves to the transformed source code as a string.
+ */
+export default function transformer(_x, _x2, _x3) {
+  return _transformer.apply(this, arguments);
+}
+function _transformer() {
+  _transformer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(fileInfo, _ref, options) {
+    var _options$useLegacyCol;
+    var j, rootDir, source, details, tokenMap, teamInfo, transformPromises, results, unusedVars, allImports, allVars;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          j = _ref.jscodeshift;
+          _context.next = 3;
+          return findRoot(path.dirname(fileInfo.path));
+        case 3:
+          rootDir = _context.sent;
+          source = j(fileInfo.source);
+          if (hasImportDeclaration(j, source, '@atlaskit/tokens')) {
+            _context.next = 7;
+            break;
+          }
+          return _context.abrupt("return", fileInfo.source);
+        case 7:
+          details = {
+            replaced: [],
+            notReplaced: []
+          };
+          if (options.verbose) {
+            console.log(chalk.yellow("Using ".concat(options.useLegacyColorTheme ? 'legacy light' : 'light', " theme.")));
+          }
+          tokenMap = getTokenMap((_options$useLegacyCol = options.useLegacyColorTheme) !== null && _options$useLegacyCol !== void 0 ? _options$useLegacyCol : false);
+          _context.next = 12;
+          return getTeamInfo(fileInfo.path);
+        case 12:
+          teamInfo = _context.sent;
+          transformPromises = source.find(j.CallExpression, {
+            callee: {
+              type: 'Identifier',
+              name: 'token'
+            }
+          }).paths().map(function (callPath) {
+            var processor = new TokenProcessor(j, options, fileInfo, source, rootDir, details, tokenMap, teamInfo);
+            return processor.processAndLogSingleToken(callPath);
+          });
+          _context.next = 16;
+          return Promise.all(transformPromises);
+        case 16:
+          results = _context.sent;
+          unusedVars = [];
+          if (results.some(function (result) {
+            return result.fallbackRemoved;
+          })) {
+            allImports = results.flatMap(function (result) {
+              var _result$resolvedImpor;
+              return (_result$resolvedImpor = result.resolvedImportDeclaration) !== null && _result$resolvedImpor !== void 0 ? _result$resolvedImpor : [];
+            });
+            allVars = results.flatMap(function (result) {
+              var _result$resolvedLocal;
+              return (_result$resolvedLocal = result.resolvedLocalVarDeclaration) !== null && _result$resolvedLocal !== void 0 ? _result$resolvedLocal : [];
+            });
+            unusedVars.push.apply(unusedVars, _toConsumableArray(allVars));
+            if (allImports.length) {
+              if (options.verbose) {
+                console.log(chalk.green("".concat(fileInfo.path, ": Some fallbacks were removed. Cleaning up ").concat(allImports.length, " imports.")));
+              }
+              removeUnusedImports(allImports, j);
+            }
+          }
+          removeUnusedVariables(unusedVars, j);
+          if (!options.reportFolder) {
+            _context.next = 23;
+            break;
+          }
+          _context.next = 23;
+          return writeReports(details, options.reportFolder);
+        case 23:
+          if (!options.dry) {
+            _context.next = 28;
+            break;
+          }
+          if (options.verbose) {
+            console.log(chalk.cyan("".concat(fileInfo.path, ": dry run mode active. Source was not modified.")));
+          }
+          // Return the unmodified source if dryRun is true
+          return _context.abrupt("return", fileInfo.source);
+        case 28:
+          return _context.abrupt("return", source.toSource());
+        case 29:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _transformer.apply(this, arguments);
+}
+export var parser = 'tsx';
+
+/**
+ * Function executed before all transformations to prepare the environment by clearing the report folder.
+ */
+export function beforeAll(_x4) {
+  return _beforeAll.apply(this, arguments);
+}
+
+/**
+ * Function executed after all transformations to combine individual file reports into a comprehensive transformation report.
+ * It also applies prettier to the affected files.
+ */
+function _beforeAll() {
+  _beforeAll = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(options) {
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          if (!options.reportFolder) {
+            _context2.next = 3;
+            break;
+          }
+          _context2.next = 3;
+          return clearFolder(options.reportFolder);
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _beforeAll.apply(this, arguments);
+}
+export function afterAll(_x5) {
+  return _afterAll.apply(this, arguments);
+}
+function _afterAll() {
+  _afterAll = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(options) {
+    var filesTxtPath, fileContent;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          if (!options.reportFolder) {
+            _context3.next = 3;
+            break;
+          }
+          _context3.next = 3;
+          return combineReports(options.reportFolder);
+        case 3:
+          if (!(options.reportFolder && !options.dry)) {
+            _context3.next = 19;
+            break;
+          }
+          _context3.prev = 4;
+          filesTxtPath = path.join(options.reportFolder, 'files.txt');
+          _context3.next = 8;
+          return fs.readFile(filesTxtPath, 'utf-8');
+        case 8:
+          fileContent = _context3.sent;
+          if (!(fileContent.length > 0)) {
+            _context3.next = 14;
+            break;
+          }
+          console.log("Running prettier on files: ".concat(chalk.magenta(fileContent)));
+          _context3.next = 13;
+          return execAsync("yarn prettier --write ".concat(fileContent));
+        case 13:
+          console.log(chalk.green("Prettier was run successfully"));
+        case 14:
+          _context3.next = 19;
+          break;
+        case 16:
+          _context3.prev = 16;
+          _context3.t0 = _context3["catch"](4);
+          if (_context3.t0 instanceof Error) {
+            console.error(chalk.red("Unexpected error running Prettier: ".concat(_context3.t0.message)));
+          } else {
+            console.error(chalk.red('An unknown error occurred while running Prettier.'));
+          }
+        case 19:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[4, 16]]);
+  }));
+  return _afterAll.apply(this, arguments);
+}

package/dist/esm/presets/remove-token-fallbacks/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,38 @@
+import { legacyLightTokens as legacyLightTheme, light as lightTheme, shape as shapeTheme, spacing as spacingTheme, typographyAdg3 as typographyAdg3Theme } from '@atlaskit/tokens/tokens-raw';
+var typographyGroups = ['typography', 'fontWeight', 'fontFamily'];
+function buildCombinedMap() {
+  var combinedMap = {};
+  for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrays[_key] = arguments[_key];
+  }
+  arrays.forEach(function (array) {
+    array.forEach(function (token) {
+      combinedMap[token.cleanName] = token.value.toString();
+    });
+  });
+  return combinedMap;
+}
+
+// Filter the typography tokens based on predefined groups and exclusions
+var typographyAdg3ThemeFiltered = typographyAdg3Theme.filter(function (token) {
+  return typographyGroups.includes(token.attributes.group);
+}).filter(function (token) {
+  return token.cleanName !== 'font.body.UNSAFE_small';
+});
+
+// Cache array: [0] for light theme, [1] for legacy light theme
+var tokenMapCache = [null, null];
+
+// Function to get the token map with the desired theme.
+// This should be used with the same value as the @atlaskit/tokens/babel-plugin is cofigured with for the given path.
+// When there is no theme, the babel plugin would use the given theme to provide default token fallbacks. Therefore it's safe to remove fallbacks only when they match the fallbacks that would be generated by the babel plugin with the given theme.
+// The default value is set to use the Light theme to match the behavior of the babel plugin (packages/design-system/tokens/src/babel-plugin/plugin.tsx).
+export function getTokenMap() {
+  var useLegacyTheme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var themeIndex = useLegacyTheme ? 1 : 0;
+  if (!tokenMapCache[themeIndex]) {
+    var selectedTheme = useLegacyTheme ? legacyLightTheme : lightTheme;
+    tokenMapCache[themeIndex] = buildCombinedMap(selectedTheme, spacingTheme, shapeTheme, typographyAdg3ThemeFiltered);
+  }
+  return tokenMapCache[themeIndex];
+}

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

@@ -0,0 +1,86 @@
+import { diff, rgb_to_lab } from 'color-diff';
+
+// Compare hex values using a CIEDE2000 color difference algorithm
+export var compareHex = function compareHex(hex, hex2) {
+  return diff(rgb_to_lab(hexToRgbA(hex)), rgb_to_lab(hexToRgbA(hex2)));
+};
+function hexToRgbA(hex) {
+  // Remove the leading '#' if present
+  hex = hex.replace(/^#/, '');
+  // Parse the hex string
+  var r = parseInt(hex.substring(0, 2), 16);
+  var g = parseInt(hex.substring(2, 4), 16);
+  var b = parseInt(hex.substring(4, 6), 16);
+  var a = parseInt(hex.substring(6, 8), 16) / 255;
+  return {
+    R: r,
+    G: g,
+    B: b,
+    A: a
+  };
+}
+var namedColors = {
+  black: '#000000',
+  silver: '#C0C0C0',
+  gray: '#808080',
+  grey: '#808080',
+  pink: '#FFC0CB',
+  white: '#FFFFFF',
+  maroon: '#800000',
+  red: '#FF0000',
+  purple: '#800080',
+  fuchsia: '#FF00FF',
+  green: '#008000',
+  lime: '#00FF00',
+  olive: '#808000',
+  yellow: '#FFFF00',
+  navy: '#000080',
+  blue: '#0000FF',
+  teal: '#008080',
+  aqua: '#00FFFF'
+};
+export function isValidColor(color) {
+  // Check if it's a named color
+  if (namedColors[color.toLowerCase()]) {
+    return true;
+  }
+  // Check for hex colors (including those with alpha)
+  if (/^#([0-9A-F]{3}){1,2}([0-9A-F]{2})?$/i.test(color)) {
+    return true;
+  }
+  // Check for rgba() values
+  if (/^rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(?:,\s*(?:0?\.)?\d+\s*)?\)$/i.test(color)) {
+    return true;
+  }
+  return false;
+}
+export function colorToHex(color) {
+  // Handle named colors
+  if (namedColors[color.toLowerCase()]) {
+    return namedColors[color.toLowerCase()].toUpperCase() + 'FF'; // Add full opacity
+  }
+  if (color.startsWith('#')) {
+    // If it's already a hex color
+    if (color.length === 7) {
+      // #RRGGBB format, add full opacity
+      return (color + 'FF').toUpperCase();
+    } else if (color.length === 9) {
+      // #RRGGBBAA format, return as is
+      return color.toUpperCase();
+    } else if (color.length === 4) {
+      // #RGB format, expand to #RRGGBBFF
+      return ('#' + color[1] + color[1] + color[2] + color[2] + color[3] + color[3] + 'FF').toUpperCase();
+    }
+  }
+  // For rgb() and rgba(), convert to hex
+  var match = color.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?\)$/i);
+  if (match) {
+    var r = parseInt(match[1], 10);
+    var g = parseInt(match[2], 10);
+    var b = parseInt(match[3], 10);
+    var a = match[4] !== undefined ? Math.round(parseFloat(match[4]) * 255) : 255;
+    return "#".concat(((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).padStart(6, '0')).concat(a.toString(16).padStart(2, '0')).toUpperCase();
+  }
+  // If conversion is not possible, return the original color
+  return color;
+}

package/dist/esm/presets/remove-token-fallbacks/utils/get-team-info.js

@@ -0,0 +1,44 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import readPkgUp from 'read-pkg-up';
+/**
+ * Looks for the closest package.json and gets team and package information from it.
+ *
+ * @param {string} filePath
+ * @returns {Promise<AtlassianTeamInfo>}
+ */
+export var getTeamInfo = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(filePath) {
+    var _pkgJson$packageJson$;
+    var pkgJson, packageName, teamName;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return readPkgUp({
+            cwd: filePath
+          });
+        case 2:
+          pkgJson = _context.sent;
+          if (!(!pkgJson || !pkgJson.packageJson)) {
+            _context.next = 5;
+            break;
+          }
+          throw new Error("Closest package.json file could not be found or is invalid for ".concat(filePath, "."));
+        case 5:
+          packageName = pkgJson.packageJson.name || '';
+          teamName = ((_pkgJson$packageJson$ = pkgJson.packageJson.atlassian) === null || _pkgJson$packageJson$ === void 0 ? void 0 : _pkgJson$packageJson$.team) || '';
+          return _context.abrupt("return", {
+            packageName: packageName,
+            teamName: teamName
+          });
+        case 8:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getTeamInfo(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();