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

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

@@ -1,366 +0,0 @@
-// 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';
-const 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'];
-const spacingValueToToken = Object.fromEntries(spacingScale.map(token => [token.value, token.cleanName]));
-export const isSpacingProperty = propertyName => {
-  return properties.includes(propertyName);
-};
-export const getValueFromShorthand = str => {
-  const valueString = String(str);
-  const fontFamily = /(Charlie)|(sans-serif$)|(monospace$)/;
-  const fontWeightString = /(regular$)|(medium$)|(semibold$)|(bold$)/;
-  const 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);
-};
-const isGridSize = node => 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;
-const isToken = node => isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && node.callee.name === 'token';
-const getRawExpressionForToken = (node, context) => {
-  const args = node.arguments;
-  const call = `\${token(${args.map(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;
-};
-const isFontSize = node => isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'fontSize' || node.callee.name === 'getFontSize');
-const isFontSizeSmall = node => isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && node.callee.name === 'fontSizeSmall';
-const 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 const 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;
-};
-const getValueFromIdentifier = (node, context) => {
-  if (!isNodeOfType(node, 'Identifier')) {
-    return null;
-  }
-  if (node.name === 'gridSize') {
-    return 8;
-  }
-  const scope = getScope(context, node);
-  const variable = findIdentifierInParentScope({
-    scope,
-    identifierName: node.name
-  });
-  if (!variable) {
-    return null;
-  }
-  const 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);
-};
-const getValueFromUnaryExpression = (node, context) => {
-  if (!isNodeOfType(node, 'UnaryExpression')) {
-    return null;
-  }
-  const value = getValue(node.argument, context);
-  if (!value) {
-    return null;
-  }
-
-  // eslint-disable-next-line no-eval
-  return eval(`${node.operator}(${value})`);
-};
-
-/**
- * @example
- * ```js
- * `2 ${variable} 0`
- *
- * // results in [2, NaN, 0]
- * ```
- * ```js
- * const variable = 4;
- * `2 ${variable} 0`
- *
- * // results in [2, 4, 0]
- * ```
- */
-export const getValueFromTemplateLiteralRaw = (node, context) => {
-  if (!isNodeOfType(node, `TemplateLiteral`)) {
-    return null;
-  }
-  const combinedString = node.quasis.map((q, i) => {
-    return `${q.value.raw}${node.expressions[i] ? getValue(node.expressions[i], context) : ''}`;
-  }).join('').trim();
-  const fontFamily = /(sans-serif$)|(monospace$)/;
-  if (fontFamily.test(combinedString)) {
-    return combinedString;
-  }
-  return combinedString.split(' ');
-};
-const getValueFromTemplateLiteral = (node, context) => {
-  const value = getValueFromTemplateLiteralRaw(node, context);
-  return Array.isArray(value) ? value.map(removePixelSuffix) : value;
-};
-const getValueFromBinaryExpression = (node, context) => {
-  if (!isNodeOfType(node, 'BinaryExpression')) {
-    return null;
-  }
-  const {
-    left,
-    right,
-    operator
-  } = node;
-  const leftValue = getValue(left, context);
-  const rightValue = getValue(right, context);
-  const final = rightValue && leftValue ?
-  // eslint-disable-next-line no-eval
-  eval(`${leftValue}${operator}${rightValue}`) : null;
-  return final;
-};
-const emRegex = /(.*\d+)em$/;
-const percentageRegex = /(%$)/;
-export const emToPixels = (value, fontSize) => {
-  if (typeof value === 'string') {
-    const 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;
-};
-const percentageOrEmOrAuto = /(%$)|(\d+em$)|(auto$)/;
-export const removePixelSuffix = value => {
-  if (typeof value === 'string' && (percentageOrEmOrAuto.test(value) || isCalc(value))) {
-    return value;
-  }
-  return Number(typeof value === 'string' ? value.replace('px', '') : value);
-};
-const invalidSpacingUnitRegex = /(\d+rem$)|(vw$)|(vh$)/;
-export const 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 (const val in value) {
-      if (invalidSpacingUnitRegex.test(val)) {
-        return false;
-      }
-    }
-  }
-  if (emRegex.test(value) && typeof fontSize !== 'number') {
-    return false;
-  }
-  return true;
-};
-const calcRegex = /(^calc)/;
-export const 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) {
-  const 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) {
-  const combinedString = node.quasi.quasis.map((q, i) => {
-    return `${q.value.raw}${node.quasi.expressions[i] ? getValue(node.quasi.expressions[i], context) : ''}`;
-  }).join('');
-  const rawString = node.quasi.quasis.map((q, i) => {
-    return `${q.value.raw}${node.quasi.expressions[i] ? getRawExpression(node.quasi.expressions[i], context) ? `\${${getRawExpression(node.quasi.expressions[i], context)}}` : null : ''}`;
-  }).join('');
-  const cssProperties = splitCssProperties(cleanComments(combinedString));
-  const 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((cssProperty, index) => [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) {
-  const token = findTokenNameByPropertyValue(propertyName, value);
-  const fallbackValue = propertyName === 'fontFamily' ? {
-    value: `${value}`,
-    raw: `\`${value}\``
-  } : `${value}`;
-  return callExpression({
-    callee: identifier({
-      name: 'token'
-    }),
-    arguments: [literal({
-      value: `'${token !== null && token !== void 0 ? token : ''}'`
-    }), literal(fallbackValue)],
-    optional: false
-  });
-}
-export function getFontSizeValueInScope(cssProperties) {
-  const fontSizeNode = cssProperties.find(([style]) => {
-    const [rawProperty, value] = style.split(':');
-    return /font-size/.test(rawProperty) ? value : null;
-  });
-  if (!fontSizeNode) {
-    return undefined;
-  }
-  const [_, fontSizeValue] = fontSizeNode[0].split(':');
-  if (!fontSizeValue) {
-    return undefined;
-  }
-  return getValueFromShorthand(fontSizeValue)[0];
-}
-export function findTokenNameByPropertyValue(propertyName, value) {
-  const lookupValue = normaliseValue(propertyName, value);
-  const 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) {
-  const tokenName = findTokenNameByPropertyValue(propertyName, value);
-  if (!tokenName) {
-    return undefined;
-  }
-  const fallbackValue = normaliseValue(propertyName, value);
-  return getTokenNodeForValue(propertyName, fallbackValue);
-}
-export function getPropertyNodeFromParent(property, parentNode) {
-  const propertyNode = parentNode.properties.find(node => {
-    if (!isNodeOfType(node, 'Property')) {
-      return;
-    }
-    if (!isNodeOfType(node.key, 'Identifier')) {
-      return;
-    }
-    return node.key.name === property;
-  });
-  return propertyNode;
-}
-export function getValueForPropertyNode(propertyNode, context) {
-  const propertyValueRaw = isNodeOfType(propertyNode, 'Property') ? getValue(propertyNode.value, context) : null;
-  const propertyValue = Array.isArray(propertyValueRaw) ? propertyValueRaw[0] : propertyValueRaw;
-  return propertyValue;
-}

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

