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

package/dist/es2019/rules/no-html-image/node-types/supported.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
+import { JSXElement } from '../../../ast-nodes/jsx-element';
 const supportedElements = [{
   name: 'img'
 }, {
@@ -20,7 +20,7 @@ export function isSupportedForLint(jsxNode, elementName) {
 
   // Allow passing in the element name because the jsxNode doesn't
   // represent the element name with styled components
-  const elName = elementName || ast.JSXElement.getName(jsxNode);
+  const elName = elementName || JSXElement.getName(jsxNode);
   if (!elName) {
     return false;
   }
@@ -42,7 +42,7 @@ export function isSupportedForLint(jsxNode, elementName) {
   }
 
   // Check if the element has any attributes that are not supported
-  const attributes = ast.JSXElement.getAttributes(jsxNode);
+  const attributes = JSXElement.getAttributes(jsxNode);
   if (supportedElement.attributes && !supportedElement.attributes.every(({
     name,
     values

package/dist/es2019/rules/no-html-radio/index.js

@@ -1,5 +1,5 @@
 import { createLintRule } from '../utils/create-rule';
-import { JSXElement } from './node-types';
+import { JSXElement } from './node-types/jsx-element';
 const rule = createLintRule({
   meta: {
     name: 'no-html-radio',

package/dist/es2019/rules/no-html-radio/node-types/jsx-element/index.js

@@ -1,4 +1,4 @@
-import * as ast from '../../../../ast-nodes';
+import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
 import { isSupportedForLint } from '../supported';
 export const JSXElement = {
   lint(node, {
@@ -7,7 +7,7 @@ export const JSXElement = {
     if (!isSupportedForLint(node)) {
       return;
     }
-    const nodeName = ast.JSXElement.getName(node);
+    const nodeName = JSXElementHelper.getName(node);
     context.report({
       node: node.openingElement,
       messageId: 'noHtmlRadio',

package/dist/es2019/rules/no-html-radio/node-types/supported.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
+import { JSXElement } from '../../../ast-nodes/jsx-element';
 const supportedElements = [{
   name: 'input',
   attributes: [{
@@ -18,7 +18,7 @@ export function isSupportedForLint(jsxNode, elementName) {
 
   // Allow passing in the element name because the jsxNode doesn't
   // represent the element name with styled components
-  const elName = elementName || ast.JSXElement.getName(jsxNode);
+  const elName = elementName || JSXElement.getName(jsxNode);
   if (!elName) {
     return false;
   }
@@ -40,7 +40,7 @@ export function isSupportedForLint(jsxNode, elementName) {
   }
 
   // Check if the element has any attributes that are not supported
-  const attributes = ast.JSXElement.getAttributes(jsxNode);
+  const attributes = JSXElement.getAttributes(jsxNode);
   if (supportedElement.attributes && !supportedElement.attributes.every(({
     name,
     values

package/dist/es2019/rules/no-html-range/index.js

@@ -1,5 +1,5 @@
 import { createLintRule } from '../utils/create-rule';
-import { JSXElement } from './node-types';
+import { JSXElement } from './node-types/jsx-element';
 const rule = createLintRule({
   meta: {
     name: 'no-html-range',

package/dist/es2019/rules/no-html-range/node-types/jsx-element/index.js

@@ -1,4 +1,4 @@
-import * as ast from '../../../../ast-nodes';
+import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
 import { isSupportedForLint } from '../supported';
 export const JSXElement = {
   lint(node, {
@@ -7,7 +7,7 @@ export const JSXElement = {
     if (!isSupportedForLint(node)) {
       return;
     }
-    const nodeName = ast.JSXElement.getName(node);
+    const nodeName = JSXElementHelper.getName(node);
     context.report({
       node: node.openingElement,
       messageId: 'noHtmlRange',

package/dist/es2019/rules/no-html-range/node-types/supported.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
+import { JSXElement } from '../../../ast-nodes/jsx-element';
 const supportedElements = [{
   name: 'input',
   attributes: [{
@@ -18,7 +18,7 @@ export function isSupportedForLint(jsxNode, elementName) {
 
   // Allow passing in the element name because the jsxNode doesn't
   // represent the element name with styled components
-  const elName = elementName || ast.JSXElement.getName(jsxNode);
+  const elName = elementName || JSXElement.getName(jsxNode);
   if (!elName) {
     return false;
   }
@@ -40,7 +40,7 @@ export function isSupportedForLint(jsxNode, elementName) {
   }
 
   // Check if the element has any attributes that are not supported
-  const attributes = ast.JSXElement.getAttributes(jsxNode);
+  const attributes = JSXElement.getAttributes(jsxNode);
   if (supportedElement.attributes && !supportedElement.attributes.every(({
     name,
     values

package/dist/es2019/rules/no-html-select/index.js

@@ -1,5 +1,6 @@
 import { createLintRule } from '../utils/create-rule';
-import { JSXElement, StyledComponent } from './node-types';
+import { JSXElement } from './node-types/jsx-element';
+import { StyledComponent } from './node-types/styled-component';
 const rule = createLintRule({
   meta: {
     name: 'no-html-select',

package/dist/es2019/rules/no-html-select/node-types/jsx-element/index.js

@@ -1,4 +1,4 @@
-import * as ast from '../../../../ast-nodes';
+import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
 import { isSupportedForLint } from '../supported';
 export const JSXElement = {
   lint(node, {
@@ -7,7 +7,7 @@ export const JSXElement = {
     if (!isSupportedForLint(node)) {
       return;
     }
-    const nodeName = ast.JSXElement.getName(node);
+    const nodeName = JSXElementHelper.getName(node);
     context.report({
       node: node.openingElement,
       messageId: 'noHtmlSelect',

package/dist/es2019/rules/no-html-select/node-types/supported.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
+import { JSXElement } from '../../../ast-nodes/jsx-element';
 const supportedElements = [{
   name: 'select'
 }];
@@ -14,7 +14,7 @@ export function isSupportedForLint(jsxNode, elementName) {
 
   // Allow passing in the element name because the jsxNode doesn't
   // represent the element name with styled components
-  const elName = elementName || ast.JSXElement.getName(jsxNode);
+  const elName = elementName || JSXElement.getName(jsxNode);
   if (!elName) {
     return false;
   }
@@ -36,7 +36,7 @@ export function isSupportedForLint(jsxNode, elementName) {
   }
 
   // Check if the element has any attributes that are not supported
-  const attributes = ast.JSXElement.getAttributes(jsxNode);
+  const attributes = JSXElement.getAttributes(jsxNode);
   if (supportedElement.attributes && !supportedElement.attributes.every(({
     name,
     values

package/dist/es2019/rules/no-html-text-input/index.js

@@ -1,5 +1,5 @@
 import { createLintRule } from '../utils/create-rule';
-import { JSXElement } from './node-types';
+import { JSXElement } from './node-types/jsx-element';
 const rule = createLintRule({
   meta: {
     name: 'no-html-text-input',

package/dist/es2019/rules/no-html-text-input/node-types/jsx-element/index.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import * as ast from '../../../../ast-nodes';
+import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
 import { isSupportedForLint } from '../supported';
 function isImportDeclaration(node) {
   return node.type === 'ImportDeclaration';
@@ -12,7 +12,7 @@ export const JSXElement = {
     if (!isSupportedForLint(node)) {
       return;
     }
-    const nodeName = ast.JSXElement.getName(node);
+    const nodeName = JSXElementHelper.getName(node);
     const sourceCode = getSourceCode(context);
     const importDeclarations = sourceCode.ast.body.filter(isImportDeclaration);
     let existingTextfieldName = null;

package/dist/es2019/rules/no-html-text-input/node-types/supported.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
+import { JSXElement } from '../../../ast-nodes/jsx-element';
 const supportedElements = [{
   name: 'input',
   attributes: [{
@@ -19,7 +19,7 @@ export function isSupportedForLint(jsxNode, elementName) {
 
   // Allow passing in the element name because the jsxNode doesn't
   // represent the element name with styled components
-  const elName = elementName || ast.JSXElement.getName(jsxNode);
+  const elName = elementName || JSXElement.getName(jsxNode);
   if (!elName) {
     return false;
   }
@@ -41,7 +41,7 @@ export function isSupportedForLint(jsxNode, elementName) {
   }
 
   // Check if the element has any attributes that are not supported
-  const attributes = ast.JSXElement.getAttributes(jsxNode);
+  const attributes = JSXElement.getAttributes(jsxNode);
   if (supportedElement.attributes &&
   // If not every attribute resolves to `true`
   !supportedElement.attributes.every(({

package/dist/es2019/rules/no-html-textarea/index.js

@@ -1,5 +1,6 @@
 import { createLintRule } from '../utils/create-rule';
-import { JSXElement, StyledComponent } from './node-types';
+import { JSXElement } from './node-types/jsx-element';
+import { StyledComponent } from './node-types/styled-component';
 const rule = createLintRule({
   meta: {
     name: 'no-html-textarea',

package/dist/es2019/rules/no-html-textarea/node-types/jsx-element/index.js

@@ -1,5 +1,5 @@
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import * as ast from '../../../../ast-nodes';
+import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
 import { isSupportedForLint } from '../supported';
 function isImportDeclaration(node) {
   return node.type === 'ImportDeclaration';
@@ -11,7 +11,7 @@ export const JSXElement = {
     if (!isSupportedForLint(node)) {
       return;
     }
-    const nodeName = ast.JSXElement.getName(node);
+    const nodeName = JSXElementHelper.getName(node);
     const sourceCode = getSourceCode(context);
     const importDeclarations = sourceCode.ast.body.filter(isImportDeclaration);
     let existingTextareaName = null;

package/dist/es2019/rules/no-html-textarea/node-types/supported.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import * as ast from '../../../ast-nodes';
+import { JSXElement } from '../../../ast-nodes/jsx-element';
 const supportedElements = [{
   name: 'textarea'
 }];
@@ -14,7 +14,7 @@ export function isSupportedForLint(jsxNode, elementName) {
 
   // Allow passing in the element name because the jsxNode doesn't
   // represent the element name with styled components
-  const elName = elementName || ast.JSXElement.getName(jsxNode);
+  const elName = elementName || JSXElement.getName(jsxNode);
   if (!elName) {
     return false;
   }
@@ -36,7 +36,7 @@ export function isSupportedForLint(jsxNode, elementName) {
   }
 
   // Check if the element has any attributes that are not supported
-  const attributes = ast.JSXElement.getAttributes(jsxNode);
+  const attributes = JSXElement.getAttributes(jsxNode);
   if (supportedElement.attributes && !supportedElement.attributes.every(({
     name,
     values

package/dist/es2019/rules/no-icon-spacing-prop/get-css-map-key.js

@@ -0,0 +1,7 @@
+/**
+ * Maps a padding token to a cssMap key name.
+ * e.g. 'space.050' → 'space050'
+ */
+export function getCssMapKey(paddingToken) {
+  return paddingToken.replace('space.', 'space');
+}

package/dist/es2019/rules/no-icon-spacing-prop/get-icon-size.js

@@ -0,0 +1,16 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { getStaticAttributeValue } from './get-static-attribute-value';
+
+/**
+ * Returns the static `size` prop value, defaulting to 'medium' if not present.
+ */
+export function getIconSize(node) {
+  if (!isNodeOfType(node.openingElement, 'JSXOpeningElement')) {
+    return 'medium';
+  }
+  const sizeAttr = node.openingElement.attributes.find(a => a.type === 'JSXAttribute' && a.name.name === 'size');
+  if (!sizeAttr) {
+    return 'medium';
+  }
+  return getStaticAttributeValue(sizeAttr);
+}

package/dist/es2019/rules/no-icon-spacing-prop/get-spacing-attribute.js

@@ -0,0 +1,11 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+
+/**
+ * Returns the `spacing` JSXAttribute from an icon element, or undefined.
+ */
+export function getSpacingAttribute(node) {
+  if (!isNodeOfType(node.openingElement, 'JSXOpeningElement')) {
+    return undefined;
+  }
+  return node.openingElement.attributes.find(a => a.type === 'JSXAttribute' && a.name.name === 'spacing');
+}

package/dist/es2019/rules/no-icon-spacing-prop/get-static-attribute-value.js

@@ -0,0 +1,9 @@
+/**
+ * Returns the static string value of a JSXAttribute, or undefined if dynamic.
+ */
+export function getStaticAttributeValue(attr) {
+  if (attr.value && attr.value.type === 'Literal' && typeof attr.value.value === 'string') {
+    return attr.value.value;
+  }
+  return undefined;
+}

package/dist/es2019/rules/no-icon-spacing-prop/has-spread-props.js

@@ -0,0 +1,6 @@
+/**
+ * Returns true if the element has any JSXSpreadAttribute.
+ */
+export function hasSpreadProps(node) {
+  return node.openingElement.attributes.some(a => a.type === 'JSXSpreadAttribute');
+}

package/dist/es2019/rules/no-icon-spacing-prop/index.js

@@ -1,7 +1,17 @@
 import { createIsFromImportSourceFor } from '../../common/is-from-import-source';
 import { createLintRule } from '../utils/create-rule';
 import { errorBoundary } from '../utils/error-boundary';
-import { CSSMAP_VARIABLE_NAME, getCssMapKey, getIconSize, getSpacingAttribute, getStaticAttributeValue, hasSpreadProps, SPACING_TO_PADDING, upsertCssMapImport, upsertCssMapVariable, upsertFlexImport, upsertTokenImport } from './helpers';
+import { getCssMapKey } from './get-css-map-key';
+import { getIconSize } from './get-icon-size';
+import { getSpacingAttribute } from './get-spacing-attribute';
+import { getStaticAttributeValue } from './get-static-attribute-value';
+import { hasSpreadProps } from './has-spread-props';
+import { SPACING_TO_PADDING } from './spacing-to-padding';
+import { upsertCssMapImport } from './upsert-css-map-import';
+import { upsertCssMapVariable } from './upsert-css-map-variable';
+import { upsertFlexImport } from './upsert-flex-import';
+import { upsertTokenImport } from './upsert-token-import';
+const CSSMAP_VARIABLE_NAME = 'iconSpacingStyles';
 const rule = createLintRule({
   meta: {
     name: 'no-icon-spacing-prop',

package/dist/es2019/rules/no-icon-spacing-prop/spacing-to-padding.js

@@ -0,0 +1,14 @@
+/**
+ * Padding token mapping based on icon size and spacing value.
+ * Same mapping as the codemod `icon-spacing-to-box-primitive`.
+ */
+export const SPACING_TO_PADDING = {
+  medium: {
+    compact: 'space.050',
+    spacious: 'space.050'
+  },
+  small: {
+    compact: 'space.025',
+    spacious: 'space.075'
+  }
+};

package/dist/es2019/rules/no-icon-spacing-prop/upsert-css-map-import.js

@@ -0,0 +1,36 @@
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
+import { Import } from '../../ast-nodes/import';
+import { Root } from '../../ast-nodes/root';
+const CSS_IMPORT_MODULE = '@atlaskit/css';
+
+/**
+ * Upserts `cssMap` from `@atlaskit/css`, handling:
+ * 1. Already imported → no-op
+ * 2. `@atlaskit/css` exists but missing `cssMap` → add specifier
+ * 3. No import → insert new `import { cssMap } from '@atlaskit/css'`
+ */
+export function upsertCssMapImport(context, fixer) {
+  const root = getSourceCode(context).ast.body;
+  const cssImports = root.filter(node => node.type === 'ImportDeclaration' && node.source.value === CSS_IMPORT_MODULE);
+  if (cssImports.length > 0) {
+    const decl = cssImports[0];
+    const hasCssMap = Import.containsNamedSpecifier(decl, 'cssMap');
+    if (hasCssMap) {
+      return undefined;
+    }
+    const specifiers = decl.specifiers.filter(s => s.type === 'ImportSpecifier').map(s => s.local.name);
+    specifiers.push('cssMap');
+    specifiers.sort();
+    return fixer.replaceText(decl, `import { ${specifiers.join(', ')} } from '${CSS_IMPORT_MODULE}';`);
+  }
+
+  // If cssMap is already imported from another package (e.g. @compiled/react), don't add a duplicate
+  const cssMapAlreadyImported = root.some(node => node.type === 'ImportDeclaration' && node.specifiers.some(s => s.type === 'ImportSpecifier' && s.local.name === 'cssMap'));
+  if (cssMapAlreadyImported) {
+    return undefined;
+  }
+  return Root.upsertNamedImportDeclaration({
+    module: CSS_IMPORT_MODULE,
+    specifiers: ['cssMap']
+  }, context, fixer);
+}

package/dist/es2019/rules/no-icon-spacing-prop/upsert-css-map-variable.js

@@ -0,0 +1,48 @@
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
+import { getCssMapKey } from './get-css-map-key';
+const CSSMAP_VARIABLE_NAME = 'iconSpacingStyles';
+
+/**
+ * Inserts or updates `const iconSpacingStyles = cssMap({ spaceXXX: { padding: token('space.XXX') } })`
+ * after the last import statement.
+ *
+ * If `iconSpacingStyles` already exists, adds the new key to the existing cssMap object.
+ * If it doesn't exist, inserts a new declaration after the last import.
+ */
+export function upsertCssMapVariable(context, fixer, paddingToken) {
+  const sourceCode = getSourceCode(context);
+  const body = sourceCode.ast.body;
+  const key = getCssMapKey(paddingToken);
+  const keyValuePair = `  ${key}: { paddingBlock: token('${paddingToken}'), paddingInline: token('${paddingToken}') }`;
+
+  // Check if iconSpacingStyles cssMap variable already exists
+  const existingVar = body.find(node => {
+    var _node$declarations$, _node$declarations$0$;
+    return node.type === 'VariableDeclaration' && ((_node$declarations$ = node.declarations[0]) === null || _node$declarations$ === void 0 ? void 0 : _node$declarations$.type) === 'VariableDeclarator' && ((_node$declarations$0$ = node.declarations[0].id) === null || _node$declarations$0$ === void 0 ? void 0 : _node$declarations$0$.name) === CSSMAP_VARIABLE_NAME;
+  });
+  if (existingVar) {
+    // Check if the key already exists in the cssMap
+    const varText = sourceCode.getText(existingVar);
+    if (varText.includes(key + ':') || varText.includes(`'${key}'`)) {
+      return undefined;
+    }
+    // Add the key to the existing cssMap — insert before the closing }
+    const closingBrace = sourceCode.getText(existingVar).lastIndexOf('}');
+    const existingVarStart = existingVar.range[0];
+    return fixer.insertTextAfterRange([existingVarStart, existingVarStart + closingBrace], `,\n${keyValuePair}\n`);
+  }
+
+  // Find last import to insert after it
+  const lastImport = [...body].reverse().find(n => n.type === 'ImportDeclaration');
+  const declaration = `\nconst ${CSSMAP_VARIABLE_NAME} = cssMap({\n${keyValuePair},\n});`;
+  if (lastImport) {
+    return fixer.insertTextAfter(lastImport, declaration);
+  }
+
+  // No imports — insert at the start of the file
+  const firstNode = body[0];
+  if (firstNode) {
+    return fixer.insertTextBefore(firstNode, declaration);
+  }
+  return undefined;
+}

package/dist/es2019/rules/no-icon-spacing-prop/upsert-flex-import.js

@@ -0,0 +1,41 @@
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
+import { Import } from '../../ast-nodes/import';
+import { Root } from '../../ast-nodes/root';
+const FLEX_IMPORT_MODULE = '@atlaskit/primitives/compiled';
+const FLEX_IMPORT_MODULE_NON_COMPILED = '@atlaskit/primitives';
+
+/**
+ * Upserts `Flex` from `@atlaskit/primitives/compiled`, handling:
+ * 1. Already imported from `/compiled` → add Flex if missing
+ * 2. Import from `@atlaskit/primitives` (non-compiled) → migrate path + add Flex
+ * 3. No import → insert new `import { Flex } from '@atlaskit/primitives/compiled'`
+ */
+export function upsertFlexImport(context, fixer) {
+  const root = getSourceCode(context).ast.body;
+  const findExactImports = module => root.filter(node => node.type === 'ImportDeclaration' && node.source.value === module);
+  const compiledImports = findExactImports(FLEX_IMPORT_MODULE);
+  if (compiledImports.length > 0) {
+    const decl = compiledImports[0];
+    if (Import.containsNamedSpecifier(decl, 'Flex')) {
+      return undefined;
+    }
+    const specifiers = decl.specifiers.filter(s => s.type === 'ImportSpecifier').map(s => s.local.name);
+    specifiers.push('Flex');
+    specifiers.sort();
+    return fixer.replaceText(decl, `import { ${specifiers.join(', ')} } from '${FLEX_IMPORT_MODULE}';`);
+  }
+  const nonCompiledImports = findExactImports(FLEX_IMPORT_MODULE_NON_COMPILED);
+  if (nonCompiledImports.length > 0) {
+    const decl = nonCompiledImports[0];
+    const specifiers = decl.specifiers.filter(s => s.type === 'ImportSpecifier').map(s => s.local.name);
+    if (!specifiers.includes('Flex')) {
+      specifiers.push('Flex');
+    }
+    specifiers.sort();
+    return fixer.replaceText(decl, `import { ${specifiers.join(', ')} } from '${FLEX_IMPORT_MODULE}';`);
+  }
+  return Root.upsertNamedImportDeclaration({
+    module: FLEX_IMPORT_MODULE,
+    specifiers: ['Flex']
+  }, context, fixer);
+}

package/dist/es2019/rules/no-icon-spacing-prop/upsert-token-import.js

@@ -0,0 +1,29 @@
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
+import { Import } from '../../ast-nodes/import';
+import { Root } from '../../ast-nodes/root';
+const TOKEN_IMPORT_MODULE = '@atlaskit/tokens';
+
+/**
+ * Upserts `token` from `@atlaskit/tokens`, handling:
+ * 1. Already imported → no-op
+ * 2. `@atlaskit/tokens` exists but missing `token` → add specifier
+ * 3. No import → insert new `import { token } from '@atlaskit/tokens'`
+ */
+export function upsertTokenImport(context, fixer) {
+  const root = getSourceCode(context).ast.body;
+  const tokenImports = root.filter(node => node.type === 'ImportDeclaration' && node.source.value === TOKEN_IMPORT_MODULE);
+  if (tokenImports.length > 0) {
+    const decl = tokenImports[0];
+    if (Import.containsNamedSpecifier(decl, 'token')) {
+      return undefined;
+    }
+    const specifiers = decl.specifiers.filter(s => s.type === 'ImportSpecifier').map(s => s.local.name);
+    specifiers.push('token');
+    specifiers.sort();
+    return fixer.replaceText(decl, `import { ${specifiers.join(', ')} } from '${TOKEN_IMPORT_MODULE}';`);
+  }
+  return Root.upsertNamedImportDeclaration({
+    module: TOKEN_IMPORT_MODULE,
+    specifiers: ['token']
+  }, context, fixer);
+}

package/dist/es2019/rules/no-invalid-css-map/get-css-map-object.js

@@ -0,0 +1,12 @@
+export const getCssMapObject = node => {
+  // We assume the argument `node` is already a cssMap() call.
+
+  // Things like the number of arguments to cssMap and the type of
+  // cssMap's argument are handled by the TypeScript compiler, so
+  // we don't bother with creating eslint errors for these here
+
+  if (node.arguments.length !== 1 || node.arguments[0].type !== 'ObjectExpression') {
+    return;
+  }
+  return node.arguments[0];
+};

package/dist/es2019/rules/no-invalid-css-map/index.js

@@ -2,7 +2,8 @@ import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { CSS_IN_JS_IMPORTS, isCssMap } from '@atlaskit/eslint-utils/is-supported-import';
 import { checkIfSupportedExport } from '../utils/create-no-exported-rule/check-if-supported-export';
 import { createLintRule } from '../utils/create-rule';
-import { CssMapObjectChecker, getCssMapObject } from './utils';
+import { getCssMapObject } from './get-css-map-object';
+import { CssMapObjectChecker } from './utils';
 const IMPORT_SOURCES = [CSS_IN_JS_IMPORTS.compiled, CSS_IN_JS_IMPORTS.atlaskitCss];
 const reportIfExported = (node, context) => {
   const state = checkIfSupportedExport(context, node, IMPORT_SOURCES);

package/dist/es2019/rules/no-invalid-css-map/utils.js

@@ -1,18 +1,6 @@
 import { getAllowedFunctionCalls, isAllowListedVariable } from '@atlaskit/eslint-utils/allowed-function-calls';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { findVariable } from '@atlaskit/eslint-utils/find-variable';
-export const getCssMapObject = node => {
-  // We assume the argument `node` is already a cssMap() call.
-
-  // Things like the number of arguments to cssMap and the type of
-  // cssMap's argument are handled by the TypeScript compiler, so
-  // we don't bother with creating eslint errors for these here
-
-  if (node.arguments.length !== 1 || node.arguments[0].type !== 'ObjectExpression') {
-    return;
-  }
-  return node.arguments[0];
-};
 export class CssMapObjectChecker {
   constructor(cssMapObject, context) {
     this.allowedFunctionCalls = getAllowedFunctionCalls(context.options);

package/dist/es2019/rules/no-physical-properties/index.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { createLintRule } from '../utils/create-rule';
-import { physicalLogicalMap } from './logical-physical-map';
+import { physicalLogicalMap } from './physical-logical-map';
 const rule = createLintRule({
   meta: {
     name: 'no-physical-properties',

package/dist/es2019/rules/no-physical-properties/logical-physical-map.js

@@ -69,38 +69,4 @@ export const logicalPhysicalMap = {
   insetInlineEnd: 'right',
   insetBlockStart: 'top',
   insetBlockEnd: 'bottom'
-};
-export const physicalLogicalMap = {
-  borderBottom: 'borderBlockEnd',
-  borderBottomColor: 'borderBlockEndColor',
-  borderBottomStyle: 'borderBlockEndStyle',
-  borderBottomWidth: 'borderBlockEndWidth',
-  borderTop: 'borderBlockStart',
-  borderTopColor: 'borderBlockStartColor',
-  borderTopStyle: 'borderBlockStartStyle',
-  borderTopWidth: 'borderBlockStartWidth',
-  borderRight: 'borderInlineEnd',
-  borderRightColor: 'borderInlineEndColor',
-  borderRightStyle: 'borderInlineEndStyle',
-  borderRightWidth: 'borderInlineEndWidth',
-  borderLeft: 'borderInlineStart',
-  borderLeftColor: 'borderInlineStartColor',
-  borderLeftStyle: 'borderInlineStartStyle',
-  borderLeftWidth: 'borderInlineStartWidth',
-  borderTopLeftRadius: 'borderStartStartRadius',
-  borderBottomLeftRadius: 'borderEndStartRadius',
-  borderTopRightRadius: 'borderStartEndRadius',
-  borderBottomRightRadius: 'borderEndEndRadius',
-  marginBottom: 'marginBlockEnd',
-  marginTop: 'marginBlockStart',
-  marginRight: 'marginInlineEnd',
-  marginLeft: 'marginInlineStart',
-  paddingBottom: 'paddingBlockEnd',
-  paddingTop: 'paddingBlockStart',
-  paddingRight: 'paddingInlineEnd',
-  paddingLeft: 'paddingInlineStart',
-  left: 'insetInlineStart',
-  right: 'insetInlineEnd',
-  top: 'insetBlockStart',
-  bottom: 'insetBlockEnd'
 };