@atlaskit/eslint-plugin-design-system 8.23.1 → 8.23.3

package/dist/types-ts4.5/ast-nodes/import.d.ts

@@ -0,0 +1,16 @@
+import type { Rule } from 'eslint';
+import { type ImportDeclaration } from 'eslint-codemod-utils';
+export declare const Import: {
+    /**
+     * Note: fixes can't overlap, which means this will fail:
+     * ```
+     * const importNode = Root.findImportByModule('@atlaskit/primitives')
+     * Import.insertNamedSpecifier(importNode, 'Box')
+     * Import.insertNamedSpecifier(importNode, 'xcss')
+     * ```
+     *
+     * For this reason `insertNamedSpecifiers` accepts a `specifiers` array, so you can group all inserts together.
+     */
+    insertNamedSpecifiers(node: ImportDeclaration, specifiers: string[], fixer: Rule.RuleFixer): Rule.Fix | undefined;
+    containsNamedSpecifier(node: ImportDeclaration, name: string): boolean;
+};

package/dist/types-ts4.5/ast-nodes/index.d.ts

@@ -0,0 +1,5 @@
+export { FunctionCall } from './function-call';
+export { Import } from './import';
+export { JSXAttribute } from './jsx-attribute';
+export { JSXElement } from './jsx-element';
+export { Root } from './root';

package/dist/types-ts4.5/ast-nodes/jsx-attribute.d.ts

@@ -0,0 +1,26 @@
+import type { Rule } from 'eslint';
+import { JSXAttribute } from 'eslint-codemod-utils';
+declare const HelperJSXAttribute: {
+    getName(node: JSXAttribute): string;
+    updateName(node: JSXAttribute, name: string, fixer: Rule.RuleFixer): Rule.Fix;
+    /**
+     * A JSXAttribute value can be many things:
+     * - css='myStyles'
+     * - css={myStyles}
+     * - css={[styles1, styles2]}
+     * - header={<></>}
+     * - css={styleMap.header}
+     * - css={...styles}
+     *
+     * Currently, `getValue` has only implemented strategies for when the value is a string, or an ExpressionStatement
+     * If you need additional functionality add it, and set the correct `type` on the returned object
+     */
+    getValue(node: JSXAttribute): {
+        type: 'ExpressionStatement';
+        value: string;
+    } | {
+        type: 'Literal';
+        value: string;
+    } | undefined;
+};
+export { HelperJSXAttribute as JSXAttribute };

package/dist/types-ts4.5/ast-nodes/jsx-element.d.ts

@@ -0,0 +1,21 @@
+import type { Rule } from 'eslint';
+import { JSXAttribute, JSXElement, JSXSpreadAttribute } from 'eslint-codemod-utils';
+export declare const JSXElementHelper: {
+    /**
+     * Names of JSXElements can be any of:
+     * `<Component></Component>` - (JSXIdentifier)
+     * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is a namespace (JSXNamespacedName)
+     * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is an object (JSXMemberExpression)
+     *
+     * Getting the name of a JSXMemberExpression is difficult, because object can contain objects, which is recursively defined in the AST.
+     * e.g. getting the name of `<MyComponents.PresentationLayer.LeftSideBar.Header />` would require `getName` to recursively resolve all parts of the name.
+     * `getName` does not currently have this functionality. Add it if you need it.
+     */
+    getName(node: JSXElement): string;
+    updateName(node: JSXElement, newName: string, fixer: Rule.RuleFixer): Rule.Fix[];
+    isSelfClosing(node: JSXElement): boolean;
+    getAttributes(node: JSXElement): (JSXAttribute | JSXSpreadAttribute)[];
+    getAttributeByName(node: JSXElement, name: string): JSXAttribute | undefined;
+    containsSpreadAttributes(node: JSXElement): boolean;
+};
+export { JSXElementHelper as JSXElement };

