@amazon-devices/eslint-plugin-kepler 0.1.4 → 0.1.8

package/dist/rules/backwardCompatibility/BackwardCompatibilityCopyOnPack.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KEP_COMPAT_PACK_CTA = exports.BackwardCompatibilityCopyOnPack = void 0;
+var _RuleUtils = require("../../utils/RuleUtils");
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All rights reserved.
+// AMAZON PROPRIETARY/CONFIDENTIAL
+// You may not use this file except in compliance with the terms and conditions
+// set forth in the accompanying LICENSE.TXT file.
+// THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY
+// DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS,
+// IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+const KEP_COMPAT_PACK_CTA = exports.KEP_COMPAT_PACK_CTA = 'kepler-compatibility.json must be included in npm packages. Please add kepler-compatibility.json to the `files` field in your package.json.';
+
+/**
+ * Gets the location of the files field in package.json for error reporting
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const getFilesFieldLocation = sourceCode => {
+  const text = sourceCode.getText();
+  const filesMatch = text.match(/"files"\s*:\s*\[[^\]]*\]/);
+  if (filesMatch) {
+    const start = text.indexOf(filesMatch[0]);
+    const startPos = sourceCode.getLocFromIndex(start);
+    const endPos = sourceCode.getLocFromIndex(start + filesMatch[0].length);
+    return {
+      start: startPos,
+      end: endPos
+    };
+  }
+  return {
+    start: {
+      line: 1,
+      column: 0
+    },
+    end: {
+      line: 1,
+      column: 0
+    }
+  };
+};
+
+/**
+ * Checks that kepler-compatibility.json is included in the files array of package.json
+ */
+const BackwardCompatibilityCopyOnPack = exports.BackwardCompatibilityCopyOnPack = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Ensures kepler-compatibility.json is included in npm packages',
+      recommended: true,
+      category: 'Backward Compatibility'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      Program() {
+        // do nothing if not in a Brazil repo and/or this isn't a library
+        if (!(0, _RuleUtils.isBrazilRepo)() || !(0, _RuleUtils.isSDLProject)()) {
+          return;
+        }
+
+        // Use modern context.filename with fallback to deprecated context.getFilename()
+        const filename = context.filename || context.getFilename();
+        if (!filename.endsWith('package.json')) {
+          return;
+        }
+
+        // Use modern context.sourceCode with fallback to deprecated context.getSourceCode()
+        const sourceCode = context.sourceCode || context.getSourceCode();
+        const text = sourceCode.getText();
+        try {
+          const packageJson = JSON.parse(text);
+          const files = packageJson.files;
+          if (!files || !Array.isArray(files)) {
+            context.report({
+              node: sourceCode.ast,
+              message: KEP_COMPAT_PACK_CTA,
+              loc: getFilesFieldLocation(sourceCode)
+            });
+            return;
+          }
+          if (!files.includes('kepler-compatibility.json')) {
+            context.report({
+              node: sourceCode.ast,
+              message: KEP_COMPAT_PACK_CTA,
+              loc: getFilesFieldLocation(sourceCode)
+            });
+          }
+        } catch {
+          // Ignore JSON parsing errors for package.json. Linting will be unreliable anyway.
+        }
+      }
+    };
+  }
+};

