@atlaskit/codemod-cli 0.13.4 → 0.15.0

package/dist/es2019/presets/css-to-design-tokens/lib/logger.js

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+export const logger = {
+  warn(message) {
+    // eslint-disable-next-line no-console
+    console.warn(chalk.yellow('WARNING'), message);
+  },
+  error(message) {
+    // eslint-disable-next-line no-console
+    console.error(chalk.red('ERROR'), message);
+  }
+};

package/dist/es2019/presets/css-to-design-tokens/lib/meta.js

@@ -0,0 +1,133 @@
+import designTokens from '@atlaskit/tokens/token-names';
+import { extractCssVarName } from './declaration';
+import { knownVariables, knownRawColors, knownNamedColors } from './legacy-colors';
+const getUniqueWordsFromTokens = Object.keys(designTokens).reduce((accum, val) => [...accum, ...val.split('.')], []).reduce((accum, val) => [...accum, ...val.split(/(?=[A-Z])/g).map(e => e.toLowerCase())], []).reduce((accum, val) => {
+  if (!accum.includes(val)) {
+    accum.push(val);
+  }
+  return accum;
+}, []);
+function filterDuplciateFoundations(meta) {
+  const foundations = ['text', 'background', 'shadow', 'border'];
+  let hasFoundation = false;
+  return meta.filter(val => {
+    if (!hasFoundation && foundations.includes(val)) {
+      hasFoundation = true;
+      return true;
+    }
+    if (hasFoundation && foundations.includes(val)) {
+      return false;
+    }
+    return true;
+  });
+}
+const REPLACEMENTS = {
+  ':': '',
+  ',': '',
+  texts: 'text',
+  error: 'danger',
+  invalid: 'danger',
+  removed: 'danger',
+  removal: 'danger',
+  remove: 'danger',
+  focus: 'focused',
+  valid: 'success',
+  successful: 'success',
+  risk: 'warning',
+  caution: 'warning',
+  warn: 'warning',
+  primary: 'bold',
+  info: 'bold',
+  secondary: 'subtle',
+  hyperlink: 'link',
+  anchor: 'link',
+  active: 'pressed',
+  hover: 'hovered',
+  dragged: 'overlay',
+  dragging: 'overlay',
+  drag: 'overlay',
+  'background-color': 'background',
+  color: 'text',
+  icons: 'icon',
+  arrow: 'icon',
+  glyph: 'icon',
+  stroke: 'border',
+  'border-left': 'border',
+  'border-right': 'border',
+  'border-top': 'border',
+  'border-bottom': 'border',
+  'box-shadow': 'shadow'
+};
+const ADDITIONAL_META = {
+  grey: 'neutral',
+  red: 'danger'
+};
+export function cleanMeta(meta) {
+  const cleanMeta = meta.reduce((accum, val) => [...accum, ...(typeof val === 'string' ? val.split(/(?=[A-Z])/g).map(e => e.toLowerCase()) : [])], []).reduce((accum, val) => {
+    if (val in ADDITIONAL_META) {
+      accum.push(val, ADDITIONAL_META[val]);
+    } else {
+      accum.push(val);
+    }
+    accum.push(val in REPLACEMENTS ? REPLACEMENTS[val] : val);
+    return accum;
+  }, []).filter(val => getUniqueWordsFromTokens.includes(val)).reduce((accum, val) => {
+    if (!accum.includes(val)) {
+      accum.push(val);
+    }
+    return accum;
+  }, []);
+  return filterDuplciateFoundations(cleanMeta);
+}
+export function getBaseDeclarationMeta(decl) {
+  const parentSelectors = getParentSelectors(decl).split(/\-|\.|\,|\ |\:|\&/).filter(Boolean);
+  return [getPropertyMeta(decl.prop), ...parentSelectors];
+}
+function getPropertyMeta(prop) {
+  if (prop === 'color') {
+    return 'text';
+  }
+  if (prop.startsWith('background')) {
+    return 'background';
+  }
+  if (prop.includes('shadow')) {
+    return 'shadow';
+  }
+  if (prop.includes('border')) {
+    return 'border';
+  }
+  return '';
+}
+function isRule(node) {
+  return node.type === 'rule';
+}
+function getParentSelectors(node) {
+  if (isRule(node)) {
+    // @ts-expect-error
+    return getParentSelectors(node.parent) + ' ' + node.selector;
+  }
+  if (node.parent) {
+    return getParentSelectors(node.parent);
+  }
+  return '';
+}
+export function getCssVarMeta(cssVariable) {
+  const tokenName = extractCssVarName(cssVariable);
+  const meta = knownVariables[tokenName];
+  if (!meta || meta.length === 0) {
+    return tokenName.split('-');
+  }
+  return meta;
+}
+export function getRawColorMeta(rawColor) {
+  var _knownRawColors$clean;
+  let cleanColor = rawColor.toLowerCase();
+  if (cleanColor.length === 4) {
+    cleanColor = cleanColor + cleanColor.substring(cleanColor.indexOf('#') + 1);
+  }
+  return (_knownRawColors$clean = knownRawColors[cleanColor]) !== null && _knownRawColors$clean !== void 0 ? _knownRawColors$clean : [];
+}
+export function getNamedColorMeta(namedColor) {
+  var _knownNamedColors$nam;
+  return (_knownNamedColors$nam = knownNamedColors[namedColor]) !== null && _knownNamedColors$nam !== void 0 ? _knownNamedColors$nam : [];
+}

