@atlaskit/eslint-plugin-design-system 8.15.5 → 8.16.0

package/dist/esm/rules/use-primitives/utils/get-variable-usage-count.js

@@ -0,0 +1,15 @@
+/**
+ * Using Regex here because otherwise we'd need to traverse the entire AST
+ * We should harden this logic as we go.
+ */
+export var getVariableUsagesCount = function getVariableUsagesCount(variableName, context) {
+  if (!variableName) {
+    return 0;
+  }
+  var source = context.getSourceCode().text;
+  var matches = Array.from(source.matchAll(new RegExp("[^a-z]".concat(variableName, "[^a-z]"), 'g')));
+
+  // subtract 1 because one of the matches is the variable definition:
+  // e.g. a regex will find two `beep`s in this: `const beep = 'hello'; console.log(beep)`
+  return matches.length - 1;
+};

package/dist/esm/rules/use-primitives/utils/index.js

@@ -0,0 +1,12 @@
+export { containsOnlySupportedAttrs } from './contains-only-supported-attrs';
+export { convertASTObjectExpressionToJSObject } from './convert-ast-object-expression-to-js-object';
+export { getAttributeValueIdentifier } from './get-attribute-value-identifier';
+export { getFunctionArgumentAtPos } from './get-function-argument-at-pos';
+export { getJSXAttributeByName } from './get-jsx-attribute-by-name';
+export { getVariableDefinitionValue } from './get-variable-definition-value';
+export { getVariableUsagesCount } from './get-variable-usage-count';
+export { isFunctionNamed } from './is-function-named';
+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/dist/esm/rules/use-primitives/utils/is-function-named.js

@@ -0,0 +1,13 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export var isFunctionNamed = function isFunctionNamed(node, name) {
+  if (!node) {
+    return false;
+  }
+  if (!isNodeOfType(node.node.init, 'CallExpression')) {
+    return false;
+  }
+  if (!isNodeOfType(node.node.init.callee, 'Identifier')) {
+    return false;
+  }
+  return node.node.init.callee.name === name;
+};

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

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

package/dist/esm/rules/use-primitives/utils/update-jsx-attribute-by-name.js

@@ -0,0 +1,24 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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 { jsxAttribute, jsxIdentifier } from 'eslint-codemod-utils';
+export var updateJSXAttributeByName = function updateJSXAttributeByName(oldName, newName, node, fixer) {
+  var openingElement = node.openingElement;
+  var attributes = openingElement.attributes;
+  var existingAttribute = attributes.find(function (attr) {
+    if (attr.type !== 'JSXAttribute') {
+      return false;
+    }
+    if (attr.name.type !== 'JSXIdentifier') {
+      return false;
+    }
+    return attr.name.name === oldName;
+  });
+  if (!existingAttribute || existingAttribute.type !== 'JSXAttribute') {
+    return [];
+  }
+  var newAttribute = jsxAttribute(_objectSpread(_objectSpread({}, existingAttribute), {}, {
+    name: jsxIdentifier(newName)
+  }));
+  return fixer.replaceText(existingAttribute, newAttribute.toString());
+};

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

@@ -0,0 +1,10 @@
+import { jsxIdentifier } from 'eslint-codemod-utils';
+export var updateJSXElementName = function updateJSXElementName(node, newName, fixer) {
+  var openingElement = node.openingElement,
+    closingElement = node.closingElement;
+  var newOpeningElement = fixer.replaceText(openingElement.name, jsxIdentifier(newName).toString());
+  var 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];
+};

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