package/dist/rules/backwardCompatibility/BackwardCompatibilitySysconfCheck.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BackwardCompatibilitySysconfCheck = void 0;
+var fs = _interopRequireWildcard(require("fs"));
+var path = _interopRequireWildcard(require("path"));
+var _RuleUtils = require("../../utils/RuleUtils");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All rights reserved.
+// AMAZON PROPRIETARY/CONFIDENTIAL
+// You may not use this file except in compliance with the terms and conditions
+// set forth in the accompanying LICENSE.TXT file.
+// THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY
+// DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS,
+// IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+/**
+ * Validates that libraries referenced in kepler-compatibility.json exist in kepler-system-conf.toml
+ */
+const BackwardCompatibilitySysconfCheck = exports.BackwardCompatibilitySysconfCheck = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Validates that versions or modules in kepler-compatibility.json exist in kepler-system-conf.toml.',
+      recommended: true,
+      category: 'Backward Compatibility'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      Program() {
+        // do nothing if not in a Brazil repo and/or this isn't a library
+        if (!(0, _RuleUtils.isBrazilRepo)() || !(0, _RuleUtils.isSDLProject)()) {
+          return;
+        }
+
+        // Use modern context.filename with fallback to deprecated context.getFilename()
+        const filename = context.filename || context.getFilename();
+        if (!filename.endsWith('kepler-compatibility.json')) {
+          return;
+        }
+
+        // Use modern context.sourceCode with fallback to deprecated context.getSourceCode()
+        const sourceCode = context.sourceCode || context.getSourceCode();
+        const text = sourceCode.getText();
+        try {
+          const compatibilityData = JSON.parse(text);
+          const projectRoot = process.cwd();
+          const sysconfPath = path.join(projectRoot, 'kepler-system-conf.toml');
+          if (!fs.existsSync(sysconfPath)) {
+            return;
+          }
+          const sysconfContent = fs.readFileSync(sysconfPath, 'utf8');
+          const libraryIds = Object.values(compatibilityData.versions || {});
+          for (const libraryId of libraryIds) {
+            if (!sysconfContent.includes(`id = "${libraryId}"`)) {
+              context.report({
+                node: sourceCode.ast,
+                message: `Library "${libraryId}" referenced in kepler-compatibility.json is not found in kepler-system-conf.toml. Please add the module definition.`
+              });
+            }
+          }
+        } catch {
+          // Ignore JSON parsing errors
+        }
+      }
+    };
+  }
+};

package/dist/rules/performance/Animated.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Animated = void 0;
+var _Constants = require("../../utils/Constants");
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+const USE_NATIVE_DRIVER_PROP_NAME = 'useNativeDriver';
+const NATIVE_DRIVER_MESSAGE = `Set ${USE_NATIVE_DRIVER_PROP_NAME} to 'true' to run animations on UI thread for better performance.  ` + `See ${_Constants.VEGA_BEST_PRACTICE_URL}#the-animated-library for more.`;
+const Animated = exports.Animated = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: "Recommends performance optimization configs for 'Animated' component",
+      recommended: true,
+      category: 'Performance'
+    },
+    fixable: 'code',
+    schema: []
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const isAnimated = node.callee.type === 'MemberExpression' && node.callee.object.name === 'Animated' && (node.callee.property.name === 'timing' || node.callee.property.name === 'spring' || node.callee.property.name === 'decay');
+        if (!isAnimated) {
+          return;
+        }
+        const animatedFunction = `${node.callee.object.name}.${node.callee.property.name}()`;
+        // Animated.timing/spring/decay() accept 2 arguments 'value' and 'config'
+        if (node.arguments.length < 2) {
+          return;
+        }
+        const configArgument = node.arguments[1];
+
+        // Check if configArgument is of type object
+        if (configArgument.type !== 'ObjectExpression') {
+          return;
+        }
+
+        // Check if the config object has a property named 'useNativeDriver'
+        const useNativeDriverProperty = configArgument.properties.find(prop => prop.type === 'Property' && prop.key.type === 'Identifier' && prop.key.name === USE_NATIVE_DRIVER_PROP_NAME);
+        if (!useNativeDriverProperty) {
+          context.report({
+            node,
+            message: `${animatedFunction} missing props: '${USE_NATIVE_DRIVER_PROP_NAME}'.  ${NATIVE_DRIVER_MESSAGE}`
+          });
+          return;
+        }
+
+        // If 'useNativeDriver' exists, check if it's set to true
+        if (useNativeDriverProperty && useNativeDriverProperty.value.type === 'Literal' && useNativeDriverProperty.value.value === true) {
+          return;
+        }
+        context.report({
+          node,
+          message: `'${USE_NATIVE_DRIVER_PROP_NAME}' property is set to 'false'.  ${NATIVE_DRIVER_MESSAGE}`
+        });
+      }
+    };
+  }
+};

