@atlaskit/select 17.10.2 → 17.10.4

package/codemods/utils/helpers.ts

@@ -1,261 +1,256 @@
 import { type NodePath } from 'ast-types/lib/node-path';
 import {
-  type default as core,
-  type ASTPath,
-  type ImportDeclaration,
-  type JSXAttribute,
-  type JSXElement,
-  type Node,
+	type default as core,
+	type ASTPath,
+	type ImportDeclaration,
+	type JSXAttribute,
+	type JSXElement,
+	type Node,
 } from 'jscodeshift';
 import { type Collection } from 'jscodeshift/src/Collection';
 
 export type Nullable<T> = T | null;
 
 export function hasImportDeclaration(
-  j: core.JSCodeshift,
-  source: string,
-  importPath: string,
+	j: core.JSCodeshift,
+	source: string,
+	importPath: string,
 ): boolean {
-  return (
-    j(source)
-      .find(j.ImportDeclaration)
-      .filter(
-        (path: ASTPath<ImportDeclaration>) =>
-          path.node.source.value === importPath,
-      ).length > 0
-  );
+	return (
+		j(source)
+			.find(j.ImportDeclaration)
+			.filter((path: ASTPath<ImportDeclaration>) => path.node.source.value === importPath).length >
+		0
+	);
 }
 
 export function getDefaultSpecifierName({
-  j,
-  base,
-  packageName,
+	j,
+	base,
+	packageName,
 }: {
-  j: core.JSCodeshift;
-  base: Collection<any>;
-  packageName: string;
+	j: core.JSCodeshift;
+	base: Collection<any>;
+	packageName: string;
 }): Nullable<string> {
-  const specifiers = base
-    .find(j.ImportDeclaration)
-    .filter((path) => path.node.source.value === packageName)
-    .find(j.ImportDefaultSpecifier);
+	const specifiers = base
+		.find(j.ImportDeclaration)
+		.filter((path) => path.node.source.value === packageName)
+		.find(j.ImportDefaultSpecifier);
 
-  if (!specifiers.length) {
-    return null;
-  }
-  return specifiers.nodes()[0]!.local!.name;
+	if (!specifiers.length) {
+		return null;
+	}
+	return specifiers.nodes()[0]!.local!.name;
 }
 
 export function getSpecifierName({
-  j,
-  base,
-  packageName,
-  component,
+	j,
+	base,
+	packageName,
+	component,
 }: {
-  j: core.JSCodeshift;
-  base: Collection<any>;
-  packageName: string;
-  component: string;
+	j: core.JSCodeshift;
+	base: Collection<any>;
+	packageName: string;
+	component: string;
 }): Nullable<string> {
-  const specifiers = base
-    .find(j.ImportDeclaration)
-    .filter((path) => path.node.source.value === packageName)
-    .find(j.ImportSpecifier);
+	const specifiers = base
+		.find(j.ImportDeclaration)
+		.filter((path) => path.node.source.value === packageName)
+		.find(j.ImportSpecifier);
 
-  if (!specifiers.length) {
-    return null;
-  }
-  const specifierNode = specifiers
-    .nodes()
-    .find((node) => node.imported.name === component);
-  if (!specifierNode) {
-    return null;
-  }
-  // @ts-ignore
-  return specifierNode.local.name;
+	if (!specifiers.length) {
+		return null;
+	}
+	const specifierNode = specifiers.nodes().find((node) => node.imported.name === component);
+	if (!specifierNode) {
+		return null;
+	}
+	// @ts-ignore
+	return specifierNode.local.name;
 }
 
 export function getJSXAttributesByName({
-  j,
-  element,
-  attributeName,
+	j,
+	element,
+	attributeName,
 }: {
-  j: core.JSCodeshift;
-  element: JSXElement | ASTPath<JSXElement>;
-  attributeName: string;
+	j: core.JSCodeshift;
+	element: JSXElement | ASTPath<JSXElement>;
+	attributeName: string;
 }): Collection<JSXAttribute> {
-  return j(element)
-    .find(j.JSXOpeningElement)
-    .find(j.JSXAttribute)
-    .filter((attribute) => {
-      const matches = j(attribute)
-        .find(j.JSXIdentifier)
-        .filter((identifier) => identifier.value.name === attributeName);
-      return Boolean(matches.length);
-    });
+	return j(element)
+		.find(j.JSXOpeningElement)
+		.find(j.JSXAttribute)
+		.filter((attribute) => {
+			const matches = j(attribute)
+				.find(j.JSXIdentifier)
+				.filter((identifier) => identifier.value.name === attributeName);
+			return Boolean(matches.length);
+		});
 }
 
 export function hasJSXAttributesByName({
-  j,
-  element,
-  attributeName,
+	j,
+	element,
+	attributeName,
 }: {
-  j: core.JSCodeshift;
-  element: JSXElement;
-  attributeName: string;
+	j: core.JSCodeshift;
+	element: JSXElement;
+	attributeName: string;
 }): boolean {
-  return getJSXAttributesByName({ j, element, attributeName }).length > 0;
+	return getJSXAttributesByName({ j, element, attributeName }).length > 0;
 }
 
 export function isUsingSupportedSpread({
-  j,
-  base,
-  element,
+	j,
+	base,
+	element,
 }: {
-  j: core.JSCodeshift;
-  base: Collection<any>;
-  element: NodePath<JSXElement, JSXElement>;
+	j: core.JSCodeshift;
+	base: Collection<any>;
+	element: NodePath<JSXElement, JSXElement>;
 }): boolean {
-  const isUsingSpread: boolean =
-    j(element).find(j.JSXSpreadAttribute).length > 0;
+	const isUsingSpread: boolean = j(element).find(j.JSXSpreadAttribute).length > 0;
 
-  if (!isUsingSpread) {
-    return true;
-  }
+	if (!isUsingSpread) {
+		return true;
+	}
 
-  return (
-    j(element)
-      .find(j.JSXSpreadAttribute)
-      .filter((spread) => {
-        const argument = spread.value.argument;
-        // in place expression is supported
-        if (argument.type === 'ObjectExpression') {
-          return true;
-        }
+	return (
+		j(element)
+			.find(j.JSXSpreadAttribute)
+			.filter((spread) => {
+				const argument = spread.value.argument;
+				// in place expression is supported
+				if (argument.type === 'ObjectExpression') {
+					return true;
+				}
 
-        // Supporting identifiers that point to an a local object expression
-        if (argument.type === 'Identifier') {
-          return (
-            base.find(j.VariableDeclarator).filter((declarator): boolean => {
-              return (
-                declarator.value.id.type === 'Identifier' &&
-                // @ts-ignore
-                declarator.value.init.type === 'ObjectExpression'
-              );
-            }).length > 0
-          );
-        }
+				// Supporting identifiers that point to an a local object expression
+				if (argument.type === 'Identifier') {
+					return (
+						base.find(j.VariableDeclarator).filter((declarator): boolean => {
+							return (
+								declarator.value.id.type === 'Identifier' &&
+								// @ts-ignore
+								declarator.value.init.type === 'ObjectExpression'
+							);
+						}).length > 0
+					);
+				}
 
-        // We don't support anything else
-        return false;
-      }).length > 0
-  );
+				// We don't support anything else
+				return false;
+			}).length > 0
+	);
 }
 
 export function isUsingThroughSpread({
-  j,
-  base,
-  element,
-  propName,
+	j,
+	base,
+	element,
+	propName,
 }: {
-  j: core.JSCodeshift;
-  base: Collection<any>;
-  element: NodePath<JSXElement, JSXElement>;
-  propName: string;
+	j: core.JSCodeshift;
+	base: Collection<any>;
+	element: NodePath<JSXElement, JSXElement>;
+	propName: string;
 }): boolean {
-  if (!isUsingSupportedSpread({ j, base, element })) {
-    return false;
-  }
+	if (!isUsingSupportedSpread({ j, base, element })) {
+		return false;
+	}
 
-  const isUsedThroughExpression: boolean =
-    j(element)
-      .find(j.JSXSpreadAttribute)
-      .find(j.ObjectExpression)
-      .filter((item) => {
-        const match: boolean =
-          item.value.properties.filter(
-            (property) =>
-              property.type === 'ObjectProperty' &&
-              property.key.type === 'Identifier' &&
-              property.key.name === propName,
-          ).length > 0;
+	const isUsedThroughExpression: boolean =
+		j(element)
+			.find(j.JSXSpreadAttribute)
+			.find(j.ObjectExpression)
+			.filter((item) => {
+				const match: boolean =
+					item.value.properties.filter(
+						(property) =>
+							property.type === 'ObjectProperty' &&
+							property.key.type === 'Identifier' &&
+							property.key.name === propName,
+					).length > 0;
 
-        return match;
-      }).length > 0;
+				return match;
+			}).length > 0;
 
-  if (isUsedThroughExpression) {
-    return true;
-  }
+	if (isUsedThroughExpression) {
+		return true;
+	}
 
-  const isUsedThroughIdentifier: boolean =
-    j(element)
-      .find(j.JSXSpreadAttribute)
-      .find(j.Identifier)
-      .filter((identifier): boolean => {
-        return (
-          base
-            .find(j.VariableDeclarator)
-            .filter(
-              (declarator) =>
-                declarator.value.id.type === 'Identifier' &&
-                declarator.value.id.name === identifier.value.name,
-            )
-            .filter((declarator) => {
-              const value = declarator.value;
-              if (value.id.type !== 'Identifier') {
-                return false;
-              }
+	const isUsedThroughIdentifier: boolean =
+		j(element)
+			.find(j.JSXSpreadAttribute)
+			.find(j.Identifier)
+			.filter((identifier): boolean => {
+				return (
+					base
+						.find(j.VariableDeclarator)
+						.filter(
+							(declarator) =>
+								declarator.value.id.type === 'Identifier' &&
+								declarator.value.id.name === identifier.value.name,
+						)
+						.filter((declarator) => {
+							const value = declarator.value;
+							if (value.id.type !== 'Identifier') {
+								return false;
+							}
 
-              if (value.id.name !== identifier.value.name) {
-                return false;
-              }
-              // @ts-ignore
-              if (value.init.type !== 'ObjectExpression') {
-                return false;
-              }
+							if (value.id.name !== identifier.value.name) {
+								return false;
+							}
+							// @ts-ignore
+							if (value.init.type !== 'ObjectExpression') {
+								return false;
+							}
 
-              const match: boolean =
-                // @ts-ignore
-                value.init.properties.filter(
-                  // @ts-ignore
-                  (property) =>
-                    property.type === 'ObjectProperty' &&
-                    property.key.type === 'Identifier' &&
-                    property.key.name === propName,
-                ).length > 0;
+							const match: boolean =
+								// @ts-ignore
+								value.init.properties.filter(
+									// @ts-ignore
+									(property) =>
+										property.type === 'ObjectProperty' &&
+										property.key.type === 'Identifier' &&
+										property.key.name === propName,
+								).length > 0;
 
-              return match;
-            }).length > 0
-        );
-      }).length > 0;
+							return match;
+						}).length > 0
+				);
+			}).length > 0;
 
-  return isUsedThroughIdentifier;
+	return isUsedThroughIdentifier;
 }
 
 export function isUsingProp({
-  j,
-  base,
-  element,
-  propName,
+	j,
+	base,
+	element,
+	propName,
 }: {
-  j: core.JSCodeshift;
-  base: Collection<any>;
-  element: NodePath<JSXElement, JSXElement>;
-  propName: string;
+	j: core.JSCodeshift;
+	base: Collection<any>;
+	element: NodePath<JSXElement, JSXElement>;
+	propName: string;
 }): boolean {
-  return (
-    hasJSXAttributesByName({
-      j,
-      element: element.value,
-      attributeName: propName,
-    }) ||
-    isUsingThroughSpread({
-      j,
-      base,
-      element,
-      propName,
-    })
-  );
+	return (
+		hasJSXAttributesByName({
+			j,
+			element: element.value,
+			attributeName: propName,
+		}) ||
+		isUsingThroughSpread({
+			j,
+			base,
+			element,
+			propName,
+		})
+	);
 }
 
 // not replacing newlines (which \s does)