package/dist/es2019/presets/css-to-design-tokens/lib/tokens.js

@@ -0,0 +1,24 @@
+import designTokens from '@atlaskit/tokens/token-names';
+import { light as rawTokens } from '@atlaskit/tokens/tokens-raw';
+import Search from '../../theme-to-design-tokens/utils/fuzzy-search';
+import { cleanMeta } from './meta';
+const MISSING_TOKEN_NAME = 'MISSING_TOKEN';
+const ACTIVE_TOKENS = rawTokens.filter(token => token.attributes.state === 'active').map(token => token.name.replace(/\.\[default\]/g, '')).filter(token => !token.includes('UNSAFE') && !token.includes('interaction'));
+const COLOR_TOKEN_SEARCH_TYPES = ['text', 'link', 'icon', 'border', 'background', 'blanket', 'skeleton', 'chart', 'surface', 'shadow'];
+const createFuzzySearch = tokens => Search(tokens, false);
+function filterTokens(meta) {
+  const commonSearchTypes = COLOR_TOKEN_SEARCH_TYPES.filter(type => meta.includes(type));
+  return commonSearchTypes.length !== 0 ? ACTIVE_TOKENS.filter(token => commonSearchTypes.some(type => token.startsWith(`color.${type}`) || token.startsWith(`elevation.${type}`))) : ACTIVE_TOKENS;
+}
+export default function findToken(meta) {
+  const filteredTokens = filterTokens(meta);
+  const tokenFuzzySearch = createFuzzySearch(filteredTokens);
+  const cleanSearchTerms = cleanMeta(meta).join(' ');
+  const results = tokenFuzzySearch.get(cleanSearchTerms);
+  if (!results) {
+    return MISSING_TOKEN_NAME;
+  }
+  const candidates = results.map(result => result[1]);
+  const bestCandidate = designTokens[candidates[0]];
+  return bestCandidate;
+}

package/dist/es2019/presets/css-to-design-tokens/lib/value.js

@@ -0,0 +1,68 @@
+import { extractBetweenParentheses, isGradient, isKnownCssVariable, isLessFunction, isNamedColor, isRawColor } from './colors';
+import { extractCssVarName } from './declaration';
+import { getCssVarMeta, getNamedColorMeta, getRawColorMeta } from './meta';
+import findToken from './tokens';
+import { logger } from './logger';
+export default function parseValue(value) {
+  if (isLessFunction(value)) {
+    logger.warn('Cannot parse - less function detected, would cause compilation error');
+    return null;
+  }
+  if (isGradient(value)) {
+    return {
+      getReplacement(additionalMeta = []) {
+        const gradientContent = extractBetweenParentheses(value);
+        const values = gradientContent.split(',');
+        const replacedValues = values.map(val => {
+          const parsedValue = parseValue(val.trim());
+          return parsedValue ? parsedValue.getReplacement(additionalMeta) : val;
+        });
+        return value.replace(gradientContent, replacedValues.join(', '));
+      },
+      getMeta() {
+        const BASE_META = [];
+        const gradientContent = extractBetweenParentheses(value);
+        const values = gradientContent.split(',');
+        const metas = values.reduce((acc, val) => {
+          const parsedValue = parseValue(val.trim());
+          return parsedValue ? [...acc, ...parsedValue.getMeta()] : acc;
+        }, BASE_META);
+        return metas;
+      }
+    };
+  }
+  if (isKnownCssVariable(extractCssVarName(value))) {
+    return {
+      getReplacement(additionalMeta = []) {
+        const token = findToken([...additionalMeta, ...this.getMeta()]);
+        return `var(${token}, ${value})`;
+      },
+      getMeta() {
+        return getCssVarMeta(value);
+      }
+    };
+  }
+  if (isRawColor(value)) {
+    return {
+      getReplacement(additionalMeta = []) {
+        const token = findToken([...additionalMeta, ...this.getMeta()]);
+        return `var(${token}, ${value})`;
+      },
+      getMeta() {
+        return getRawColorMeta(value);
+      }
+    };
+  }
+  if (isNamedColor(value)) {
+    return {
+      getReplacement(additionalMeta = []) {
+        const token = findToken([...additionalMeta, ...this.getMeta()]);
+        return `var(${token}, ${value})`;
+      },
+      getMeta() {
+        return getNamedColorMeta(value);
+      }
+    };
+  }
+  return null;
+}