@@ -0,0 +1,75 @@
+import { hasImportDeclaration, insertImportDeclaration, insertImportSpecifier, isNodeOfType } from '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.
+ */
+export var 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 (!isNodeOfType(node, 'ImportDeclaration')) {
+      return false;
+    }
+    if (!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(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(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/types/rules/prefer-primitives/utils.d.ts

@@ -1,2 +1,3 @@
-import type { JSXElement } from 'eslint-codemod-utils';
+import { type JSXElement } from 'eslint-codemod-utils';
+export declare const validPrimitiveElements: Set<string>;
 export declare const shouldSuggest: (node: JSXElement) => boolean;

package/dist/types/rules/use-primitives/transformers/css-to-xcss.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const cssToXcssTransformer: (node: JSXElement, context: Rule.RuleContext, fixer: Rule.RuleFixer) => (Rule.Fix | undefined)[];
+export declare const spaceTokenMap: {
+    [key: string]: string;
+};
+export declare const supportedStylesMap: {
+    [key: string]: typeof spaceTokenMap;
+};

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

@@ -0,0 +1,2 @@
+export { cssToXcssTransformer, supportedStylesMap, spaceTokenMap, } from './css-to-xcss';
+export { jsxElementToBoxTransformer } from './jsx-element-to-box';

package/dist/types/rules/use-primitives/transformers/jsx-element-to-box.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const jsxElementToBoxTransformer: (node: JSXElement, context: Rule.RuleContext) => (fixer: Rule.RuleFixer) => Rule.Fix[];

package/dist/types/rules/use-primitives/utils/contains-only-supported-attrs.d.ts

@@ -0,0 +1,2 @@
+import { type JSXElement } from 'eslint-codemod-utils';
+export declare const containsOnlySupportedAttrs: (node: JSXElement) => boolean;

package/dist/types/rules/use-primitives/utils/convert-ast-object-expression-to-js-object.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from 'eslint';
+import { ObjectExpression } from 'eslint-codemod-utils';
+export type CSSPropStyleObject = {
+    [key: string]: string | number;
+};
+/**
+ * Note: Not recursive. Only handles top level key/value pairs
+ */
+export declare const convertASTObjectExpressionToJSObject: (styles: ObjectExpression & Partial<Rule.NodeParentExtension>) => CSSPropStyleObject;

package/dist/types/rules/use-primitives/utils/get-attribute-value-identifier.d.ts

@@ -0,0 +1,14 @@
+import { JSXAttribute } from 'eslint-codemod-utils';
+/**
+ * Bit of a weird name, but the functionality is quite specific, so this is the best I could do.
+ * This function looks at a JSXAttribute, and returns the string representation
+ * of the value if it's an identifier, e.g. `css={someStyles}` would return `'someStyles'`
+ *
+ * It returns undefined if it finds anything else, like:
+ * - `css={[styles1, styles2]}`
+ * - `css={...styles}`
+ * - `css={styleMap[key]}`
+ * - `css='what even is this'`
+ * - etc
+ */
+export declare const getAttributeValueIdentifier: (attr: JSXAttribute | undefined) => string | undefined;

package/dist/types/rules/use-primitives/utils/get-function-argument-at-pos.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from 'eslint';
+export declare const getFunctionArgumentAtPos: (node: Scope.Definition | undefined, pos: number) => any;

package/dist/types/rules/use-primitives/utils/get-jsx-attribute-by-name.d.ts

@@ -0,0 +1,2 @@
+import { JSXAttribute, JSXOpeningElement } from 'eslint-codemod-utils';
+export declare const getJSXAttributeByName: (node: JSXOpeningElement, attrName: string) => JSXAttribute | undefined;

package/dist/types/rules/use-primitives/utils/get-variable-definition-value.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from 'eslint';
+export declare const getVariableDefinitionValue: (variableDefinition: Scope.Variable | null) => Scope.Definition | undefined;

package/dist/types/rules/use-primitives/utils/get-variable-usage-count.d.ts

@@ -0,0 +1,6 @@
+import type { Rule } from 'eslint';
+/**
+ * Using Regex here because otherwise we'd need to traverse the entire AST
+ * We should harden this logic as we go.
+ */
+export declare const getVariableUsagesCount: (variableName: string | undefined, context: Rule.RuleContext) => number;

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

@@ -0,0 +1,12 @@
+export { containsOnlySupportedAttrs } from './contains-only-supported-attrs';
+export { convertASTObjectExpressionToJSObject } from './convert-ast-object-expression-to-js-object';
+export { getAttributeValueIdentifier } from './get-attribute-value-identifier';
+export { getFunctionArgumentAtPos } from './get-function-argument-at-pos';
+export { getJSXAttributeByName } from './get-jsx-attribute-by-name';
+export { getVariableDefinitionValue } from './get-variable-definition-value';
+export { getVariableUsagesCount } from './get-variable-usage-count';
+export { isFunctionNamed } from './is-function-named';
+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/dist/types/rules/use-primitives/utils/is-function-named.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from 'eslint';
+export declare const isFunctionNamed: (node: Scope.Definition | undefined, name: string) => boolean;

package/dist/types/rules/use-primitives/utils/is-valid-tag-name.d.ts

@@ -0,0 +1,2 @@
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const isValidTagName: (node: JSXElement) => boolean;

package/dist/types/rules/use-primitives/utils/update-jsx-attribute-by-name.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const updateJSXAttributeByName: (oldName: string, newName: string, node: JSXElement, fixer: Rule.RuleFixer) => never[] | Rule.Fix;

package/dist/types/rules/use-primitives/utils/update-jsx-element-name.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const updateJSXElementName: (node: JSXElement, newName: string, fixer: Rule.RuleFixer) => (Rule.Fix | null)[];

package/dist/types/rules/use-primitives/utils/upsert-import-declaration.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from 'eslint';
+/**
+ * Note: Very naive implementation. Does not handle default imports, namespace imports, or aliased imports.
+ * Add that functionality when needed.
+ *
+ * However, does handle duplicate identifiers.
+ */
+export declare const upsertImportDeclaration: ({ packageName, specifiers, }: {
+    packageName: string;
+    specifiers: string[];
+}, context: Rule.RuleContext, fixer: Rule.RuleFixer) => Rule.Fix | undefined;

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

@@ -1,2 +1,3 @@
-import type { JSXElement } from 'eslint-codemod-utils';
+import { type JSXElement } from 'eslint-codemod-utils';
+export declare const validPrimitiveElements: Set<string>;
 export declare const shouldSuggest: (node: JSXElement) => boolean;

package/dist/types-ts4.5/rules/use-primitives/transformers/css-to-xcss.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const cssToXcssTransformer: (node: JSXElement, context: Rule.RuleContext, fixer: Rule.RuleFixer) => (Rule.Fix | undefined)[];
+export declare const spaceTokenMap: {
+    [key: string]: string;
+};
+export declare const supportedStylesMap: {
+    [key: string]: typeof spaceTokenMap;
+};

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

@@ -0,0 +1,2 @@
+export { cssToXcssTransformer, supportedStylesMap, spaceTokenMap, } from './css-to-xcss';
+export { jsxElementToBoxTransformer } from './jsx-element-to-box';

package/dist/types-ts4.5/rules/use-primitives/transformers/jsx-element-to-box.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const jsxElementToBoxTransformer: (node: JSXElement, context: Rule.RuleContext) => (fixer: Rule.RuleFixer) => Rule.Fix[];

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

@@ -0,0 +1,2 @@
+import { type JSXElement } from 'eslint-codemod-utils';
+export declare const containsOnlySupportedAttrs: (node: JSXElement) => boolean;

package/dist/types-ts4.5/rules/use-primitives/utils/convert-ast-object-expression-to-js-object.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from 'eslint';
+import { ObjectExpression } from 'eslint-codemod-utils';
+export type CSSPropStyleObject = {
+    [key: string]: string | number;
+};
+/**
+ * Note: Not recursive. Only handles top level key/value pairs
+ */
+export declare const convertASTObjectExpressionToJSObject: (styles: ObjectExpression & Partial<Rule.NodeParentExtension>) => CSSPropStyleObject;

package/dist/types-ts4.5/rules/use-primitives/utils/get-attribute-value-identifier.d.ts

@@ -0,0 +1,14 @@
+import { JSXAttribute } from 'eslint-codemod-utils';
+/**
+ * Bit of a weird name, but the functionality is quite specific, so this is the best I could do.
+ * This function looks at a JSXAttribute, and returns the string representation
+ * of the value if it's an identifier, e.g. `css={someStyles}` would return `'someStyles'`
+ *
+ * It returns undefined if it finds anything else, like:
+ * - `css={[styles1, styles2]}`
+ * - `css={...styles}`
+ * - `css={styleMap[key]}`
+ * - `css='what even is this'`
+ * - etc
+ */
+export declare const getAttributeValueIdentifier: (attr: JSXAttribute | undefined) => string | undefined;

package/dist/types-ts4.5/rules/use-primitives/utils/get-function-argument-at-pos.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from 'eslint';
+export declare const getFunctionArgumentAtPos: (node: Scope.Definition | undefined, pos: number) => any;

package/dist/types-ts4.5/rules/use-primitives/utils/get-jsx-attribute-by-name.d.ts

@@ -0,0 +1,2 @@
+import { JSXAttribute, JSXOpeningElement } from 'eslint-codemod-utils';
+export declare const getJSXAttributeByName: (node: JSXOpeningElement, attrName: string) => JSXAttribute | undefined;

package/dist/types-ts4.5/rules/use-primitives/utils/get-variable-definition-value.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from 'eslint';
+export declare const getVariableDefinitionValue: (variableDefinition: Scope.Variable | null) => Scope.Definition | undefined;

package/dist/types-ts4.5/rules/use-primitives/utils/get-variable-usage-count.d.ts

@@ -0,0 +1,6 @@
+import type { Rule } from 'eslint';
+/**
+ * Using Regex here because otherwise we'd need to traverse the entire AST
+ * We should harden this logic as we go.
+ */
+export declare const getVariableUsagesCount: (variableName: string | undefined, context: Rule.RuleContext) => number;

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

@@ -0,0 +1,12 @@
+export { containsOnlySupportedAttrs } from './contains-only-supported-attrs';
+export { convertASTObjectExpressionToJSObject } from './convert-ast-object-expression-to-js-object';
+export { getAttributeValueIdentifier } from './get-attribute-value-identifier';
+export { getFunctionArgumentAtPos } from './get-function-argument-at-pos';
+export { getJSXAttributeByName } from './get-jsx-attribute-by-name';
+export { getVariableDefinitionValue } from './get-variable-definition-value';
+export { getVariableUsagesCount } from './get-variable-usage-count';
+export { isFunctionNamed } from './is-function-named';
+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/dist/types-ts4.5/rules/use-primitives/utils/is-function-named.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from 'eslint';
+export declare const isFunctionNamed: (node: Scope.Definition | undefined, name: string) => boolean;

package/dist/types-ts4.5/rules/use-primitives/utils/is-valid-tag-name.d.ts

@@ -0,0 +1,2 @@
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const isValidTagName: (node: JSXElement) => boolean;

package/dist/types-ts4.5/rules/use-primitives/utils/update-jsx-attribute-by-name.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const updateJSXAttributeByName: (oldName: string, newName: string, node: JSXElement, fixer: Rule.RuleFixer) => never[] | Rule.Fix;

package/dist/types-ts4.5/rules/use-primitives/utils/update-jsx-element-name.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { JSXElement } from 'eslint-codemod-utils';
+export declare const updateJSXElementName: (node: JSXElement, newName: string, fixer: Rule.RuleFixer) => (Rule.Fix | null)[];

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

@@ -0,0 +1,11 @@
+import type { Rule } from 'eslint';
+/**
+ * Note: Very naive implementation. Does not handle default imports, namespace imports, or aliased imports.
+ * Add that functionality when needed.
+ *
+ * However, does handle duplicate identifiers.
+ */
+export declare const upsertImportDeclaration: ({ packageName, specifiers, }: {
+    packageName: string;
+    specifiers: string[];
+}, context: Rule.RuleContext, fixer: Rule.RuleFixer) => Rule.Fix | undefined;

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.15.5",
+  "version": "8.16.0",
   "author": "Atlassian Pty Ltd",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -54,8 +54,10 @@
     "@emotion/styled": "^11.0.0",
     "@types/eslint": "^8.4.5",
     "eslint": "^7.7.0",
+    "jscodeshift": "^0.13.0",
     "prettier": "^2.8.0",
     "react": "^16.8.0",
+    "ts-jest": "26.5.6",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",
     "typescript": "~4.9.5"