package/dist/rules/performance/CheckSubscription.js

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CheckSubscription = void 0;
+var _Constants = require("../../utils/Constants");
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All rights reserved.
+// AMAZON PROPRIETARY/CONFIDENTIAL
+// You may not use this file except in compliance with the terms and conditions
+// set forth in the accompanying LICENSE.TXT file.
+// THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY
+// DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS,
+// IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+const moreUrlMessage = `See ${_Constants.VEGA_BEST_PRACTICE_URL}#listeners-event-subscriptions-and-timers for more.`;
+const CheckSubscription = exports.CheckSubscription = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Checks if subscriptions are set to be cleaned up',
+      recommended: true,
+      category: 'Performance'
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      failedToKeepSubscription: `Subscription must be kept in variable so that it can be cleaned up on the component is detached.  ${moreUrlMessage}`,
+      missingCleanUp: `Subscription \`{{varName}}\` is not cleaned up.  ${moreUrlMessage}`
+    }
+  },
+  create(context) {
+    const addListenerFuncs = new Set();
+    const subscriptionVars = new Set();
+    const subscriptionCollections = new Set();
+    const stateManagerVars = new Set();
+
+    // Return true if the given node is a call to adding a listener.
+    // Ex. `addInputListener(..)` or `appStateManager.addAppStateListener(...)`
+    function isExpressionToAddListener(node) {
+      if (node.callee.type === 'Identifier') {
+        return addListenerFuncs.has(node.callee.name);
+      }
+      if (node.callee.type === 'MemberExpression') {
+        if (node.callee.object.type === 'Identifier' && stateManagerVars.has(node.callee.object.name) && node.callee.property.type === 'Identifier' && node.callee.property.name === 'addAppStateListener') {
+          return true;
+        }
+      }
+      return false;
+    }
+    return {
+      // Collect variables containing functions to add listener.
+      // Ex. `const ${var} = useAddKeplerAppStateListenerCallback()`
+      'VariableDeclarator[init.callee.name = /^useAdd(KeplerAppState|UserInput)ListenerCallback$/]': node => {
+        if (node.id.type === 'Identifier') {
+          const varName = node.id.name;
+          addListenerFuncs.add(varName);
+        }
+      },
+      // Collect variables containing AppStateManager.
+      // Ex. `const ${varName} = useKeplerAppStateManager()`
+      'VariableDeclarator[init.callee.name = /^useKeplerAppStateManager$/]': node => {
+        if (node.id.type === 'Identifier') {
+          const varName = node.id.name;
+          stateManagerVars.add(varName);
+        }
+      },
+      // Check the code adding listeners and collect variables containing subscriptions.
+      // Warn code like `useEffect(() => {...; ${addListenerFunc}(....); ...}`
+      // Collect vars like `useEffect(() => {...; ${subscriptionVar} = ${addListenerFunc}(....); ...}`
+      // or `useEffect(() => {...; ${subscriptionCollection}.push(${addListenerFunc}(....)); ...}`
+      "CallExpression[callee.name='useEffect'] :function CallExpression": node => {
+        if (isExpressionToAddListener(node)) {
+          const sourceCode = context.sourceCode ?? context.getSourceCode();
+          const ancestors = sourceCode.getAncestors?.(node) ?? context.getAncestors();
+          if (ancestors.length >= 1) {
+            const parent = ancestors[ancestors.length - 1];
+            if (parent.type === 'VariableDeclarator' && parent.id.type == 'Identifier') {
+              // [const|let|var] ${var} = ${addListenerFunc}(....)
+              subscriptionVars.add(parent.id.name);
+              return;
+            } else if (parent.type === 'AssignmentExpression' && parent.left.type == 'Identifier') {
+              // ${var} = ${addListenerFunc}(....)
+              subscriptionVars.add(parent.left.name);
+              return;
+            } else if (parent.type === 'CallExpression' && parent.arguments[0] === node && parent.callee.type === 'MemberExpression') {
+              const callee = parent.callee;
+              if (
+              // ${collection}.[add|push](${addListenerFunc}(....));
+              callee.property.type === 'Identifier' && ['add', 'push'].includes(callee.property.name) && callee.object.type === 'Identifier') {
+                subscriptionCollections.add(callee.object.name);
+                return;
+              }
+            }
+          }
+          context.report({
+            node: node,
+            messageId: 'failedToKeepSubscription'
+          });
+        }
+      },
+      // Remove subscription vars that are cleaned up in a function returned by the effect function.
+      // Ex. `useEffect(() => {...; return () => ${subscriptionVar}.remove()});`
+      "CallExpression[callee.name='useEffect'] :function ReturnStatement CallExpression[callee.property.name='remove']": removeCall => {
+        if (removeCall.callee.type === 'MemberExpression') {
+          const callee = removeCall.callee;
+          if (callee.object.type === 'Identifier' && subscriptionVars.has(callee.object.name)) {
+            subscriptionVars.delete(callee.object.name);
+          }
+        }
+      },
+      // Remove subscription collections that are cleaned up in a function returned by the effect function.
+      // Ex. `useEffect(() => {...; return () => ${subscriptionCollection}.forEach(s => s.remove())});`
+      "CallExpression[callee.name='useEffect'] :function ReturnStatement CallExpression[callee.property.name='forEach']": forEachCall => {
+        if (forEachCall.callee.type === 'MemberExpression') {
+          const callee = forEachCall.callee;
+          if (callee.object.type === 'Identifier' && subscriptionCollections.has(callee.object.name)) {
+            // Though it would be more precise to check if each subscription is removed in the function passed to `forEach`,
+            // it's overkill. Let's accept false-negative by now.
+            subscriptionCollections.delete(callee.object.name);
+          }
+        }
+      },
+      // Report all subscription vars and collections that are not removed at the exit of `useEffect` call
+      "CallExpression[callee.name='useEffect']:exit": node => {
+        for (const varName of subscriptionVars) {
+          context.report({
+            node,
+            messageId: 'missingCleanUp',
+            data: {
+              varName
+            }
+          });
+        }
+        for (const varName of subscriptionCollections) {
+          context.report({
+            node,
+            messageId: 'missingCleanUp',
+            data: {
+              varName
+            }
+          });
+        }
+        subscriptionVars.clear();
+        subscriptionCollections.clear();
+      }
+    };
+  }
+};