package/dist/types-ts4.5/ast-nodes/root.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import type { Rule } from 'eslint';
+import { Directive, ImportDeclaration, insertImportDeclaration, ModuleDeclaration, Statement } from 'eslint-codemod-utils';
+type ImportData = Parameters<typeof insertImportDeclaration>[1];
+export declare const Root: {
+    /**
+     * Note: This can return multiple ImportDeclarations for cases like:
+     * ```
+     * import { Stack } from '@atlaskit/primitives'
+     * import type { StackProps } from '@atlaskit/primitives'
+     * ```
+     */
+    findImportsByModule(root: (Directive | Statement | ModuleDeclaration)[], name: string): ImportDeclaration[];
+    insertImport(root: (Directive | Statement | ModuleDeclaration)[], data: {
+        module: string;
+        specifiers: ImportData;
+    }, fixer: Rule.RuleFixer): Rule.Fix;
+};
+export {};

package/dist/types-ts4.5/rules/use-primitives/transformers/compiled-styled/convert-jsx-call-site.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+/**
+ * Transforms a JSXElement from:
+ * ```
+ *   <div>
+ *     // ...
+ *   </div>
+ * ```
+ * to
+ * ```
+ *   <Box xcss={myStyles}>
+ *     // ...
+ *   </Box>
+ * ```
+ */
+export declare const convertJsxCallSite: (jsxElement: JSXElement, newStylesVariableName: string, fixer: Rule.RuleFixer) => Rule.Fix[];

package/dist/types-ts4.5/rules/use-primitives/transformers/compiled-styled/convert-styled-component-call-to-jsx.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from 'eslint';
+import { VariableDeclarator } from 'eslint-codemod-utils';
+/**
+ * Transforms a variable like:
+ * ```
+ * const MyComponent = styled.div({
+ *   padding: '8px',
+ * })
+ * ```
+ * to
+ * ```
+ * const myComponentStyles = xcss({
+ *   padding: 'space.100',
+ * })
+ * ```
+ */
+export declare const convertStyledComponentToXcss: (styles: VariableDeclarator, newStylesVariableName: string, fixer: Rule.RuleFixer) => (Rule.Fix | undefined)[];

package/dist/types-ts4.5/rules/use-primitives/transformers/compiled-styled/index.d.ts

@@ -0,0 +1,25 @@
+import type { Rule } from 'eslint';
+import { JSXElement, VariableDeclarator } from 'eslint-codemod-utils';
+import { RuleConfig } from '../../config';
+interface MetaData {
+    context: Rule.RuleContext;
+    config: RuleConfig;
+}
+interface Refs {
+    styles: VariableDeclarator;
+    jsxElement: JSXElement;
+}
+type Check = {
+    success: boolean;
+    refs?: Refs;
+};
+export declare const CompiledStyled: {
+    lint(node: Rule.Node, { context, config }: MetaData): void;
+    _check(node: Rule.Node, { context, config }: MetaData): Check;
+    /**
+     * All required validation steps have been taken care of before this
+     * transformer is called, so it just goes ahead providing all necessary fixes
+     */
+    _fix(refs: Refs, context: Rule.RuleContext): (fixer: Rule.RuleFixer) => Rule.Fix[];
+};
+export {};

package/dist/types-ts4.5/rules/use-primitives/transformers/compiled-styled/supported.d.ts

@@ -0,0 +1,2 @@
+export declare const elements: string[];
+export declare const attributes: string[];

package/dist/types-ts4.5/rules/use-primitives/transformers/compiled-styled/upsert-import-declaration.d.ts

@@ -0,0 +1,14 @@
+import type { Rule } from 'eslint';
+/**
+ * Currently this is defined here because it's not very general purpose.
+ * If we were to move this to `ast-nodes`, half the implementation would be in `Root`,
+ * and the other half would be in `Import`.
+ *
+ * TODO: Refactor and move to `ast-nodes`
+ *
+ * Note: It does not handle default imports, namespace imports, or aliased imports.
+ */
+export declare const upsertImportDeclaration: ({ module, specifiers, }: {
+    module: string;
+    specifiers: string[];
+}, context: Rule.RuleContext, fixer: Rule.RuleFixer) => Rule.Fix | undefined;