package/dist/es2019/presets/theme-to-design-tokens/theme-to-design-tokens.js

@@ -3,15 +3,13 @@
 import { isDecendantOfType, hasImportDeclaration } from '@codeshift/utils';
 import { isDecendantOfToken, isParentOfToken } from './utils/ast';
 import { cleanMeta, getMetaFromAncestors } from './utils/ast-meta';
-import { includesHardCodedColor, isHardCodedColor, isLegacyColor, isLegacyNamedColor } from './utils/color';
+import { includesHardCodedColor, isHardCodedColor, isLegacyColor, isLegacyNamedColor, isBoldColor } from './utils/color';
 import Search from './utils/fuzzy-search';
 import { legacyColorMetaMap } from './utils/legacy-colors';
 import { tokens } from './utils/tokens';
-const kebabize = str => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());
-function isBoldColor(color) {
-  const number = parseInt(color.replace(/^./, ''), 10);
-  return number > 300;
-}
+import { kebabize, findFirstNonspaceIndexAfter, splitAtIndex } from './utils/string-utils';
+import { containsReplaceableCSSDeclarations, findEndIndexOfCSSExpression } from './utils/css-utils';
+import CSSTransformer from '../css-to-design-tokens/css-to-design-tokens';
 function insertTokenImport(j, source) {
   if (hasImportDeclaration(j, source, '@atlaskit/tokens')) {
     return;
@@ -23,6 +21,23 @@ function buildToken(j, tokenId, node) {
   const callExpr = j.callExpression(j.identifier('token'), [j.stringLiteral(tokenId), node].filter(Boolean));
   return callExpr;
 }
+
+// Wrap over the j.templateElement builder to provide a more convenient API.
+function buildTemplateElement(j, text, options = {
+  tail: false,
+  fromNode: null
+}) {
+  let tail;
+  if (options.fromNode) {
+    tail = options.fromNode.tail;
+  } else {
+    tail = !!options.tail;
+  }
+  return j.templateElement({
+    raw: text,
+    cooked: null
+  }, tail);
+}
 function getColorFromIdentifier(expression) {
   let value = '';
   if (expression.type === 'Identifier') {
@@ -126,10 +141,20 @@ function getTokenFromNode(j, path, value, propertyName) {
 }
 function parseCSSPropertyName(cssString) {
   const lastColonIndex = cssString.lastIndexOf(':');
-  const propertyNameEndIndex = Math.max(cssString.lastIndexOf(';', lastColonIndex), cssString.lastIndexOf(' ', lastColonIndex));
-  return cssString.slice(propertyNameEndIndex + 1, lastColonIndex).trim();
+  if (lastColonIndex === -1) {
+    return {
+      colonIndex: null,
+      cssPropertyName: null
+    };
+  }
+  const propertyNameEndIndex = Math.max(cssString.lastIndexOf(';', lastColonIndex), cssString.lastIndexOf(' ', lastColonIndex), -1);
+  const startIndex = propertyNameEndIndex + 1;
+  return {
+    cssPropertyName: cssString.slice(startIndex, lastColonIndex).trim(),
+    colonIndex: lastColonIndex
+  };
 }
-export default function transformer(file, api, debug = false) {
+export default async function transformer(file, api, debug = false) {
   const j = api.jscodeshift;
   const source = j(file.source);
   let transformed = false;
@@ -169,29 +194,6 @@ export default function transformer(file, api, debug = false) {
     transformed = true;
   });
 
-  // Template literals
-  source.find(j.TemplateLiteral).forEach(path => {
-    function replaceTemplateLiteralExpressions(j, expression, index) {
-      if (isDecendantOfToken(j, expression)) {
-        return;
-      }
-      if (index >= path.value.quasis.length) {
-        return;
-      }
-      const quasi = path.value.quasis[index];
-      const value = getColorFromIdentifier(expression.value);
-      if (!value || !includesHardCodedColor(value) && !isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
-        return;
-      }
-      const tokenId = getTokenFromNode(j, expression, value, parseCSSPropertyName(quasi.value.cooked || ''));
-      insertTokenImport(j, source);
-      expression.replace(buildToken(j, tokenId, expression.value));
-    }
-    j(path).find(j.Identifier).filter(expression => !isDecendantOfType(j, expression, j.MemberExpression)).forEach((expression, i) => replaceTemplateLiteralExpressions(j, expression, i));
-    j(path).find(j.MemberExpression).forEach((expression, i) => replaceTemplateLiteralExpressions(j, expression, i));
-    transformed = true;
-  });
-
   // JSX props
   source.find(j.JSXAttribute).forEach(path => {
     var _path$value, _path$value$value;
@@ -214,5 +216,162 @@ export default function transformer(file, api, debug = false) {
     });
     transformed = true;
   });
+
+  // Strings
+  source.find(j.StringLiteral).forEach(path => {
+    j(path).filter(expression => !isDecendantOfType(j, expression, j.ObjectExpression)).forEach(path => {
+      const value = path.value.value;
+      if (replaceStringLiteralIfItConsistsOnlyOfColor(j, path, value)) {
+        transformed = true;
+      }
+    });
+  });
+  const templateLiteralPaths = source.find(j.TemplateLiteral).paths();
+  for (const path of templateLiteralPaths) {
+    // Background: a 'type: TemplateLiteral' Node has quasis and expressions
+    // (see ast-types/src/gen/namedTypes.ts), and invariant holds that
+    // quasis.length === expression.length + 1.
+    //
+    // eg `${foo}bar` has quasis [Node(''), Node('bar')] and expressions
+    // [Node('foo')]. Each quasi has type: 'TemplateElement'; expressions are
+    // probably safe to treat as subtypes of Expression, though ast-types
+    // codebase has a more involved definition.
+    if (path.value.expressions.length === 0) {
+      // A single-quasi (equivalently, no-expression) template literal is
+      // basically just a string literal, possibly multi-line. We handle the
+      // simple `#ababab` case here, and the multi-line case after.
+      const text = path.value.quasis[0].value.raw;
+      if (replaceStringLiteralIfItConsistsOnlyOfColor(j, path, text)) {
+        transformed = true;
+      }
+    } else {
+      j(path).find(j.Expression).filter(expressionPath => {
+        // jscodeshift walks over the whole tree; we are interested only in
+        // the direct children: i.e. top-level expressions appearing in ${}.
+        return expressionPath.parent === path;
+      }).forEach((expressionPath, expressionIndex) => {
+        if (replaceTemplateLiteralExpression(j, path, expressionPath, expressionIndex)) {
+          transformed = true;
+        }
+      });
+    }
+
+    // No matter if we have one big quasi or many small chunks between
+    // expressions (which potentially have been transformed), try to pass them
+    // through the CSS transformer; it's robust enough to understand malformed
+    // CSS that would result if we split e.g. this template:
+    //
+    // `${gridSize}px; color: red;`, giving `px; color: red;` as input; or
+    // `@media ${mobile} { color: red }`, giving `{ color: red }`.
+    const quasiPaths = j(path).find(j.TemplateElement).filter(quasiPath => {
+      return quasiPath.parent === path;
+    }).paths();
+    for (const quasiPath of quasiPaths) {
+      const text = quasiPath.value.value.raw;
+      if (includesHardCodedColor(text) && containsReplaceableCSSDeclarations(text)) {
+        const newCSS = await CSSTransformer(text);
+        j(quasiPath).replaceWith(buildTemplateElement(j, newCSS));
+        transformed = true;
+      }
+    }
+  }
+  function replaceStringLiteralIfItConsistsOnlyOfColor(j, path, value) {
+    if (isDecendantOfToken(j, path)) {
+      return false;
+    }
+    if (isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
+      const parent = path.parent.value;
+      let key = '';
+      if (parent.type === 'VariableDeclarator') {
+        key = parent.id.name;
+      }
+      const tokenId = getTokenFromNode(j, path, value, key);
+      insertTokenImport(j, source);
+      j(path).replaceWith(buildToken(j, tokenId, path.value));
+      return true;
+    }
+    return false;
+  }
+  function replaceTemplateLiteralExpression(j, mainPath, expressionPath, expressionIndex) {
+    const expression = expressionPath.value;
+    if (!(expression.type === 'MemberExpression' || expression.type === 'Identifier')) {
+      return false;
+    }
+    if (isDecendantOfToken(j, expressionPath)) {
+      return false;
+    }
+    const value = getColorFromIdentifier(expression);
+    if (!value || !includesHardCodedColor(value) && !isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
+      return false;
+    }
+    const precedingQuasi = mainPath.value.quasis[expressionIndex];
+    const precedingQuasiText = precedingQuasi.value.raw;
+    const {
+      cssPropertyName,
+      colonIndex
+    } = parseCSSPropertyName(precedingQuasiText);
+    if (!cssPropertyName) {
+      return false;
+    }
+    const tokenId = getTokenFromNode(j, expressionPath, value, cssPropertyName);
+    insertTokenImport(j, source);
+    const newQuasis = [...mainPath.value.quasis];
+    const newExpressions = [...mainPath.value.expressions];
+    if (cssPropertyName !== 'box-shadow') {
+      const tokenExpression = buildToken(j, tokenId, expressionPath.value);
+      newExpressions[expressionIndex] = tokenExpression;
+    } else {
+      // box-shadow is a multi-part property where the color can appear at any
+      // part position (even though the standard suggests that color comes
+      // last, browsers' CSS parsers are more lax). If we get here, then the
+      // color part is replaceable.  Textually, it's something like:
+      //
+      // <rules before>; box-shadow: 0 1px ${colors.N50} 2rem; <rules after>
+      //
+      // the fallback value will be multipart, i.e. the token call is
+      //
+      // token(<replacedValue>, `0 1px ${colors.N50} 2rem`)
+      //
+      // and it's wrapped in a substitution like this:
+      //
+      // <rules before>; box-shadow: ${token(<...>)}; <rules after>
+      //
+      // We stich the fallback from the last part of preceding quasi (after
+      // colon) and the first part of the following quasi (before ';' or '}').
+      //
+      // If multiple box-shadows are comma-separated but only one of them has a
+      // replaceable color and others are hard-coded, this logic would still
+      // work. When multiple shadows have expressions, it's unfortunately not
+      // possible to proceed because we cannot find where the value ends from a
+      // single following quasi.
+      const valueStartIndex = findFirstNonspaceIndexAfter(precedingQuasiText, colonIndex);
+      const [newPrecedingQuasiText, partialValueBeginning] = splitAtIndex(precedingQuasiText, valueStartIndex);
+      const followingQuasi = mainPath.value.quasis[expressionIndex + 1];
+      const followingQuasiText = followingQuasi.value.raw;
+      const valueEndIndex = findEndIndexOfCSSExpression(followingQuasiText, followingQuasi.tail);
+      if (!valueEndIndex) {
+        console.warn('cannot find end of box-shadow value, please check manually');
+        return false;
+      }
+      const [partialValueEnd, newFollowingQuasiText] = splitAtIndex(followingQuasiText, valueEndIndex + 1);
+      const internalQuasis = [buildTemplateElement(j, partialValueBeginning, {
+        tail: false
+      }), buildTemplateElement(j, partialValueEnd, {
+        tail: true
+      })];
+      const internalExpressions = [expressionPath.value];
+      const newFallback = j.templateLiteral(internalQuasis, internalExpressions);
+      const newExpression = buildToken(j, tokenId, newFallback);
+      newQuasis[expressionIndex] = buildTemplateElement(j, newPrecedingQuasiText, {
+        fromNode: newQuasis[expressionIndex]
+      });
+      newExpressions[expressionIndex] = newExpression;
+      newQuasis[expressionIndex + 1] = buildTemplateElement(j, newFollowingQuasiText, {
+        fromNode: newQuasis[expressionIndex]
+      });
+    }
+    mainPath.replace(j.templateLiteral(newQuasis, newExpressions));
+    return true;
+  }
   return transformed ? source.toSource() : file.source;
 }

package/dist/es2019/presets/theme-to-design-tokens/utils/ast.js

@@ -1,6 +1,6 @@
 import { isDecendantOfType } from '@codeshift/utils';
 export function isDecendantOfToken(j, path) {
-  if (path.type === 'CallExpression' && path.callee.type === 'Identifier' && path.callee.name === 'token') {
+  if ('type' in path && path.type === 'CallExpression' && path.callee.type === 'Identifier' && path.callee.name === 'token') {
     return true;
   }
   return j(path).closest(j.CallExpression, {

package/dist/es2019/presets/theme-to-design-tokens/utils/color.js

@@ -2,9 +2,10 @@ import { legacyColorMixins, legacyColors } from './legacy-colors';
 import { namedColors } from './named-colors';
 export const isLegacyColor = value => legacyColors.includes(value);
 export const isLegacyNamedColor = value => legacyColorMixins.includes(value);
+const colorRegexp = /#(?:[a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})\b|(?:rgb|rgba|hsl|hsla|lch|lab|color)\([^\)]*\)/;
 export const includesHardCodedColor = raw => {
   const value = raw.toLowerCase();
-  if (/#(?:[a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})\b|(?:rgb|hsl)a?\([^\)]*\)/.exec(value.toLowerCase())) {
+  if (colorRegexp.exec(value)) {
     return true;
   }
   for (let i = 0; i < namedColors.length; i++) {
@@ -14,17 +15,18 @@ export const includesHardCodedColor = raw => {
   }
   return false;
 };
-export const isHardCodedColor = value => {
-  if (namedColors.includes(value.toLowerCase())) {
-    return true;
-  }
-  if (value.startsWith('rgb(') || value.startsWith('rgba(') || value.startsWith('hsl(') || value.startsWith('hsla(') || value.startsWith('lch(') || value.startsWith('lab(') || value.startsWith('color(')) {
+export const isHardCodedColor = raw => {
+  const value = raw.toLowerCase();
+  if (namedColors.includes(value)) {
     return true;
   }
-  if (value.startsWith('#') && (
-  // short hex, hex, or hex with alpha
-  value.length === 4 || value.length === 7 || value.length === 9)) {
+  const match = value.toLowerCase().match(colorRegexp);
+  if (match && match[0] === value) {
     return true;
   }
   return false;
-};
+};
+export function isBoldColor(color) {
+  const number = parseInt(color.replace(/^./, ''), 10);
+  return number > 300;
+}

package/dist/es2019/presets/theme-to-design-tokens/utils/css-utils.js

@@ -0,0 +1,31 @@
+import { isColorRelatedProperty } from '../../css-to-design-tokens/lib/declaration';
+export function containsReplaceableCSSDeclarations(input) {
+  const cssPattern = /(\S+)\s*:/g;
+  let match;
+  while ((match = cssPattern.exec(input)) !== null) {
+    if (isColorRelatedProperty(match[1])) {
+      return true;
+    }
+  }
+  return false;
+}
+export function findEndIndexOfCSSExpression(text, isAtEndOfInput) {
+  // CSS expression can end *on* a semicolon or *before* a brace. In either
+  // case we treat the remaining part of the value to cover one character
+  // before that symbol.
+  const semicolonIndex = text.indexOf(';');
+  const braceIndex = text.indexOf('}');
+  if (semicolonIndex === -1 && braceIndex === -1) {
+    if (isAtEndOfInput) {
+      return text.length;
+    } else {
+      return null;
+    }
+  } else if (semicolonIndex === -1) {
+    return braceIndex - 1;
+  } else if (braceIndex === -1) {
+    return semicolonIndex - 1;
+  } else {
+    return Math.min(semicolonIndex, braceIndex) - 1;
+  }
+}

package/dist/es2019/presets/theme-to-design-tokens/utils/string-utils.js

@@ -0,0 +1,13 @@
+export const kebabize = str => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());
+export function findFirstNonspaceIndexAfter(text, index) {
+  const rest = text.slice(index + 1);
+  const indexInRest = rest.search(/\S/);
+  if (indexInRest === -1) {
+    return text.length;
+  } else {
+    return index + 1 + indexInRest;
+  }
+}
+export function splitAtIndex(text, index) {
+  return [text.slice(0, index), text.slice(index)];
+}

package/dist/esm/main.js

@@ -5,8 +5,8 @@ function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import chalk from 'chalk';
 import fs from 'fs';
 import spawn from 'projector-spawn';
@@ -291,7 +291,7 @@ function _main() {
         case 4:
           _yield$parseArgs = _context5.sent;
           packages = _yield$parseArgs.packages;
-          _process$env$_PACKAGE = "0.13.4", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+          _process$env$_PACKAGE = "0.15.0", _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) {