@@ -263,82 +258,76 @@ const spacesAndTabs: RegExp = /[ \t]{2,}/g;
 const lineStartWithSpaces: RegExp = /^[ \t]*/gm;
 
 function clean(value: string): string {
-  return (
-    value
-      .replace(spacesAndTabs, ' ')
-      .replace(lineStartWithSpaces, '')
-      // using .trim() to clear the any newlines before the first text and after last text
-      .trim()
-  );
+	return (
+		value
+			.replace(spacesAndTabs, ' ')
+			.replace(lineStartWithSpaces, '')
+			// using .trim() to clear the any newlines before the first text and after last text
+			.trim()
+	);
 }
 
 export function addCommentToStartOfFile({
-  j,
-  base,
-  message,
+	j,
+	base,
+	message,
 }: {
-  j: core.JSCodeshift;
-  base: Collection<Node>;
-  message: string;
+	j: core.JSCodeshift;
+	base: Collection<Node>;
+	message: string;
 }) {
-  addCommentBefore({
-    j,
-    // @ts-ignore
-    target: base.find(j.Program),
-    message,
-  });
+	addCommentBefore({
+		j,
+		// @ts-ignore
+		target: base.find(j.Program),
+		message,
+	});
 }
 
 export function addCommentBefore({
-  j,
-  target,
-  message,
+	j,
+	target,
+	message,
 }: {
-  j: core.JSCodeshift;
-  target: Collection<Node>;
-  message: string;
+	j: core.JSCodeshift;
+	target: Collection<Node>;
+	message: string;
 }) {
-  const content: string = ` TODO: (from codemod) ${clean(message)} `;
-  target.forEach((path) => {
-    path.value.comments = path.value.comments || [];
+	const content: string = ` TODO: (from codemod) ${clean(message)} `;
+	target.forEach((path) => {
+		path.value.comments = path.value.comments || [];
 
-    const exists = path.value.comments.find(
-      (comment) => comment.value === content,
-    );
+		const exists = path.value.comments.find((comment) => comment.value === content);
 
-    // avoiding duplicates of the same comment
-    if (exists) {
-      return;
-    }
+		// avoiding duplicates of the same comment
+		if (exists) {
+			return;
+		}
 
-    path.value.comments.push(j.commentBlock(content));
-  });
+		path.value.comments.push(j.commentBlock(content));
+	});
 }
 
 export function updateRenderProps(
-  j: core.JSCodeshift,
-  source: Collection<any>,
-  specifier: string,
-  oldProperty: string,
-  newProperty: string,
+	j: core.JSCodeshift,
+	source: Collection<any>,
+	specifier: string,
+	oldProperty: string,
+	newProperty: string,
 ) {
-  source.findJSXElements(specifier).forEach((element: ASTPath<JSXElement>) => {
-    j(element)
-      .find(j.ArrowFunctionExpression)
-      .find(j.ObjectPattern)
-      .find(j.ObjectProperty)
-      .filter(
-        // @ts-ignore
-        (path: ASTPath<ObjectProperty>) => path.value.key.name === oldProperty,
-      )
-      .forEach((path) => {
-        j(path).replaceWith(
-          j.property(
-            'init',
-            j.identifier(newProperty),
-            j.identifier(oldProperty),
-          ),
-        );
-      });
-  });
+	source.findJSXElements(specifier).forEach((element: ASTPath<JSXElement>) => {
+		j(element)
+			.find(j.ArrowFunctionExpression)
+			.find(j.ObjectPattern)
+			.find(j.ObjectProperty)
+			.filter(
+				// @ts-ignore
+				(path: ASTPath<ObjectProperty>) => path.value.key.name === oldProperty,
+			)
+			.forEach((path) => {
+				j(path).replaceWith(
+					j.property('init', j.identifier(newProperty), j.identifier(oldProperty)),
+				);
+			});
+	});
 }

