@atlaskit/eslint-plugin-design-system 14.1.0 → 14.3.0

package/dist/esm/rules/ensure-design-token-usage/utils.js

@@ -1,385 +0,0 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-// eslint-disable-next-line @typescript-eslint/consistent-type-imports
-import { callExpression, identifier, isNodeOfType, literal } from 'eslint-codemod-utils';
-import { getScope } from '@atlaskit/eslint-utils/context-compat';
-import { spacing as spacingScale } from '@atlaskit/tokens/tokens-raw';
-import { findIdentifierInParentScope } from '../utils/find-in-parent';
-import { isColorCssPropertyName } from '../utils/is-color';
-import { isCurrentSurfaceCustomPropertyName } from '../utils/is-current-surface-custom-property-name';
-import { borderWidthValueToToken } from './border-width-value-to-token';
-import { cleanComments } from './clean-comments';
-import { getRawExpression } from './get-raw-expression';
-import { isBorderRadius } from './is-border-radius';
-import { normaliseValue } from './normalise-value';
-import { radiusValueToToken } from './radius-value-to-token';
-import { isBorderSizeProperty, isShapeProperty } from './shape';
-import { splitCssProperties } from './split-css-properties';
-import { splitShorthandValues } from './split-shorthand-values';
-var properties = ['padding', 'paddingBlock', 'paddingInline', 'paddingLeft', 'paddingTop', 'paddingRight', 'paddingBottom', 'paddingInline', 'paddingInlineStart', 'paddingInlineEnd', 'paddingBlock', 'paddingBlockStart', 'paddingBlockEnd', 'marginLeft', 'marginTop', 'marginRight', 'marginBottom', 'marginInline', 'marginInlineStart', 'marginInlineEnd', 'marginBlock', 'marginBlockStart', 'marginBlockEnd', 'margin', 'gap', 'rowGap', 'gridRowGap', 'columnGap', 'gridColumnGap', 'top', 'left', 'right', 'bottom', 'inlineStart', 'inlineEnd', 'blockStart', 'blockEnd', 'outline-offset'];
-var spacingValueToToken = Object.fromEntries(spacingScale.map(function (token) {
-  return [token.value, token.cleanName];
-}));
-export var isSpacingProperty = function isSpacingProperty(propertyName) {
-  return properties.includes(propertyName);
-};
-export var getValueFromShorthand = function getValueFromShorthand(str) {
-  var valueString = String(str);
-  var fontFamily = /(Charlie)|(sans-serif$)|(monospace$)/;
-  var fontWeightString = /(regular$)|(medium$)|(semibold$)|(bold$)/;
-  var fontStyleString = /(inherit$)|(normal$)|(italic$)/;
-  if (fontFamily.test(valueString) || fontWeightString.test(valueString) || fontStyleString.test(valueString)) {
-    return [valueString];
-  }
-  // If we want to filter out NaN just add .filter(Boolean)
-  return splitShorthandValues(String(str).trim()).map(removePixelSuffix);
-};
-var isGridSize = function isGridSize(node) {
-  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'gridSize' || node.callee.name === 'getGridSize') &&
-  // If there are arguments we know it's a custom gridSize function and cannot be certain what it returns
-  node.arguments.length === 0;
-};
-var isToken = function isToken(node) {
-  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && node.callee.name === 'token';
-};
-var getRawExpressionForToken = function getRawExpressionForToken(node, context) {
-  var args = node.arguments;
-  var call = "${token(".concat(args.map(function (argNode) {
-    if (isNodeOfType(argNode, 'Literal')) {
-      return argNode.raw;
-    }
-    if (isNodeOfType(argNode, 'Identifier')) {
-      return argNode.name;
-    }
-    if (isNodeOfType(argNode, 'MemberExpression')) {
-      return getValue(argNode, context);
-    }
-  }).join(', '), ")}");
-  return call;
-};
-var isFontSize = function isFontSize(node) {
-  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'fontSize' || node.callee.name === 'getFontSize');
-};
-var isFontSizeSmall = function isFontSizeSmall(node) {
-  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && node.callee.name === 'fontSizeSmall';
-};
-var getValueFromCallExpression = function getValueFromCallExpression(node, context) {
-  if (!isNodeOfType(node, 'CallExpression')) {
-    return null;
-  }
-  if (isGridSize(node)) {
-    return 8;
-  }
-  if (isBorderRadius(node)) {
-    return 3;
-  }
-  if (isFontSize(node)) {
-    return 14;
-  }
-  if (isFontSizeSmall(node)) {
-    return 11;
-  }
-  if (isToken(node)) {
-    return getRawExpressionForToken(node, context);
-  }
-  return null;
-};
-export var getValue = function getValue(node, context) {
-  if (isNodeOfType(node, 'Literal')) {
-    return getValueFromShorthand(node.value);
-  }
-  if (isNodeOfType(node, 'BinaryExpression')) {
-    return getValueFromBinaryExpression(node, context);
-  }
-  if (isNodeOfType(node, 'UnaryExpression')) {
-    return getValueFromUnaryExpression(node, context);
-  }
-  if (isNodeOfType(node, 'CallExpression')) {
-    return getValueFromCallExpression(node, context);
-  }
-  if (isNodeOfType(node, 'Identifier')) {
-    return getValueFromIdentifier(node, context);
-  }
-  if (isNodeOfType(node, 'TemplateLiteral')) {
-    return getValueFromTemplateLiteral(node, context);
-  }
-  return null;
-};
-var getValueFromIdentifier = function getValueFromIdentifier(node, context) {
-  if (!isNodeOfType(node, 'Identifier')) {
-    return null;
-  }
-  if (node.name === 'gridSize') {
-    return 8;
-  }
-  var scope = getScope(context, node);
-  var variable = findIdentifierInParentScope({
-    scope: scope,
-    identifierName: node.name
-  });
-  if (!variable) {
-    return null;
-  }
-  var definition = variable.defs[0];
-  if (isNodeOfType(definition.node, 'ImportSpecifier') && isNodeOfType(definition.node.parent, 'ImportDeclaration') && definition.node.parent.source.value === '@atlassian/jira-common-styles/src/main.tsx') {
-    return definition.node.imported.type === 'Identifier' && definition.node.imported.name === 'gridSize' ? 8 : null;
-  }
-  if (!isNodeOfType(definition.node, 'VariableDeclarator')) {
-    return null;
-  }
-  if (!definition.node.init) {
-    return null;
-  }
-  return getValue(definition.node.init, context);
-};
-var getValueFromUnaryExpression = function getValueFromUnaryExpression(node, context) {
-  if (!isNodeOfType(node, 'UnaryExpression')) {
-    return null;
-  }
-  var value = getValue(node.argument, context);
-  if (!value) {
-    return null;
-  }
-
-  // eslint-disable-next-line no-eval
-  return eval("".concat(node.operator, "(").concat(value, ")"));
-};
-
-/**
- * @example
- * ```js
- * `2 ${variable} 0`
- *
- * // results in [2, NaN, 0]
- * ```
- * ```js
- * const variable = 4;
- * `2 ${variable} 0`
- *
- * // results in [2, 4, 0]
- * ```
- */
-export var getValueFromTemplateLiteralRaw = function getValueFromTemplateLiteralRaw(node, context) {
-  if (!isNodeOfType(node, "TemplateLiteral")) {
-    return null;
-  }
-  var combinedString = node.quasis.map(function (q, i) {
-    return "".concat(q.value.raw).concat(node.expressions[i] ? getValue(node.expressions[i], context) : '');
-  }).join('').trim();
-  var fontFamily = /(sans-serif$)|(monospace$)/;
-  if (fontFamily.test(combinedString)) {
-    return combinedString;
-  }
-  return combinedString.split(' ');
-};
-var getValueFromTemplateLiteral = function getValueFromTemplateLiteral(node, context) {
-  var value = getValueFromTemplateLiteralRaw(node, context);
-  return Array.isArray(value) ? value.map(removePixelSuffix) : value;
-};
-var getValueFromBinaryExpression = function getValueFromBinaryExpression(node, context) {
-  if (!isNodeOfType(node, 'BinaryExpression')) {
-    return null;
-  }
-  var left = node.left,
-    right = node.right,
-    operator = node.operator;
-  var leftValue = getValue(left, context);
-  var rightValue = getValue(right, context);
-  var final = rightValue && leftValue ?
-  // eslint-disable-next-line no-eval
-  eval("".concat(leftValue).concat(operator).concat(rightValue)) : null;
-  return final;
-};
-var emRegex = /(.*\d+)em$/;
-var percentageRegex = /(%$)/;
-export var emToPixels = function emToPixels(value, fontSize) {
-  if (typeof value === 'string') {
-    var emMatch = value.match(emRegex);
-    if (emMatch && typeof fontSize === 'number') {
-      return Number(emMatch[1]) * fontSize;
-    } else if (value.match(percentageRegex)) {
-      return value;
-    } else {
-      return null;
-    }
-  }
-  return value;
-};
-var percentageOrEmOrAuto = /(%$)|(\d+em$)|(auto$)/;
-export var removePixelSuffix = function removePixelSuffix(value) {
-  if (typeof value === 'string' && (percentageOrEmOrAuto.test(value) || isCalc(value))) {
-    return value;
-  }
-  return Number(typeof value === 'string' ? value.replace('px', '') : value);
-};
-var invalidSpacingUnitRegex = /(\d+rem$)|(vw$)|(vh$)/;
-export var isValidSpacingValue = function isValidSpacingValue(value, fontSize) {
-  if (typeof value === 'string') {
-    if (invalidSpacingUnitRegex.test(value)) {
-      return false;
-    }
-  } else if (Array.isArray(value)) {
-    // could be array due to shorthand
-    for (var val in value) {
-      if (invalidSpacingUnitRegex.test(val)) {
-        return false;
-      }
-    }
-  }
-  if (emRegex.test(value) && typeof fontSize !== 'number') {
-    return false;
-  }
-  return true;
-};
-var calcRegex = /(^calc)/;
-export var isCalc = function isCalc(value) {
-  if (typeof value === 'string') {
-    if (calcRegex.test(value)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-/**
- * Returns an array of domains that are relevant to the provided property based on the rule options.
- * @param propertyName camelCase CSS property
- * @param targetOptions Array containing the types of properties that should be included in the rule.
- * @example
- * ```
- * propertyName: padding, targetOptions: ['spacing'] -> returns ['spacing']
- * propertyName: backgroundColor, targetOptions: ['spacing'] -> returns []
- * propertyName: backgroundColor, targetOptions: ['color', 'spacing'] -> returns ['color']
- * ```
- */
-export function getDomainsForProperty(propertyName, targetOptions) {
-  var domains = [];
-  if ((isColorCssPropertyName(propertyName) || isCurrentSurfaceCustomPropertyName(propertyName)) && targetOptions.includes('color')) {
-    domains.push('color');
-  }
-  if (isSpacingProperty(propertyName) && targetOptions.includes('spacing')) {
-    domains.push('spacing');
-  }
-  if (isShapeProperty(propertyName) && targetOptions.includes('shape')) {
-    domains.push('shape');
-  }
-  return domains;
-}
-
-/**
- * Returns an array of tuples representing a processed css within `TaggedTemplateExpression` node.
- * Each element of the array is a tuple `[string, string]`,
- * where the first element is the processed css line with computed values
- * and the second element of the tuple is the original css line from source.
- * @param node TaggedTemplateExpression node.
- * @param context Rule.RuleContext.
- * @example
- * ```
- * `[['padding: 8', 'padding: ${gridSize()}'], ['margin: 6', 'margin: 6px' ]]`
- * ```
- */
-export function processCssNode(node, context) {
-  var combinedString = node.quasi.quasis.map(function (q, i) {
-    return "".concat(q.value.raw).concat(node.quasi.expressions[i] ? getValue(node.quasi.expressions[i], context) : '');
-  }).join('');
-  var rawString = node.quasi.quasis.map(function (q, i) {
-    return "".concat(q.value.raw).concat(node.quasi.expressions[i] ? getRawExpression(node.quasi.expressions[i], context) ? "${".concat(getRawExpression(node.quasi.expressions[i], context), "}") : null : '');
-  }).join('');
-  var cssProperties = splitCssProperties(cleanComments(combinedString));
-  var unalteredCssProperties = splitCssProperties(cleanComments(rawString));
-  if (cssProperties.length !== unalteredCssProperties.length) {
-    // this means something went wrong with the parsing, the original lines can't be reconciled with the processed lines
-    return undefined;
-  }
-  return cssProperties.map(function (cssProperty, index) {
-    return [cssProperty, unalteredCssProperties[index]];
-  });
-}
-
-/**
- * Returns a token node for a given value including fallbacks.
- * @param propertyName camelCase CSS property
- * @param value string representing pixel value, or font family, or number representing font weight
- * @example
- * ```
- * propertyName: padding, value: '8px' => token('space.100', '8px')
- * propertyName: fontWeight, value: 400 => token('font.weight.regular', '400')
- * ```
- */
-export function getTokenNodeForValue(propertyName, value) {
-  var token = findTokenNameByPropertyValue(propertyName, value);
-  var fallbackValue = propertyName === 'fontFamily' ? {
-    value: "".concat(value),
-    raw: "`".concat(value, "`")
-  } : "".concat(value);
-  return callExpression({
-    callee: identifier({
-      name: 'token'
-    }),
-    arguments: [literal({
-      value: "'".concat(token !== null && token !== void 0 ? token : '', "'")
-    }), literal(fallbackValue)],
-    optional: false
-  });
-}
-export function getFontSizeValueInScope(cssProperties) {
-  var fontSizeNode = cssProperties.find(function (_ref) {
-    var _ref2 = _slicedToArray(_ref, 1),
-      style = _ref2[0];
-    var _style$split = style.split(':'),
-      _style$split2 = _slicedToArray(_style$split, 2),
-      rawProperty = _style$split2[0],
-      value = _style$split2[1];
-    return /font-size/.test(rawProperty) ? value : null;
-  });
-  if (!fontSizeNode) {
-    return undefined;
-  }
-  var _fontSizeNode$0$split = fontSizeNode[0].split(':'),
-    _fontSizeNode$0$split2 = _slicedToArray(_fontSizeNode$0$split, 2),
-    _ = _fontSizeNode$0$split2[0],
-    fontSizeValue = _fontSizeNode$0$split2[1];
-  if (!fontSizeValue) {
-    return undefined;
-  }
-  return getValueFromShorthand(fontSizeValue)[0];
-}
-export function findTokenNameByPropertyValue(propertyName, value) {
-  var lookupValue = normaliseValue(propertyName, value);
-  var tokenName = isShapeProperty(propertyName) ? isBorderSizeProperty(propertyName) ? borderWidthValueToToken[lookupValue] : radiusValueToToken[lookupValue] : spacingValueToToken[lookupValue];
-  if (!tokenName) {
-    return undefined;
-  }
-  return tokenName;
-}
-
-/**
- * Returns a stringifiable node with the token expression corresponding to its matching token.
- * If no token found for the pair the function returns undefined.
- * @param propertyName string camelCased css property.
- * @param value The computed value e.g '8px' -> '8'.
- */
-export function getTokenReplacement(propertyName, value) {
-  var tokenName = findTokenNameByPropertyValue(propertyName, value);
-  if (!tokenName) {
-    return undefined;
-  }
-  var fallbackValue = normaliseValue(propertyName, value);
-  return getTokenNodeForValue(propertyName, fallbackValue);
-}
-export function getPropertyNodeFromParent(property, parentNode) {
-  var propertyNode = parentNode.properties.find(function (node) {
-    if (!isNodeOfType(node, 'Property')) {
-      return;
-    }
-    if (!isNodeOfType(node.key, 'Identifier')) {
-      return;
-    }
-    return node.key.name === property;
-  });
-  return propertyNode;
-}
-export function getValueForPropertyNode(propertyNode, context) {
-  var propertyValueRaw = isNodeOfType(propertyNode, 'Property') ? getValue(propertyNode.value, context) : null;
-  var propertyValue = Array.isArray(propertyValueRaw) ? propertyValueRaw[0] : propertyValueRaw;
-  return propertyValue;
-}

package/dist/esm/rules/use-latest-xcss-syntax-typography/config/index.js

@@ -1,8 +0,0 @@
-export var PATTERNS = ['restricted-property', 'wrapped-token-value', 'restricted-capitalisation'];
-var defaults = {
-  failSilently: false,
-  patterns: [].concat(PATTERNS)
-};
-export var getConfig = function getConfig(overrides) {
-  return Object.assign({}, defaults, overrides);
-};

package/dist/esm/rules/use-primitives/transformers/css-to-xcss.js

@@ -1,101 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-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 { getIdentifierInParentScope, identifier, isNodeOfType, literal } from 'eslint-codemod-utils';
-import { getScope } from '@atlaskit/eslint-utils/context-compat';
-import { getAttributeValueIdentifier } from '../utils/get-attribute-value-identifier';
-import { getFunctionArgumentAtPos } from '../utils/get-function-argument-at-pos';
-import { getJSXAttributeByName } from '../utils/get-jsx-attribute-by-name';
-import { getVariableDefinitionValue } from '../utils/get-variable-definition-value';
-import { spaceTokenMap } from './space-token-map';
-import { spaceTokenPositiveMap } from './space-token-positive-map';
-import { supportedDimensionAttributesMap } from './supported-dimension-attributes-map';
-export var cssToXcssTransformer = function cssToXcssTransformer(node, context, fixer) {
-  /**
-   * Note: The logic here is very similar to the logic in `shouldSuggestBox`. i.e.
-   * 1. Find the `css` attr
-   * 2. Find the variableName (`myStyles` in `css={myStyles}`)
-   * 3. Find the `const myStyles = css({ padding: '8px' })`
-   * 4. Find the style object `{ padding: '8px' }`
-   *
-   * The only difference is, we've already performed very defensive checks for these steps in `shouldSuggestBox`,
-   * so there's no need to do those checks here.
-   *
-   * The repetition could be avoided by combining the 'shouldSuggest' and 'fixCode' steps. However, there are tradeoffs
-   * to that approach (mainly poor separation of concerns). I'm un-opinionated about which strategy we use. I just opted
-   * for this because the original `use-primitives` rule did this.
-   */
-  var cssAttr = getJSXAttributeByName(node.openingElement, 'css');
-  var cssVariableName = getAttributeValueIdentifier(cssAttr);
-  if (!cssVariableName) {
-    return [];
-  }
-  var cssVariableDefinition = getIdentifierInParentScope(getScope(context, node), cssVariableName);
-  var cssVariableValue = getVariableDefinitionValue(cssVariableDefinition);
-  if (!cssVariableValue) {
-    return [];
-  }
-  var cssObjectExpression = getFunctionArgumentAtPos(cssVariableValue, 0);
-  return [
-  // Update `css` function name to `xcss`.
-  fixer.replaceText(cssVariableValue.node.init.callee, identifier('xcss').toString())].concat(_toConsumableArray(styledObjectToXcssTokens(cssObjectExpression, fixer)));
-};
-
-// Update css object values to xcss values
-// Note: `properties` in this context is a group of AST nodes that make up a key/value pair in an object.
-// e.g. `padding: '8px'`. For clarity, it's renamed to `entry` inside the `.map()`.
-export var styledObjectToXcssTokens = function styledObjectToXcssTokens(styles, fixer) {
-  return styles.properties.map(function (entry) {
-    if (!isNodeOfType(entry, 'Property')) {
-      return;
-    }
-    if (!isNodeOfType(entry.key, 'Identifier')) {
-      return;
-    }
-
-    // maps literal values like: 8px to 'space.100'
-    if (isNodeOfType(entry.value, 'Literal')) {
-      var value = entry.value.value;
-      if (typeof value !== 'string') {
-        return;
-      }
-      return fixer.replaceText(entry.value, literal("'".concat(supportedStylesMap[entry.key.name][value], "'")).toString());
-    }
-    // maps token calls like: token('space.100') to 'space.100'
-    if (isNodeOfType(entry.value, 'CallExpression')) {
-      var callExpression = entry.value;
-      // skip if not a call to `token`
-      if (!isNodeOfType(callExpression.callee, 'Identifier') || callExpression.callee.name !== 'token' || !isNodeOfType(callExpression.arguments[0], 'Literal')) {
-        return;
-      }
-      // the first argument of `token` is the token name and
-      // can be given directly to `xcss` as it has been validated already.
-      return fixer.replaceText(entry.value, literal("'".concat(callExpression.arguments[0].value, "'")).toString());
-    }
-  });
-};
-export var supportedStylesMap = _objectSpread({
-  padding: spaceTokenPositiveMap,
-  paddingBlock: spaceTokenPositiveMap,
-  paddingBlockEnd: spaceTokenPositiveMap,
-  paddingBlockStart: spaceTokenPositiveMap,
-  paddingBottom: spaceTokenPositiveMap,
-  paddingInline: spaceTokenPositiveMap,
-  paddingInlineEnd: spaceTokenPositiveMap,
-  paddingInlineStart: spaceTokenPositiveMap,
-  paddingLeft: spaceTokenPositiveMap,
-  paddingRight: spaceTokenPositiveMap,
-  paddingTop: spaceTokenPositiveMap,
-  margin: spaceTokenMap,
-  marginBlock: spaceTokenMap,
-  marginBlockEnd: spaceTokenMap,
-  marginBlockStart: spaceTokenMap,
-  marginBottom: spaceTokenMap,
-  marginInline: spaceTokenMap,
-  marginInlineEnd: spaceTokenMap,
-  marginInlineStart: spaceTokenMap,
-  marginLeft: spaceTokenMap,
-  marginRight: spaceTokenMap,
-  marginTop: spaceTokenMap
-}, supportedDimensionAttributesMap);

package/dist/esm/rules/use-tokens-typography/utils.js

@@ -1,119 +0,0 @@
-import { callExpression, identifier, literal, memberExpression, property } from 'eslint-codemod-utils';
-import { typographyPalette } from '@atlaskit/tokens/palettes-raw';
-import { typography as typographyTokens } from '@atlaskit/tokens/tokens-raw';
-export var typographyValueToToken = typographyTokens
-// we're filtering here to remove the `font` tokens.
-.filter(function (t) {
-  return t.attributes.group === 'typography';
-}).filter(function (t) {
-  return t.cleanName.includes('font.heading') || t.cleanName.includes('font.body');
-})
-// Filtering out UNSAFE tokens that were meant for migrations, these tokens are deprecated and will be removed in the future
-.filter(function (t) {
-  return !t.cleanName.includes('UNSAFE');
-}).map(function (currentToken) {
-  var _typographyPalette$fi, _typographyPalette$fi2, _typographyPalette$fi3;
-  var individualValues = {
-    fontSize: (_typographyPalette$fi = typographyPalette.find(function (baseToken) {
-      return baseToken.path.slice(-1)[0] ===
-      // @ts-expect-error token.original.value can be a string, due to the typographyTokens export including deprecated tokens
-      currentToken.original.value.fontSize;
-    })) === null || _typographyPalette$fi === void 0 ? void 0 : _typographyPalette$fi.value,
-    fontWeight: (_typographyPalette$fi2 = typographyPalette.find(function (baseToken) {
-      return baseToken.path.slice(-1)[0] ===
-      // @ts-expect-error token.original.value can be a string, due to the typographyTokens export including deprecated tokens
-      currentToken.original.value.fontWeight;
-    })) === null || _typographyPalette$fi2 === void 0 ? void 0 : _typographyPalette$fi2.value,
-    lineHeight: (_typographyPalette$fi3 = typographyPalette.find(function (baseToken) {
-      return baseToken.path.slice(-1)[0] ===
-      // @ts-expect-error token.original.value can be a string, due to the typographyTokens export including deprecated tokens
-      currentToken.original.value.lineHeight;
-    })) === null || _typographyPalette$fi3 === void 0 ? void 0 : _typographyPalette$fi3.value
-  };
-  return {
-    tokenName: currentToken.cleanName,
-    tokenValue: currentToken.value,
-    values: individualValues
-  };
-});
-export function findTypographyTokenForValues(fontSize, lineHeight) {
-  // Match 11px to 12px as this is what happened when transitioning from legacy to refreshed typography
-  if (fontSize === '11px') {
-    fontSize = '12px';
-  }
-  var matchingTokens = typographyValueToToken.filter(function (token) {
-    return token.values.fontSize === fontSize;
-  })
-  // If lineHeight == 1, we don't match to a token
-  .filter(function () {
-    return lineHeight === '1' ? false : true;
-  });
-  return matchingTokens;
-}
-export var fontWeightTokens = typographyTokens.filter(function (token) {
-  return token.attributes.group === 'fontWeight';
-}).map(function (token) {
-  return {
-    tokenName: token.cleanName,
-    tokenValue: token.value,
-    values: {
-      fontWeight: token.value
-    }
-  };
-});
-export function findFontWeightTokenForValue(fontWeight) {
-  var tokens = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : fontWeightTokens;
-  if (fontWeight === 'normal') {
-    fontWeight = '400';
-  }
-
-  // Match bold and 700 to 653 to match with bold weight refreshed typography
-  if (fontWeight === 'bold' || fontWeight === '700') {
-    fontWeight = '653';
-  }
-  return tokens.find(function (token) {
-    return token.values.fontWeight === fontWeight;
-  });
-}
-export var fontWeightMap = {
-  regular: '400',
-  medium: '500',
-  semibold: '600',
-  bold: '700'
-};
-export var defaultFontWeight = fontWeightMap.regular;
-function getTokenNode(tokenName, fallbackValue) {
-  var isFallbackMember = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  var callExpressionArgs = [literal({
-    value: "'".concat(tokenName, "'")
-  })];
-  if (fallbackValue) {
-    var fallback = isFallbackMember ? createMemberExpressionFromArray(fallbackValue.split('.')) : literal(fallbackValue);
-    callExpressionArgs.push(fallback);
-  }
-  return callExpression({
-    callee: identifier({
-      name: 'token'
-    }),
-    arguments: callExpressionArgs,
-    optional: false
-  });
-}
-function createMemberExpressionFromArray(array) {
-  if (array.length === 1) {
-    return identifier(array[0]);
-  }
-  var property = array.pop();
-  return memberExpression({
-    object: createMemberExpressionFromArray(array),
-    property: identifier(property)
-  });
-}
-export function getTokenProperty(propertyName, tokenName, tokenFallback) {
-  var isFallbackMember = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-  return property({
-    key: identifier(propertyName),
-    value: getTokenNode(tokenName, tokenFallback, isFallbackMember)
-  });
-}
-export { isTypographyProperty } from './is-typography-property';