package/dist/rules/performance/DetectSplashScreen.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DetectSplashScreen = void 0;
+var _KeplerESLintPluginStateManager = require("../../state/KeplerESLintPluginStateManager");
+var _RuleUtils = require("../../utils/RuleUtils");
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All rights reserved.
+// AMAZON PROPRIETARY/CONFIDENTIAL
+// You may not use this file except in compliance with the terms and conditions
+// set forth in the accompanying LICENSE.TXT file.
+// THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY
+// DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS,
+// IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+const USE_PREVENT_HIDE_SPLASH_SCREEN = 'usePreventHideSplashScreen';
+const USE_HIDE_SPLASH_SCREEN_CALLBACK = 'useHideSplashScreenCallback';
+const DetectSplashScreen = exports.DetectSplashScreen = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'usePreventHideSplashScreen() should be used to natively render splash screen, for better App launch performance',
+      recommended: true,
+      category: 'Performance'
+    },
+    fixable: 'code',
+    schema: []
+  },
+  create(context) {
+    const usePreventHideSplashScreenAliases = new Set();
+    const useHideSplashScreenCallbackAliases = new Set();
+    return {
+      VariableDeclarator(node) {
+        // Check usePreventHideSplashScreen()
+        if ((0, _RuleUtils.isFunctionAssignedToVariable)(node, USE_PREVENT_HIDE_SPLASH_SCREEN) || (0, _RuleUtils.isModuleFunctionAssignedToVariable)(node, USE_PREVENT_HIDE_SPLASH_SCREEN)) {
+          usePreventHideSplashScreenAliases.add(node.id['name']);
+        }
+        // Check useHideSplashScreenCallback()
+        else if ((0, _RuleUtils.isFunctionAssignedToVariable)(node, USE_HIDE_SPLASH_SCREEN_CALLBACK) || (0, _RuleUtils.isModuleFunctionAssignedToVariable)(node, USE_HIDE_SPLASH_SCREEN_CALLBACK)) {
+          useHideSplashScreenCallbackAliases.add(node.id['name']);
+        }
+      },
+      CallExpression(node) {
+        // Check usePreventHideSplashScreen()
+        if ((0, _RuleUtils.isDirectCall)(node, USE_PREVENT_HIDE_SPLASH_SCREEN) || (0, _RuleUtils.isAliasCall)(node, USE_PREVENT_HIDE_SPLASH_SCREEN, usePreventHideSplashScreenAliases) || (0, _RuleUtils.isNamespacedCall)(node, USE_PREVENT_HIDE_SPLASH_SCREEN)) {
+          const keplerESLintState = _KeplerESLintPluginStateManager.KeplerESLintPluginStateManager.getInstance().getKeplerESLintState();
+          keplerESLintState.splashScreen.usePreventHideSplashScreenFound = true;
+          _KeplerESLintPluginStateManager.KeplerESLintPluginStateManager.getInstance().setKeplerESLintState(keplerESLintState);
+        }
+
+        // Check useHideSplashScreenCallback()
+        else if ((0, _RuleUtils.isDirectCall)(node, USE_HIDE_SPLASH_SCREEN_CALLBACK) || (0, _RuleUtils.isAliasCall)(node, USE_HIDE_SPLASH_SCREEN_CALLBACK, useHideSplashScreenCallbackAliases) || (0, _RuleUtils.isNamespacedCall)(node, USE_HIDE_SPLASH_SCREEN_CALLBACK)) {
+          const keplerESLintState = _KeplerESLintPluginStateManager.KeplerESLintPluginStateManager.getInstance().getKeplerESLintState();
+          keplerESLintState.splashScreen.useHideSplashScreenCallbackFound = true;
+          _KeplerESLintPluginStateManager.KeplerESLintPluginStateManager.getInstance().setKeplerESLintState(keplerESLintState);
+        }
+      }
+    };
+  }
+};

