@elastic/eslint-plugin-eui 2.15.0 → 2.16.0

package/lib/cjs/rules/callout_prefer_props_for_content.js

@@ -7,6 +7,7 @@ exports.CallOutPreferPropsForContent = void 0;
 var _utils = require("@typescript-eslint/utils");
 var _constants = require("../utils/constants");
 var _get_element_name = require("../utils/get_element_name");
+var _walk_jsx_children = require("../utils/walk_jsx_children");
 /*
  * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
  * or more contributor license agreements. Licensed under the Elastic License
@@ -17,161 +18,6 @@ var _get_element_name = require("../utils/get_element_name");
 
 const DEFAULT_COMPONENTS = ['EuiCallOut'];
 const EUI_ACTION_COMPONENTS = new Set(_constants.INTERACTIVE_EUI_COMPONENTS.filter(c => c.startsWith('EuiButton') || c === 'EuiLink'));
-/**
- * Recursively checks a node for text or action elements that should not be in callout children.
- * It unwraps fragments, layout containers, conditional expressions, and logical expressions.
- * It does NOT traverse into custom/complex component children.
- */
-function checkNode(node, context, componentName) {
-  switch (node.type) {
-    case 'JSXText':
-      {
-        // Plain string content
-        if (node.value.trim().length > 0) {
-          context.report({
-            node,
-            messageId: 'childrenHavePlainText',
-            data: {
-              componentName
-            }
-          });
-        }
-        break;
-      }
-    case 'Literal':
-      {
-        const {
-          value
-        } = node;
-        if (typeof value === 'string' && value.trim().length > 0) {
-          context.report({
-            node,
-            messageId: 'childrenHavePlainText',
-            data: {
-              componentName
-            }
-          });
-        }
-        break;
-      }
-    case 'JSXElement':
-      {
-        const el = node;
-        const {
-          name
-        } = el.openingElement;
-        if (name.type === 'JSXMemberExpression' && name.object.type === 'JSXIdentifier' && name.object.name === 'React' && name.property.type === 'JSXIdentifier' && name.property.name === 'Fragment') {
-          for (const child of el.children) {
-            checkNode(child, context, componentName);
-          }
-          break;
-        }
-        const elementName = (0, _get_element_name.getElementName)(el.openingElement);
-        if (!elementName) return;
-        if (_constants.HTML_TEXT_ELEMENTS.has(elementName) || _constants.EUI_TEXT_COMPONENTS.has(elementName) || _constants.I18N_TEXT_COMPONENTS.has(elementName)) {
-          context.report({
-            node,
-            messageId: 'childrenHaveText',
-            data: {
-              elementName,
-              componentName
-            }
-          });
-        } else if (_constants.HTML_ACTION_ELEMENTS.has(elementName) || EUI_ACTION_COMPONENTS.has(elementName)) {
-          context.report({
-            node,
-            messageId: 'childrenHaveActions',
-            data: {
-              elementName,
-              componentName
-            }
-          });
-        } else if (_constants.CALLOUT_LAYOUT_CONTAINERS.has(elementName)) {
-          // Transparent layout wrapper, traverse its children
-          for (const child of el.children) {
-            checkNode(child, context, componentName);
-          }
-        }
-
-        // Custom/complex component, don't traverse its children
-        break;
-      }
-    case 'JSXFragment':
-      {
-        for (const child of node.children) {
-          checkNode(child, context, componentName);
-        }
-        break;
-      }
-    case 'MemberExpression':
-      {
-        const {
-          object
-        } = node;
-        if (object.type === 'Identifier' && object.name === 'i18n') {
-          context.report({
-            node,
-            messageId: 'childrenHavePlainText',
-            data: {
-              componentName
-            }
-          });
-        }
-        break;
-      }
-    case 'TemplateLiteral':
-      {
-        context.report({
-          node,
-          messageId: 'childrenHavePlainText',
-          data: {
-            componentName
-          }
-        });
-        break;
-      }
-    case 'ArrayExpression':
-      {
-        for (const element of node.elements) {
-          if (element) checkNode(element, context, componentName);
-        }
-        break;
-      }
-    case 'JSXExpressionContainer':
-      {
-        const {
-          expression
-        } = node;
-        if (expression.type !== 'JSXEmptyExpression') {
-          checkNode(expression, context, componentName);
-        }
-        break;
-      }
-    case 'LogicalExpression':
-      {
-        const {
-          left,
-          right
-        } = node;
-        checkNode(left, context, componentName);
-        checkNode(right, context, componentName);
-        break;
-      }
-    case 'ConditionalExpression':
-      {
-        // e.g. {condition ? <p>text</p> : null}
-        const {
-          consequent,
-          alternate
-        } = node;
-        checkNode(consequent, context, componentName);
-        checkNode(alternate, context, componentName);
-        break;
-      }
-    default:
-      break;
-  }
-}
 const CallOutPreferPropsForContent = exports.CallOutPreferPropsForContent = _utils.ESLintUtils.RuleCreator.withoutDocs({
   create(context) {
     const components = new Set(context.options[0]?.components ?? DEFAULT_COMPONENTS);
@@ -184,8 +30,99 @@ const CallOutPreferPropsForContent = exports.CallOutPreferPropsForContent = _uti
         if (openingElement.name.type !== 'JSXIdentifier' || !components.has(openingElement.name.name)) {
           return;
         }
+        const componentName = openingElement.name.name;
         for (const child of children) {
-          checkNode(child, context, openingElement.name.name);
+          (0, _walk_jsx_children.walkJsxChildren)(child, leaf => {
+            switch (leaf.type) {
+              case 'JSXText':
+                {
+                  if (leaf.value.trim().length > 0) {
+                    context.report({
+                      node: leaf,
+                      messageId: 'childrenHavePlainText',
+                      data: {
+                        componentName
+                      }
+                    });
+                  }
+                  break;
+                }
+              case 'Literal':
+                {
+                  const {
+                    value
+                  } = leaf;
+                  if (typeof value === 'string' && value.trim().length > 0) {
+                    context.report({
+                      node: leaf,
+                      messageId: 'childrenHavePlainText',
+                      data: {
+                        componentName
+                      }
+                    });
+                  }
+                  break;
+                }
+              case 'TemplateLiteral':
+                {
+                  context.report({
+                    node: leaf,
+                    messageId: 'childrenHavePlainText',
+                    data: {
+                      componentName
+                    }
+                  });
+                  break;
+                }
+              case 'MemberExpression':
+                {
+                  const {
+                    object
+                  } = leaf;
+                  if (object.type === 'Identifier' && object.name === 'i18n') {
+                    context.report({
+                      node: leaf,
+                      messageId: 'childrenHavePlainText',
+                      data: {
+                        componentName
+                      }
+                    });
+                  }
+                  break;
+                }
+              case 'JSXElement':
+                {
+                  const el = leaf;
+                  const elementName = (0, _get_element_name.getElementName)(el.openingElement);
+                  if (!elementName) break;
+                  if (_constants.HTML_TEXT_ELEMENTS.has(elementName) || _constants.EUI_TEXT_COMPONENTS.has(elementName) || _constants.I18N_TEXT_COMPONENTS.has(elementName)) {
+                    context.report({
+                      node: leaf,
+                      messageId: 'childrenHaveText',
+                      data: {
+                        elementName,
+                        componentName
+                      }
+                    });
+                  } else if (_constants.HTML_ACTION_ELEMENTS.has(elementName) || EUI_ACTION_COMPONENTS.has(elementName)) {
+                    context.report({
+                      node: leaf,
+                      messageId: 'childrenHaveActions',
+                      data: {
+                        elementName,
+                        componentName
+                      }
+                    });
+                  }
+                  break;
+                }
+            }
+          }, {
+            shouldSkip: el => {
+              const name = (0, _get_element_name.getElementName)(el.openingElement);
+              return !!name && _constants.CALLOUT_LAYOUT_CONTAINERS.has(name);
+            }
+          });
         }
       }
     };

package/lib/cjs/rules/no_deprecated_icon_aliases.d.ts

@@ -0,0 +1,174 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const DEPRECATED_ICON_ALIASES: {
+    readonly alert: "warning";
+    readonly anomalyChart: "chartAnomaly";
+    readonly apmTrace: "chartWaterfall";
+    readonly arrowDown: "chevronSingleDown";
+    readonly arrowEnd: "chevronLimitRight";
+    readonly arrowLeft: "chevronSingleLeft";
+    readonly arrowRight: "chevronSingleRight";
+    readonly arrowStart: "chevronLimitLeft";
+    readonly arrowUp: "chevronSingleUp";
+    readonly beaker: "flask";
+    readonly boxesHorizontal: "ellipsis";
+    readonly boxesVertical: "ellipsis";
+    readonly changePointDetection: "chartChangePoint";
+    readonly checkInCircleFilled: "checkCircleFill";
+    readonly cheer: "popper";
+    readonly color: "paintBucket";
+    readonly compute: "processor";
+    readonly console: "commandLine";
+    readonly contrastHigh: "contrastFill";
+    readonly controlsHorizontal: "controls";
+    readonly controlsVertical: "controls";
+    readonly copyClipboard: "copy";
+    readonly crossInCircle: "crossCircle";
+    readonly crosshairs: "crosshair";
+    readonly currency: "money";
+    readonly cut: "scissors";
+    readonly desktop: "display";
+    readonly diff: "compare";
+    readonly discuss: "comment";
+    readonly documentEdit: "pencil";
+    readonly documents: "document";
+    readonly doubleArrowLeft: "chevronDoubleLeft";
+    readonly doubleArrowRight: "chevronDoubleRight";
+    readonly editorAlignCenter: "textAlignCenter";
+    readonly editorAlignLeft: "textAlignLeft";
+    readonly editorAlignRight: "textAlignRight";
+    readonly editorBold: "textBold";
+    readonly editorChecklist: "listCheck";
+    readonly editorCodeBlock: "code";
+    readonly editorComment: "comment";
+    readonly editorDistributeHorizontal: "distributeHorizontal";
+    readonly editorDistributeVertical: "distributeVertical";
+    readonly editorHeading: "textHeading";
+    readonly editorItalic: "textItalic";
+    readonly editorItemAlignBottom: "alignBottom";
+    readonly editorItemAlignCenter: "alignCenterHorizontal";
+    readonly editorItemAlignLeft: "alignLeft";
+    readonly editorItemAlignMiddle: "alignCenterVertical";
+    readonly editorItemAlignRight: "alignRight";
+    readonly editorItemAlignTop: "alignTop";
+    readonly editorLink: "link";
+    readonly editorOrderedList: "listNumber";
+    readonly editorPositionBottomLeft: "alignBottomLeft";
+    readonly editorPositionBottomRight: "alignBottomRight";
+    readonly editorPositionTopLeft: "alignTopLeft";
+    readonly editorPositionTopRight: "alignTopRight";
+    readonly editorRedo: "redo";
+    readonly editorStrike: "textStrike";
+    readonly editorTable: "table";
+    readonly editorUnderline: "textUnderline";
+    readonly editorUndo: "undo";
+    readonly editorUnorderedList: "listBullet";
+    readonly email: "mail";
+    readonly eql: "query";
+    readonly errorFilled: "errorFill";
+    readonly exit: "logOut";
+    readonly expand: "maximize";
+    readonly expandMini: "maximize";
+    readonly export: "upload";
+    readonly exportAction: "upload";
+    readonly eyeClosed: "eyeSlash";
+    readonly fieldStatistics: "tableInfo";
+    readonly filterInCircle: "filter";
+    readonly folderCheck: "check";
+    readonly folderOpened: "folderOpen";
+    readonly glasses: "readOnly";
+    readonly grab: "dragVertical";
+    readonly grabHorizontal: "dragHorizontal";
+    readonly grabOmnidirectional: "drag";
+    readonly heatmap: "chartHeatmap";
+    readonly importAction: "download";
+    readonly indexClose: "tableCross";
+    readonly indexEdit: "tablePencil";
+    readonly indexFlush: "chartThreshold";
+    readonly indexMapping: "mapping";
+    readonly indexOpen: "tablePlus";
+    readonly indexRuntime: "tablePlay";
+    readonly indexSettings: "tableGear";
+    readonly indexTemporary: "tableTime";
+    readonly invert: "contrast";
+    readonly kqlField: "queryField";
+    readonly kqlOperand: "queryOperand";
+    readonly kqlSelector: "querySelector";
+    readonly kqlValue: "queryValue";
+    readonly kubernetesPod: "cube";
+    readonly launch: "rocket";
+    readonly lettering: "text";
+    readonly lineDashed: "lineDash";
+    readonly lineDotted: "lineDot";
+    readonly list: "listBullet";
+    readonly listAdd: "plusCircle";
+    readonly logPatternAnalysis: "pattern";
+    readonly logRateAnalysis: "chartBarVertical";
+    readonly logstashIf: "if";
+    readonly logstashQueue: "queue";
+    readonly magnifyWithExclamation: "magnifyExclamation";
+    readonly magnifyWithMinus: "magnifyMinus";
+    readonly magnifyWithPlus: "magnifyPlus";
+    readonly mapMarker: "waypoint";
+    readonly minusInCircle: "minusCircle";
+    readonly minusInCircleFilled: "minusCircle";
+    readonly minusInSquare: "minusSquare";
+    readonly newChat: "plusCircle";
+    readonly node: "vectorTriangle";
+    readonly offline: "wifiSlash";
+    readonly online: "wifi";
+    readonly pagesSelect: "documentsCheck";
+    readonly pinFilled: "pinFill";
+    readonly pipeBreaks: "lineBreak";
+    readonly pipeNoBreaks: "lineBreakSlash";
+    readonly playFilled: "play";
+    readonly plusInCircle: "plusCircle";
+    readonly plusInCircleFilled: "plusCircle";
+    readonly plusInSquare: "plusSquare";
+    readonly popout: "external";
+    readonly productRobot: "productAgent";
+    readonly push: "send";
+    readonly returnKey: "return";
+    readonly search: "magnify";
+    readonly securitySignal: "radar";
+    readonly starEmpty: "star";
+    readonly starFilled: "starFill";
+    readonly starFilledSpace: "starFillSpace";
+    readonly starMinusFilled: "starMinusFill";
+    readonly starPlusFilled: "starPlusFill";
+    readonly stopFilled: "stopFill";
+    readonly streamsClassic: "productStreamsClassic";
+    readonly streamsWired: "productStreamsWired";
+    readonly submodule: "merge";
+    readonly tableDensityCompact: "tableDensityHigh";
+    readonly tableDensityExpanded: "tableDensityLow";
+    readonly tableDensityNormal: "table";
+    readonly temperature: "thermometer";
+    readonly timeRefresh: "refreshTime";
+    readonly timelineWithArrow: "timelinePointer";
+    readonly timeslider: "clockControl";
+    readonly tokenDenseVector: "tokenVectorDense";
+    readonly training: "presentation";
+    readonly unlink: "linkSlash";
+    readonly userAvatar: "user";
+    readonly vector: "vectorSquare";
+    readonly visArea: "chartArea";
+    readonly visAreaStacked: "chartAreaStack";
+    readonly visBarHorizontal: "chartBarHorizontal";
+    readonly visBarHorizontalStacked: "chartBarHorizontalStack";
+    readonly visBarVertical: "chartBarVertical";
+    readonly visBarVerticalStacked: "chartBarVerticalStack";
+    readonly visGauge: "chartGauge";
+    readonly visLine: "chartLine";
+    readonly visMapCoordinate: "waypoint";
+    readonly visMapRegion: "map";
+    readonly visMetric: "chartMetric";
+    readonly visPie: "chartPie";
+    readonly visTable: "table";
+    readonly visTagCloud: "chartTagCloud";
+    readonly visText: "text";
+    readonly visVega: "code";
+    readonly warningFilled: "warningFill";
+};
+export declare const DEPRECATED_ICONS_WITHOUT_REPLACEMENT: ReadonlySet<string>;
+export declare const NoDeprecatedIconAliases: ESLintUtils.RuleModule<"deprecatedIcon" | "deprecatedIconAlias", [], unknown, ESLintUtils.RuleListener>;
+//# sourceMappingURL=no_deprecated_icon_aliases.d.ts.map

package/lib/cjs/rules/no_deprecated_icon_aliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_deprecated_icon_aliases.d.ts","sourceRoot":"","sources":["../../../src/rules/no_deprecated_icon_aliases.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,WAAW,EAAY,MAAM,0BAA0B,CAAC;AAEjE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyK1B,CAAC;AAEX,eAAO,MAAM,oCAAoC,EAAE,WAAW,CAAC,MAAM,CAChD,CAAC;AAwEtB,eAAO,MAAM,uBAAuB,yGAyGlC,CAAC"}