package/dist/types-ts4.5/rules/use-primitives/transformers/emotion-css/contains-only-supported-attrs.d.ts

@@ -0,0 +1,7 @@
+import { JSXElement } from 'eslint-codemod-utils';
+/**
+ * Check that every attribute in the JSXElement is something we support.
+ * We do this via a whitelist in `this.attributes`. The result is we exclude
+ * dangerous attrs like `id` and `style`.
+ */
+export declare const containsOnlySupportedAttrs: (node: JSXElement) => boolean;

package/dist/types-ts4.5/rules/use-primitives/transformers/emotion-css/index.d.ts

@@ -0,0 +1,16 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+import { RuleConfig } from '../../config';
+interface MetaData {
+    context: Rule.RuleContext;
+    config: RuleConfig;
+}
+type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+export declare const EmotionCSS: {
+    lint(node: Rule.Node, { context, config }: MetaData): void;
+    _check(node: Rule.Node, { context, config }: MetaData): boolean;
+    _fix(node: JSXElement, { context }: {
+        context: Rule.RuleContext;
+    }): FixFunction;
+};
+export {};

package/dist/types-ts4.5/rules/use-primitives/transformers/emotion-css/supported.d.ts

@@ -0,0 +1,2 @@
+export declare const elements: string[];
+export declare const attributes: string[];

package/dist/types-ts4.5/rules/use-primitives/transformers/emotion-css/upsert-import-declaration.d.ts

@@ -0,0 +1,14 @@
+import type { Rule } from 'eslint';
+/**
+ * Currently this is defined here because it's not very general purpose.
+ * If we were to move this to `ast-nodes`, half the implementation would be in `Root`,
+ * and the other half would be in `Import`.
+ *
+ * TODO: Refactor and move to `ast-nodes`
+ *
+ * Note: It does not handle default imports, namespace imports, or aliased imports.
+ */
+export declare const upsertImportDeclaration: ({ module, specifiers, }: {
+    module: string;
+    specifiers: string[];
+}, context: Rule.RuleContext, fixer: Rule.RuleFixer) => Rule.Fix | undefined;

package/dist/types-ts4.5/rules/use-primitives/transformers/index.d.ts

@@ -1,3 +1,3 @@
 export { cssToXcssTransformer, supportedStylesMap, spaceTokenMap, } from './css-to-xcss';
-export { jsxElementToBoxTransformer } from './jsx-element-to-box';
-export { styledComponentToPrimitive } from './styled-component-to-primitive';
+export { CompiledStyled } from './compiled-styled';
+export { EmotionCSS } from './emotion-css';

package/dist/types-ts4.5/rules/use-primitives/utils/index.d.ts

@@ -1,7 +1,4 @@
-export { containsOnlySupportedAttrs } from './contains-only-supported-attrs';
 export { convertASTObjectExpressionToJSObject } from './convert-ast-object-expression-to-js-object';
-export { findValidJsxUsageToTransform } from './find-valid-jsx-usage-to-transform';
-export { findValidStyledComponentCall } from './find-valid-styled-component-call';
 export { getAttributeValueIdentifier } from './get-attribute-value-identifier';
 export { getFunctionArgumentAtPos } from './get-function-argument-at-pos';
 export { getJSXAttributeByName } from './get-jsx-attribute-by-name';
@@ -9,7 +6,4 @@ export { getVariableDefinitionValue } from './get-variable-definition-value';
 export { getVariableUsagesCount } from './get-variable-usage-count';
 export { isFunctionNamed } from './is-function-named';
 export { isValidCssPropertiesToTransform } from './is-valid-css-properties-to-transform';
-export { isValidTagName } from './is-valid-tag-name';
 export { updateJSXAttributeByName } from './update-jsx-attribute-by-name';
-export { updateJSXElementName } from './update-jsx-element-name';
-export { upsertImportDeclaration } from './upsert-import-declaration';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaskit/eslint-plugin-design-system",
   "description": "The essential plugin for use with the Atlassian Design System.",
-  "version": "8.23.1",
+  "version": "8.23.3",
   "author": "Atlassian Pty Ltd",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"