package/dist/rules/performance/DetectUseReportFullyDrawn.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DetectUseReportFullyDrawn = void 0;
+var _KeplerESLintPluginStateManager = require("../../state/KeplerESLintPluginStateManager");
+var _RuleUtils = require("../../utils/RuleUtils");
+// Copyright 2025 Amazon.com, Inc. or its affiliates. All rights reserved.
+// AMAZON PROPRIETARY/CONFIDENTIAL
+// You may not use this file except in compliance with the terms and conditions
+// set forth in the accompanying LICENSE.TXT file.
+// THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY
+// DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS,
+// IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+const USE_REPORT_FULLY_DRAWN_FUNCTION_NAME = 'useReportFullyDrawn';
+const DetectUseReportFullyDrawn = exports.DetectUseReportFullyDrawn = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'useReportFullyDrawn() callback should be used to measure Time to Fully Drawn',
+      recommended: true,
+      category: 'Performance'
+    },
+    fixable: 'code',
+    schema: []
+  },
+  create(context) {
+    const useReportFullyDrawnAliases = new Set();
+    return {
+      VariableDeclarator(node) {
+        if ((0, _RuleUtils.isFunctionAssignedToVariable)(node, USE_REPORT_FULLY_DRAWN_FUNCTION_NAME)) {
+          useReportFullyDrawnAliases.add(node.id['name']);
+        }
+        if ((0, _RuleUtils.isModuleFunctionAssignedToVariable)(node, USE_REPORT_FULLY_DRAWN_FUNCTION_NAME)) {
+          useReportFullyDrawnAliases.add(node.id['name']);
+        }
+      },
+      CallExpression(node) {
+        if ((0, _RuleUtils.isDirectCall)(node, USE_REPORT_FULLY_DRAWN_FUNCTION_NAME) || (0, _RuleUtils.isAliasCall)(node, USE_REPORT_FULLY_DRAWN_FUNCTION_NAME, useReportFullyDrawnAliases) || (0, _RuleUtils.isNamespacedCall)(node, USE_REPORT_FULLY_DRAWN_FUNCTION_NAME)) {
+          const keplerESLintState = _KeplerESLintPluginStateManager.KeplerESLintPluginStateManager.getInstance().getKeplerESLintState();
+          keplerESLintState.fullyDrawn.useReportFullyDrawnFound = true;
+          _KeplerESLintPluginStateManager.KeplerESLintPluginStateManager.getInstance().setKeplerESLintState(keplerESLintState);
+        }
+      }
+    };
+  }
+};

package/dist/rules/performance/FlatList.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FlatList = void 0;
+var _Constants = require("../../utils/Constants");
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+const FLATLIST_PERF_REQD_PROPS = ['initialNumToRender', 'windowSize', 'removeClippedSubviews', 'maxToRenderPerBatch', 'updateCellsBatchingPeriod'];
+const FlatList = exports.FlatList = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'FlatList causes performance overhead and should be used carefully',
+      recommended: true,
+      category: 'Performance'
+    },
+    fixable: 'code',
+    schema: []
+  },
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        if (node.name.name === 'FlatList') {
+          const currentFlatListPropNames = node.attributes.map(attr => attr.name.name);
+          const missingProps = FLATLIST_PERF_REQD_PROPS.filter(prop => !currentFlatListPropNames.includes(prop));
+          if (missingProps.length > 0) {
+            context.report({
+              node,
+              message: `FlatList missing props: '${missingProps}'.  FlatList performance is not fully unlocked without these props.  ` + `See ${_Constants.VEGA_BEST_PRACTICE_URL}#flatlist for more.`
+            });
+          }
+        }
+      }
+    };
+  }
+};