package/dist/cjs/CountrySelect.js

@@ -11,6 +11,8 @@ var _countries = require("./data/countries");
 var _Select = _interopRequireDefault(require("./Select"));
 /** @jsx jsx */
 
+// eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
+
 // custom option renderer
 var labelStyles = (0, _react.css)({
   alignItems: 'center',

package/dist/cjs/PopupSelect/PopupSelect.js

@@ -370,7 +370,9 @@ var PopupSelect = exports.default = /*#__PURE__*/function (_PureComponent) {
             (0, _platformFeatureFlags.getBooleanFF)('platform.design-system-team.popup-select-close_8h15h') && _this.close();
             (_props$onMenuClose = props.onMenuClose) === null || _props$onMenuClose === void 0 || _props$onMenuClose.call(props);
           },
-          isSearchable: showSearchControl,
+          isSearchable: showSearchControl
+          // eslint-disable-next-line @atlaskit/ui-styling-standard/no-imported-style-values -- Ignored via go/DSP-18766
+          ,
           styles: (0, _reactSelect.mergeStyles)(_this.defaultStyles, props.styles || {}),
           maxMenuHeight: _this.getMaxHeight(),
           components: selectComponents,

package/dist/cjs/PopupSelect/components.js

@@ -15,6 +15,7 @@ var _constants = require("@atlaskit/theme/constants");
 var _colors = require("@atlaskit/theme/colors");
 var _excluded = ["innerRef", "innerProps"];
 /** @jsx jsx */
+// eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 // ==============================
 // Styled Components
 // ==============================

package/dist/cjs/Select.js

@@ -9,7 +9,7 @@ var _reactSelect = _interopRequireDefault(require("react-select"));
 var _analyticsNext = require("@atlaskit/analytics-next");
 var _createSelect = _interopRequireDefault(require("./createSelect"));
 var packageName = "@atlaskit/select";
-var packageVersion = "17.10.2";
+var packageVersion = "17.10.4";
 var SelectWithoutAnalytics = exports.SelectWithoutAnalytics = (0, _createSelect.default)(_reactSelect.default);
 var createAndFireEventOnAtlaskit = (0, _analyticsNext.createAndFireEvent)('atlaskit');
 var Select = (0, _analyticsNext.withAnalyticsContext)({

package/dist/cjs/components/index.js

@@ -29,6 +29,7 @@ var _selectClear = _interopRequireDefault(require("@atlaskit/icon/glyph/select-c
 var _reactSelect = require("react-select");
 var _indicators = require("./indicators");
 /** @jsx jsx */
+// eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 
 var disabledStyles = (0, _react.css)({
   display: 'none'

package/dist/cjs/components/indicators.js

@@ -14,7 +14,7 @@ var _spinner = _interopRequireDefault(require("@atlaskit/spinner"));
 var _selectClear = _interopRequireDefault(require("@atlaskit/icon/glyph/select-clear"));
 var _chevronDown = _interopRequireDefault(require("@atlaskit/icon/glyph/chevron-down"));
 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) { (0, _defineProperty2.default)(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; } /** @jsx jsx */
+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) { (0, _defineProperty2.default)(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; } /** @jsx jsx */ // eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 var iconContainerStyles = (0, _primitives.xcss)({
   all: 'unset',
   outline: 'revert',
@@ -40,6 +40,7 @@ var DropdownIndicator = exports.DropdownIndicator = function DropdownIndicator(p
   }));
 };
 var LoadingIndicator = exports.LoadingIndicator = function LoadingIndicator(props) {
+  // eslint-disable-next-line @atlaskit/ui-styling-standard/no-unsafe-values -- Ignored via go/DSP-18766
   var loadingStyles = (0, _react.css)(props.getStyles('loadingIndicator', props));
   return (
     // This *must* be constructed this way because this is being consumed by