package/dist/cjs/rules/use-primitives/transformers/jsx-element-to-box.js

@@ -1,26 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.jsxElementToBoxTransformer = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _utils = require("../utils");
-var _cssToXcss = require("./css-to-xcss");
-var jsxElementToBoxTransformer = exports.jsxElementToBoxTransformer = function jsxElementToBoxTransformer(node, context) {
-  return function (fixer) {
-    // Insert `import { Box, xcss } from '@atlaskit/primitives'`
-    // Or, if the import exists already, update it to include `Box`, and `xcss`
-    var importFixes = (0, _utils.upsertImportDeclaration)({
-      packageName: '@atlaskit/primitives',
-      specifiers: ['Box', 'xcss']
-    }, context, fixer);
-    var elementNameFixes = (0, _utils.updateJSXElementName)(node, 'Box', fixer);
-    var attributeFix = (0, _utils.updateJSXAttributeByName)('css', 'xcss', node, fixer);
-    var cssToXcssTransform = (0, _cssToXcss.cssToXcssTransformer)(node, context, fixer);
-    return [importFixes, attributeFix].concat((0, _toConsumableArray2.default)(elementNameFixes), (0, _toConsumableArray2.default)(cssToXcssTransform)).filter(function (fix) {
-      return Boolean(fix);
-    }); // Some of the transformers can return arrays with undefined, so filter them out
-  };
-};

package/dist/cjs/rules/use-primitives/transformers/styled-component-to-primitive.js

@@ -1,68 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.styledComponentToPrimitive = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _eslintCodemodUtils = require("eslint-codemod-utils");
-var _utils = require("../utils");
-var _cssToXcss = require("./css-to-xcss");
-/**
- * All required validation steps have been taken care of before this
- * transformer is called, so it just goes ahead providing all necessary fixes
- */
-var styledComponentToPrimitive = exports.styledComponentToPrimitive = function styledComponentToPrimitive(_ref, context) {
-  var stylesRef = _ref.stylesRef,
-    jsxRef = _ref.jsxRef;
-  return function (fixer) {
-    // generates the new variable name: MyComponent -> myComponentStyles
-    var calculatedStylesVariableName = (0, _eslintCodemodUtils.isNodeOfType)(stylesRef.id, 'Identifier') && "".concat(stylesRef.id.name.replace(stylesRef.id.name[0], stylesRef.id.name[0].toLowerCase()), "Styles");
-    if (!calculatedStylesVariableName) {
-      return [];
-    }
-    var importFixes = (0, _utils.upsertImportDeclaration)({
-      packageName: '@atlaskit/primitives',
-      specifiers: ['Box', 'xcss']
-    }, context, fixer);
-    var stylesFixes = convertStyledComponentToXcss(stylesRef, calculatedStylesVariableName, fixer);
-    var jsxFixes = convertJsxCallSite(jsxRef, calculatedStylesVariableName, fixer);
-    return [importFixes].concat(stylesFixes, jsxFixes).filter(function (fix) {
-      return Boolean(fix);
-    }); // Some of the transformers can return arrays with undefined, so filter them out
-  };
-};
-
-var convertStyledComponentToXcss = function convertStyledComponentToXcss(stylesRef, newStylesVariableName, fixer) {
-  var fixes = [];
-
-  // renames the variable from MyComponent to myComponentStyles
-  fixes.push(fixer.replaceText(stylesRef.id, newStylesVariableName));
-
-  // renames the function call from styled.<tag> to xcss
-  if (stylesRef.init && (0, _eslintCodemodUtils.isNodeOfType)(stylesRef.init, 'CallExpression')) {
-    fixes.push(fixer.replaceText(stylesRef.init.callee, 'xcss'));
-  }
-
-  // converts CSS values to XCSS-compatible tokens
-  if (stylesRef.init && (0, _eslintCodemodUtils.isNodeOfType)(stylesRef.init, 'CallExpression')) {
-    var objectExpression = stylesRef.init.arguments[0];
-    if ((0, _eslintCodemodUtils.isNodeOfType)(objectExpression, 'ObjectExpression')) {
-      fixes.push.apply(fixes, (0, _toConsumableArray2.default)((0, _cssToXcss.styledObjectToXcssTokens)(objectExpression, fixer)));
-    }
-  }
-  return fixes;
-};
-var convertJsxCallSite = function convertJsxCallSite(jsxRef, newStylesVariableName, fixer) {
-  var fixes = [];
-
-  // renames the JSX call site
-  if ((0, _eslintCodemodUtils.isNodeOfType)(jsxRef.parent, 'JSXElement')) {
-    fixes.push.apply(fixes, (0, _toConsumableArray2.default)((0, _utils.updateJSXElementName)(jsxRef.parent, 'Box', fixer)));
-  }
-
-  // adds xcss prop
-  fixes.push(fixer.insertTextAfter(jsxRef.name, " xcss={".concat(newStylesVariableName, "}")));
-  return fixes;
-};