@@ -1,98 +0,0 @@
-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 const 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.
-   */
-  const cssAttr = getJSXAttributeByName(node.openingElement, 'css');
-  const cssVariableName = getAttributeValueIdentifier(cssAttr);
-  if (!cssVariableName) {
-    return [];
-  }
-  const cssVariableDefinition = getIdentifierInParentScope(getScope(context, node), cssVariableName);
-  const cssVariableValue = getVariableDefinitionValue(cssVariableDefinition);
-  if (!cssVariableValue) {
-    return [];
-  }
-  const cssObjectExpression = getFunctionArgumentAtPos(cssVariableValue, 0);
-  return [
-  // Update `css` function name to `xcss`.
-  fixer.replaceText(cssVariableValue.node.init.callee, identifier('xcss').toString()), ...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 const styledObjectToXcssTokens = (styles, fixer) => {
-  return styles.properties.map(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')) {
-      const value = entry.value.value;
-      if (typeof value !== 'string') {
-        return;
-      }
-      return fixer.replaceText(entry.value, literal(`'${supportedStylesMap[entry.key.name][value]}'`).toString());
-    }
-    // maps token calls like: token('space.100') to 'space.100'
-    if (isNodeOfType(entry.value, 'CallExpression')) {
-      const 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(`'${callExpression.arguments[0].value}'`).toString());
-    }
-  });
-};
-export const supportedStylesMap = {
-  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/es2019/rules/use-tokens-typography/utils.js

@@ -1,96 +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 const typographyValueToToken = typographyTokens
-// we're filtering here to remove the `font` tokens.
-.filter(t => t.attributes.group === 'typography').filter(t => 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(t => !t.cleanName.includes('UNSAFE')).map(currentToken => {
-  var _typographyPalette$fi, _typographyPalette$fi2, _typographyPalette$fi3;
-  const individualValues = {
-    fontSize: (_typographyPalette$fi = typographyPalette.find(baseToken => 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(baseToken => 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(baseToken => 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';
-  }
-  let matchingTokens = typographyValueToToken.filter(token => token.values.fontSize === fontSize)
-  // If lineHeight == 1, we don't match to a token
-  .filter(() => lineHeight === '1' ? false : true);
-  return matchingTokens;
-}
-export const fontWeightTokens = typographyTokens.filter(token => token.attributes.group === 'fontWeight').map(token => {
-  return {
-    tokenName: token.cleanName,
-    tokenValue: token.value,
-    values: {
-      fontWeight: token.value
-    }
-  };
-});
-export function findFontWeightTokenForValue(fontWeight, tokens = 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(token => token.values.fontWeight === fontWeight);
-}
-export const fontWeightMap = {
-  regular: '400',
-  medium: '500',
-  semibold: '600',
-  bold: '700'
-};
-export const defaultFontWeight = fontWeightMap.regular;
-function getTokenNode(tokenName, fallbackValue, isFallbackMember = false) {
-  const callExpressionArgs = [literal({
-    value: `'${tokenName}'`
-  })];
-  if (fallbackValue) {
-    const 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]);
-  }
-  const property = array.pop();
-  return memberExpression({
-    object: createMemberExpressionFromArray(array),
-    property: identifier(property)
-  });
-}
-export function getTokenProperty(propertyName, tokenName, tokenFallback, isFallbackMember = false) {
-  return property({
-    key: identifier(propertyName),
-    value: getTokenNode(tokenName, tokenFallback, isFallbackMember)
-  });
-}
-export { isTypographyProperty } from './is-typography-property';

package/dist/es2019/rules/utils/is-color.js

@@ -1,38 +0,0 @@
-const namedColors = new Set(['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']);
-const legacyColors = new Set(['R50', 'R75', 'R100', 'R200', 'R300', 'R400', 'R500', 'Y50', 'Y75', 'Y100', 'Y200', 'Y300', 'Y400', 'Y500', 'G50', 'G75', 'G100', 'G200', 'G300', 'G400', 'G500', 'B50', 'B75', 'B100', 'B200', 'B300', 'B400', 'B500', 'P50', 'P75', 'P100', 'P200', 'P300', 'P400', 'P500', 'T50', 'T75', 'T100', 'T200', 'T300', 'T400', 'T500', 'N0', 'N10', 'N20', 'N30', 'N40', 'N50', 'N60', 'N70', 'N80', 'N90', 'N100', 'N200', 'N300', 'N400', 'N500', 'N600', 'N700', 'N800', 'N900', 'N10A', 'N20A', 'N30A', 'N40A', 'N50A', 'N60A', 'N70A', 'N80A', 'N90A', 'N100A', 'N200A', 'N300A', 'N400A', 'N500A', 'N600A', 'N700A', 'N800A', 'DN900', 'DN800', 'DN700', 'DN600', 'DN500', 'DN400', 'DN300', 'DN200', 'DN100', 'DN90', 'DN80', 'DN70', 'DN60', 'DN50', 'DN40', 'DN30', 'DN20', 'DN10', 'DN0', 'DN800A', 'DN700A', 'DN600A', 'DN500A', 'DN400A', 'DN300A', 'DN200A', 'DN100A', 'DN90A', 'DN80A', 'DN70A', 'DN60A', 'DN50A', 'DN40A', 'DN30A', 'DN20A', 'DN10A',
-// Legacy Trello colors:
-'AtlassianBlue50', 'AtlassianBlue200', 'AtlassianBlue300', 'AtlassianBlue400', 'TrelloBlue25', 'TrelloBlue50', 'TrelloBlue100', 'TrelloBlue200', 'TrelloBlue300', 'TrelloBlue400', 'TrelloBlue500', 'TrelloBlue600', 'TrelloBlue700', 'TrelloBlue800', 'TrelloBlue900', 'Green50', 'Green100', 'Green200', 'Green300', 'Green400', 'Green500', 'Green600', 'Green700', 'Green800', 'Green900', 'Orange50', 'Orange100', 'Orange200', 'Orange300', 'Orange400', 'Orange500', 'Orange600', 'Orange700', 'Orange800', 'Orange900', 'Red50', 'Red100', 'Red200', 'Red300', 'Red400', 'Red500', 'Red600', 'Red700', 'Red800', 'Red900', 'Yellow50', 'Yellow100', 'Yellow200', 'Yellow300', 'Yellow400', 'Yellow500', 'Yellow600', 'Yellow700', 'Yellow800', 'Yellow900', 'Purple50', 'Purple100', 'Purple200', 'Purple300', 'Purple400', 'Purple500', 'Purple600', 'Purple700', 'Purple800', 'Purple900', 'VioletMbgAlert', 'Pink50', 'Pink100', 'Pink200', 'Pink300', 'Pink400', 'Pink500', 'Pink600', 'Pink700', 'Pink800', 'Pink900', 'Sky25', 'Sky50', 'Sky100', 'Sky200', 'Sky300', 'Sky400', 'Sky500', 'Sky600', 'Sky700', 'Sky800', 'Sky900', 'Lime50', 'Lime100', 'Lime200', 'Lime300', 'Lime400', 'Lime500', 'Lime600', 'Lime700', 'Lime800', 'Lime900', 'BusinessBlue50', 'BusinessBlue100', 'BusinessBlue200', 'BusinessBlue300', 'BusinessBlue400', 'BusinessBlue500', 'BusinessBlue600', 'BusinessBlue700', 'BusinessBlue800', 'BusinessBlue900', 'Opacity1', 'Opacity2', 'Opacity3', 'Opacity4', 'Opacity5', 'Opacity6', 'Opacity7', 'Opacity8', 'Opacity9', 'OpacityDark1', 'OpacityDark2', 'OpacityDark3', 'OpacityDark4', 'OpacityDark5', 'OpacityDark6', 'OpacityDark7', 'OpacityDark8', 'OpacityDark9', 'Black']);
-const legacyColorMixins = new Set(['background', 'backgroundActive', 'backgroundHover', 'backgroundOnLayer', 'text', 'textHover', 'textActive', 'subtleText', 'placeholderText', 'heading', 'subtleHeading', 'codeBlock', 'link', 'linkHover', 'linkActive', 'linkOutline', 'primary', 'blue', 'teal', 'purple', 'red', 'yellow', 'green', 'skeleton']);
-const includesWholeWord = (value, options) => {
-  const values = value.replace(/[^a-zA-Z ]/g, ' ').trim().split(/(?:,|\.| )+/);
-  return values.some(value => options.has(value));
-};
-export const isLegacyColor = value => legacyColors.has(value);
-export const isLegacyNamedColor = value => legacyColorMixins.has(value);
-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?|(lch|lab|color))\([^\)]*\)/.exec(value.toLowerCase())) {
-    return true;
-  }
-  if (includesWholeWord(value, namedColors)) {
-    return true;
-  }
-  return false;
-};
-export const isHardCodedColor = value => {
-  if (includesWholeWord(value.toLowerCase(), namedColors)) {
-    return true;
-  }
-  if (value.startsWith('rgb(') || value.startsWith('rgba(') || value.startsWith('hsl(') || value.startsWith('hsla(') || value.startsWith('lch(') || value.startsWith('lab(') || value.startsWith('color(')) {
-    return true;
-  }
-  if (value.startsWith('#') && (
-  // short hex, hex, or hex with alpha
-  value.length === 4 || value.length === 7 || value.length === 9)) {
-    return true;
-  }
-  return false;
-};
-const validColorPropertyNames = new Set(['color', 'background', 'background-color', 'border', 'border-left', 'border-right', 'border-top', 'border-bottom', 'border-color', 'border-left-color', 'border-right-color', 'border-top-color', 'border-bottom-color', 'outline', 'outline-color', 'box-shadow']);
-const kebabize = str => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());
-export const isColorCssPropertyName = value => validColorPropertyNames.has(kebabize(value));