package/dist/cjs/rules/use-primitives/utils/contains-only-supported-attrs.js

@@ -1,19 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.containsOnlySupportedAttrs = void 0;
-var _eslintCodemodUtils = require("eslint-codemod-utils");
-var supportedAttributes = ['css'];
-var containsOnlySupportedAttrs = exports.containsOnlySupportedAttrs = function containsOnlySupportedAttrs(node) {
-  return node.openingElement.attributes.every(function (attr) {
-    if (!(0, _eslintCodemodUtils.isNodeOfType)(attr, 'JSXAttribute')) {
-      return false;
-    }
-    if (!(0, _eslintCodemodUtils.isNodeOfType)(attr.name, 'JSXIdentifier')) {
-      return false;
-    }
-    return supportedAttributes.includes(attr.name.name);
-  });
-};

package/dist/cjs/rules/use-primitives/utils/is-valid-tag-name.js

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.validPrimitiveElements = exports.isValidTagName = void 0;
-var validPrimitiveElements = exports.validPrimitiveElements = new Set(['div']);
-var isValidTagName = exports.isValidTagName = function isValidTagName(node) {
-  if (node.openingElement.name.type !== 'JSXIdentifier') {
-    return false;
-  }
-  return validPrimitiveElements.has(node.openingElement.name.name);
-};

package/dist/cjs/rules/use-primitives/utils/update-jsx-element-name.js

@@ -1,16 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.updateJSXElementName = void 0;
-var _eslintCodemodUtils = require("eslint-codemod-utils");
-var updateJSXElementName = exports.updateJSXElementName = function updateJSXElementName(node, newName, fixer) {
-  var openingElement = node.openingElement,
-    closingElement = node.closingElement;
-  var newOpeningElement = fixer.replaceText(openingElement.name, (0, _eslintCodemodUtils.jsxIdentifier)(newName).toString());
-  var newClosingElement = closingElement &&
-  // Self closing tags, like `<div />` don't need to have the closing tag updated
-  fixer.replaceText(closingElement.name, (0, _eslintCodemodUtils.jsxIdentifier)(newName).toString());
-  return [newOpeningElement, newClosingElement || undefined];
-};

package/dist/cjs/rules/use-primitives/utils/upsert-import-declaration.js

@@ -1,80 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.upsertImportDeclaration = void 0;
-var _eslintCodemodUtils = require("eslint-codemod-utils");
-/**
- * Note: Very naive implementation. Does not handle default imports, namespace imports, or aliased imports.
- * Add that functionality when needed.
- *
- * However, does handle duplicate identifiers.
- */
-var upsertImportDeclaration = exports.upsertImportDeclaration = function upsertImportDeclaration(_ref, context, fixer) {
-  var packageName = _ref.packageName,
-    specifiers = _ref.specifiers;
-  // Find any imports that match the packageName
-  var body = context.getSourceCode().ast.body;
-  var existingImports = body.filter(function (node) {
-    if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'ImportDeclaration')) {
-      return false;
-    }
-    if (!(0, _eslintCodemodUtils.hasImportDeclaration)(node, packageName)) {
-      return false;
-    }
-    return true;
-  });
-
-  /**
-   * This can happen for cases like:
-   * ```
-   * import { Stack } from '@atlaskit/primitives'
-   * import type { StackProps } from '@atlaskit/primitives'
-   * ```
-   *
-   * Ignore these cases for now to reduce scope creep
-   *
-   * TODO: Support multiple imports
-   */
-  if (existingImports.length > 1) {
-    return;
-  }
-
-  // The import doesn't exist yet, we can just insert a whole new one
-  if (existingImports.length === 0) {
-    return fixer.insertTextBefore(body[0], "".concat((0, _eslintCodemodUtils.insertImportDeclaration)(packageName, specifiers), ";\n"));
-  }
-
-  // The import exists so, modify the existing one
-  var existingImport = existingImports[0]; // We have already validated that only one exists
-
-  /**
-   * `insertImportSpecifier()` has the unfortunate implementation detail of naively adding duplicate specifiers.
-   * e.g. calling
-   *  `insertImportSpecifier(importDecl, 'xcss')`
-   * on
-   * `import { Inline, xcss } from '@atlaskit/primitives'`
-   * will result in:
-   * `import { Inline, xcss, xcss } from '@atlaskit/primitives'`.
-   * So, we need to filter out specifiers that are already imported.
-   */
-  var uniqueImportSpecifiers = specifiers.filter(function (specifier) {
-    return !existingImport.specifiers.find(function (existingSpecifier) {
-      if (existingSpecifier.type !== 'ImportSpecifier') {
-        return false;
-      }
-      return existingSpecifier.imported.name === specifier;
-    });
-  });
-
-  // Ensures the import doesn't end up like: `import { Box, xcss,  } from '@atlaskit/primitives';`
-  // which can happen if the import decl already contains all import specifiers
-  if (uniqueImportSpecifiers.length === 0) {
-    return;
-  }
-  return fixer.replaceText(existingImport, "".concat((0, _eslintCodemodUtils.insertImportSpecifier)(existingImport,
-  // `insertImportSpecifier` only accepts one specifier, and we can't call it multiple times on the same import, because fixes can't overlap
-  // So, join the array into a string literal, and hope for the best 🤞
-  uniqueImportSpecifiers.join(', ')), ";\n"));
-};

package/dist/es2019/rules/use-primitives/transformers/jsx-element-to-box.js

@@ -1,16 +0,0 @@
-import { updateJSXAttributeByName, updateJSXElementName, upsertImportDeclaration } from '../utils';
-import { cssToXcssTransformer } from './css-to-xcss';
-export const jsxElementToBoxTransformer = (node, context) => {
-  return fixer => {
-    // Insert `import { Box, xcss } from '@atlaskit/primitives'`
-    // Or, if the import exists already, update it to include `Box`, and `xcss`
-    const importFixes = upsertImportDeclaration({
-      packageName: '@atlaskit/primitives',
-      specifiers: ['Box', 'xcss']
-    }, context, fixer);
-    const elementNameFixes = updateJSXElementName(node, 'Box', fixer);
-    const attributeFix = updateJSXAttributeByName('css', 'xcss', node, fixer);
-    const cssToXcssTransform = cssToXcssTransformer(node, context, fixer);
-    return [importFixes, attributeFix, ...elementNameFixes, ...cssToXcssTransform].filter(fix => Boolean(fix)); // Some of the transformers can return arrays with undefined, so filter them out
-  };
-};

package/dist/es2019/rules/use-primitives/transformers/styled-component-to-primitive.js

@@ -1,59 +0,0 @@
-import { isNodeOfType } from 'eslint-codemod-utils';
-import { updateJSXElementName, upsertImportDeclaration } from '../utils';
-import { styledObjectToXcssTokens } from './css-to-xcss';
-/**
- * All required validation steps have been taken care of before this
- * transformer is called, so it just goes ahead providing all necessary fixes
- */
-export const styledComponentToPrimitive = ({
-  stylesRef,
-  jsxRef
-}, context) => {
-  return fixer => {
-    // generates the new variable name: MyComponent -> myComponentStyles
-    const calculatedStylesVariableName = isNodeOfType(stylesRef.id, 'Identifier') && `${stylesRef.id.name.replace(stylesRef.id.name[0], stylesRef.id.name[0].toLowerCase())}Styles`;
-    if (!calculatedStylesVariableName) {
-      return [];
-    }
-    const importFixes = upsertImportDeclaration({
-      packageName: '@atlaskit/primitives',
-      specifiers: ['Box', 'xcss']
-    }, context, fixer);
-    const stylesFixes = convertStyledComponentToXcss(stylesRef, calculatedStylesVariableName, fixer);
-    const jsxFixes = convertJsxCallSite(jsxRef, calculatedStylesVariableName, fixer);
-    return [importFixes, ...stylesFixes, ...jsxFixes].filter(fix => Boolean(fix)); // Some of the transformers can return arrays with undefined, so filter them out
-  };
-};
-
-const convertStyledComponentToXcss = (stylesRef, newStylesVariableName, fixer) => {
-  const fixes = [];
-
-  // renames the variable from MyComponent to myComponentStyles
-  fixes.push(fixer.replaceText(stylesRef.id, newStylesVariableName));
-
-  // renames the function call from styled.<tag> to xcss
-  if (stylesRef.init && isNodeOfType(stylesRef.init, 'CallExpression')) {
-    fixes.push(fixer.replaceText(stylesRef.init.callee, 'xcss'));
-  }
-
-  // converts CSS values to XCSS-compatible tokens
-  if (stylesRef.init && isNodeOfType(stylesRef.init, 'CallExpression')) {
-    const objectExpression = stylesRef.init.arguments[0];
-    if (isNodeOfType(objectExpression, 'ObjectExpression')) {
-      fixes.push(...styledObjectToXcssTokens(objectExpression, fixer));
-    }
-  }
-  return fixes;
-};
-const convertJsxCallSite = (jsxRef, newStylesVariableName, fixer) => {
-  const fixes = [];
-
-  // renames the JSX call site
-  if (isNodeOfType(jsxRef.parent, 'JSXElement')) {
-    fixes.push(...updateJSXElementName(jsxRef.parent, 'Box', fixer));
-  }
-
-  // adds xcss prop
-  fixes.push(fixer.insertTextAfter(jsxRef.name, ` xcss={${newStylesVariableName}}`));
-  return fixes;
-};

package/dist/es2019/rules/use-primitives/utils/contains-only-supported-attrs.js

@@ -1,13 +0,0 @@
-import { isNodeOfType } from 'eslint-codemod-utils';
-const supportedAttributes = ['css'];
-export const containsOnlySupportedAttrs = node => {
-  return node.openingElement.attributes.every(attr => {
-    if (!isNodeOfType(attr, 'JSXAttribute')) {
-      return false;
-    }
-    if (!isNodeOfType(attr.name, 'JSXIdentifier')) {
-      return false;
-    }
-    return supportedAttributes.includes(attr.name.name);
-  });
-};

package/dist/es2019/rules/use-primitives/utils/is-valid-tag-name.js

@@ -1,7 +0,0 @@
-export const validPrimitiveElements = new Set(['div']);
-export const isValidTagName = node => {
-  if (node.openingElement.name.type !== 'JSXIdentifier') {
-    return false;
-  }
-  return validPrimitiveElements.has(node.openingElement.name.name);
-};

package/dist/es2019/rules/use-primitives/utils/update-jsx-element-name.js

@@ -1,12 +0,0 @@
-import { jsxIdentifier } from 'eslint-codemod-utils';
-export const updateJSXElementName = (node, newName, fixer) => {
-  const {
-    openingElement,
-    closingElement
-  } = node;
-  const newOpeningElement = fixer.replaceText(openingElement.name, jsxIdentifier(newName).toString());
-  const newClosingElement = closingElement &&
-  // Self closing tags, like `<div />` don't need to have the closing tag updated
-  fixer.replaceText(closingElement.name, jsxIdentifier(newName).toString());
-  return [newOpeningElement, newClosingElement || undefined];
-};