@arcgis/eslint-config 4.33.0-next.64 → 4.33.0-next.66

package/dist/config/index.js

@@ -605,7 +605,9 @@ const index = [
       // This is error by default. Turning into warning because it falsely
       // reports when component tries to emit an event that is marked as
       // deprecated.
-      "@typescript-eslint/no-deprecated": "warn"
+      "@typescript-eslint/no-deprecated": "warn",
+      // For can be useful in support packages and hot paths
+      "@typescript-eslint/prefer-for-of": "off"
       //#endregion
       // TODO: go over https://typescript-eslint.io/linting/troubleshooting/performance-troubleshooting
     }

package/dist/{makePlugin-B2kjgMoQ.js → makePlugin-DfmxVuno.js}

@@ -1,4 +1,4 @@
-const version = "4.33.0-next.64";
+const version = "4.33.0-next.66";
 function makeEslintPlugin(pluginName, rules) {
   const config = {
     rules: Object.fromEntries(

package/dist/plugins/lumina/index.js

@@ -1,6 +1,6 @@
 import { ESLintUtils, AST_NODE_TYPES, AST_TOKEN_TYPES } from "@typescript-eslint/utils";
 import ts from "typescript";
-import { m as makeEslintPlugin } from "../../makePlugin-B2kjgMoQ.js";
+import { m as makeEslintPlugin } from "../../makePlugin-DfmxVuno.js";
 import { camelToKebab } from "@arcgis/components-utils";
 const createRule = ESLintUtils.RuleCreator(
   (rule) => `https://devtopia.esri.com/WebGIS/arcgis-web-components/tree/main/packages/support-packages/eslint-config/src/plugins/lumina/rules/${rule}.ts`
@@ -94,16 +94,16 @@ function isBindThisCallee(callee) {
   callee.object.object.type === AST_NODE_TYPES.ThisExpression;
 }
 const importDeclaration = `import { ${luminaJsxExportName} } from "${luminaEntrypointName}";`;
-const description$h = `To use Lumina's JSX, you need to ${importDeclaration}`;
+const description$i = `To use Lumina's JSX, you need to ${importDeclaration}`;
 const addMissingJsxImport = createRule({
   name: "add-missing-jsx-import",
   meta: {
     docs: {
-      description: description$h,
+      description: description$i,
       defaultLevel: "error"
     },
     messages: {
-      addMissingJsxImport: description$h
+      addMissingJsxImport: description$i
     },
     type: "problem",
     schema: [],
@@ -160,12 +160,12 @@ const addMissingJsxImport = createRule({
     };
   }
 });
-const description$g = "Auto add { type: Boolean } or { type: Number } where necessary";
+const description$h = "Auto add { type: Boolean } or { type: Number } where necessary";
 const autoAddType = createRule({
   name: "auto-add-type",
   meta: {
     docs: {
-      description: description$g,
+      description: description$h,
       defaultLevel: "warn"
     },
     messages: {
@@ -326,12 +326,12 @@ function inferTrivialType(member) {
   return "Other";
 }
 const builtInConverterTypes = /* @__PURE__ */ new Set(["Number", "Boolean", "Array", "Object"]);
-const description$f = `Lumina component must be declared in a TSX file with a matching folder name located inside of src/components folder.`;
+const description$g = `Lumina component must be declared in a TSX file with a matching folder name located inside of src/components folder.`;
 const componentPlacementRules = createRule({
   name: "component-placement-rules",
   meta: {
     docs: {
-      description: description$f,
+      description: description$g,
       defaultLevel: "error"
     },
     messages: {
@@ -370,7 +370,7 @@ const componentPlacementRules = createRule({
     };
   }
 });
-const description$e = `Enforce consistent event naming.`;
+const description$f = `Enforce consistent event naming.`;
 const defaultOptions$1 = [
   {
     eventNamespaces: ["arcgis"],
@@ -381,7 +381,7 @@ const consistentEventNaming = createRule({
   name: "consistent-event-naming",
   meta: {
     docs: {
-      description: description$e,
+      description: description$f,
       defaultLevel: "warn"
     },
     messages: {
@@ -482,12 +482,12 @@ Discussion: https://devtopia.esri.com/WebGIS/arcgis-web-components/discussions/3
   }
 });
 const capitalAfterLower = /(?<=[a-z\d])[A-Z]/u;
-const description$d = `Enforce that @property(), @method() and createEvent() members are used in the correct context.`;
+const description$e = `Enforce that @property(), @method() and createEvent() members are used in the correct context.`;
 const decoratorsContext = createRule({
   name: "decorators-context",
   meta: {
     docs: {
-      description: description$d,
+      description: description$e,
       defaultLevel: "error"
     },
     messages: {
@@ -552,6 +552,144 @@ If you wish to hide this member from public documentation, use @private or @prot
     };
   }
 });
+const litTemplateResult = "TemplateResult";
+const explicitJsxTypeName = "JsxNode";
+const implicitJsxTypeName = "Element";
+const implicitJsxParentName = "LuminaJsx";
+function isLuminaJsxType(type) {
+  for (const declaration of type.aliasSymbol?.declarations ?? []) {
+    if (!ts.isTypeAliasDeclaration(declaration)) {
+      continue;
+    }
+    const typeName = declaration.name.escapedText;
+    if (typeName === litTemplateResult || typeName === explicitJsxTypeName) {
+      return true;
+    }
+    if (typeName !== implicitJsxTypeName) {
+      continue;
+    }
+    const grandParent = declaration.parent?.parent;
+    if (!ts.isModuleDeclaration(grandParent)) {
+      continue;
+    }
+    const symbol = grandParent.symbol;
+    if (symbol?.escapedName === implicitJsxParentName) {
+      return true;
+    }
+  }
+  return false;
+}
+const hasTypeFlag = (type, flag) => type.flags & flag ? true : (type.flags & ts.TypeFlags.Union) !== 0 && type.types.some((t) => hasTypeFlag(t, flag));
+const literalTypeFlag = ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike;
+const description$d = `Need to add explicit type annotation: {{ setterType }}
+
+Explanation:
+Lumina automatically creates an attribute for a property if property type includes a literal type (string|number|boolean).
+For bound properties, the property type by default comes from the bound getter type.
+The property you are trying to bind includes a literal in the setter type, but not the getter type.
+An explicit type annotation is required to ensure the property has an attribute created.`;
+const explicitSetterType = createRule({
+  name: "explicit-setter-type",
+  meta: {
+    docs: {
+      description: description$d,
+      defaultLevel: "error"
+    },
+    messages: {
+      explicitSetterType: description$d,
+      addExplicitSetterType: `Add {{ setterType }} type annotation`
+    },
+    type: "problem",
+    schema: [],
+    fixable: void 0,
+    hasSuggestions: true
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = ESLintUtils.getParserServices(context);
+    let isUsingLumina = false;
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value === luminaEntrypointName) {
+          isUsingLumina = true;
+        }
+      },
+      ClassDeclaration(node) {
+        if (!isUsingLumina) {
+          return;
+        }
+        const accessorProperties = /* @__PURE__ */ new Set();
+        node.body.body.forEach((member) => {
+          if (member.type !== AST_NODE_TYPES.PropertyDefinition) {
+            return;
+          }
+          if (member.key.type !== AST_NODE_TYPES.Identifier) {
+            return;
+          }
+          const keyName = member.key.name;
+          const isGenericControllerLike = member.value?.type === AST_NODE_TYPES.CallExpression && member.value.callee.type === AST_NODE_TYPES.Identifier && member.value.callee.name.startsWith("use") && member.value.arguments.at(0)?.type === AST_NODE_TYPES.ThisExpression;
+          if (isGenericControllerLike) {
+            accessorProperties.add(keyName);
+            return;
+          }
+          const isBoundLike = member.value?.type === AST_NODE_TYPES.MemberExpression && member.value.object.type === AST_NODE_TYPES.MemberExpression && member.value.object.object.type === AST_NODE_TYPES.ThisExpression && member.value.object.property.type === AST_NODE_TYPES.Identifier && accessorProperties.has(member.value.object.property.name);
+          if (!isBoundLike) {
+            return;
+          }
+          accessorProperties.add(keyName);
+          const hasPropertyDecorator = member.decorators?.some(
+            (decorator) => decorator.expression.type === AST_NODE_TYPES.CallExpression && decorator.expression.callee.type === AST_NODE_TYPES.Identifier && decorator.expression.callee.name === "property"
+          );
+          if (!hasPropertyDecorator) {
+            return;
+          }
+          if (member.typeAnnotation !== void 0) {
+            return;
+          }
+          const symbol = services.getSymbolAtLocation(member.value);
+          const setter = symbol?.declarations?.find(ts.isSetAccessor);
+          const getter = symbol?.declarations?.find(ts.isGetAccessor);
+          if (setter === void 0 || getter === void 0) {
+            return;
+          }
+          const setterTypeNode = setter.parameters[0].type;
+          const getterTypeNode = getter.type;
+          if (setterTypeNode === void 0 || getterTypeNode === void 0) {
+            return;
+          }
+          const checker = services.program.getTypeChecker();
+          const setterType = checker.getTypeAtLocation(setterTypeNode);
+          const getterType = checker.getTypeAtLocation(getterTypeNode);
+          const setterIncludesLiteral = hasTypeFlag(setterType, literalTypeFlag);
+          const getterIncludesLiteral = hasTypeFlag(getterType, literalTypeFlag);
+          if (getterIncludesLiteral || !setterIncludesLiteral) {
+            return;
+          }
+          const setterTypeString = setterTypeNode.getText();
+          context.report({
+            node: member.key,
+            messageId: "explicitSetterType",
+            data: {
+              setterType: setterTypeString
+            },
+            // Not an auto fix because you may need to add imports too
+            suggest: [
+              {
+                messageId: "addExplicitSetterType",
+                data: {
+                  setterType: setterTypeString
+                },
+                fix(fixer) {
+                  return fixer.insertTextAfter(member.key, `: ${setterTypeString}`);
+                }
+              }
+            ]
+          });
+        });
+      }
+    };
+  }
+});
 const ordering = [
   /*
    * Putting static before instance members is a common OOP convention.
@@ -1343,33 +1481,6 @@ const noPropertyNameStartWithOn = createRule({
     };
   }
 });
-const litTemplateResult = "TemplateResult";
-const explicitJsxTypeName = "JsxNode";
-const implicitJsxTypeName = "Element";
-const implicitJsxParentName = "LuminaJsx";
-function isLuminaJsxType(type) {
-  for (const declaration of type.aliasSymbol?.declarations ?? []) {
-    if (!ts.isTypeAliasDeclaration(declaration)) {
-      continue;
-    }
-    const typeName = declaration.name.escapedText;
-    if (typeName === litTemplateResult || typeName === explicitJsxTypeName) {
-      return true;
-    }
-    if (typeName !== implicitJsxTypeName) {
-      continue;
-    }
-    const grandParent = declaration.parent?.parent;
-    if (!ts.isModuleDeclaration(grandParent)) {
-      continue;
-    }
-    const symbol = grandParent.symbol;
-    if (symbol?.escapedName === implicitJsxParentName) {
-      return true;
-    }
-  }
-  return false;
-}
 const baseDescription = `Avoid accidentally rendering "false" to the screen (Lit stringifies booleans, rather than drop them like React/Stencil).`;
 const description$4 = `${baseDescription}
 
@@ -1837,6 +1948,7 @@ const luminaPlugin = makeEslintPlugin("lumina", {
   "component-placement-rules": componentPlacementRules,
   "consistent-event-naming": consistentEventNaming,
   "decorators-context": decoratorsContext,
+  "explicit-setter-type": explicitSetterType,
   "member-ordering": memberOrdering,
   "no-ignore-jsdoc-tag": noIgnoreJsDocTag,
   "no-incorrect-dynamic-tag-name": noIncorrectDynamicTagName,

package/dist/plugins/lumina/rules/explicit-setter-type.d.ts

@@ -0,0 +1,18 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+/**
+ * @remarks
+ * It is easier to to do this in an ESLint rule rather than at build-time.
+ * Reason:
+ * - TypeScript does not have a syntax for retrieving the setter type
+ *   (https://github.com/microsoft/TypeScript/issues/60162)
+ * - While we could copy the setter type from bound setter at build-time,
+ *   copying types between files is tricky because of need for adding correct
+ *   imports for anything referenced in that type and not already included in
+ *   current file. Doing so in automated way is quite tricky, slow and
+ *   error-prone.
+ *
+ * Instead, this rule will require developer to explicitly provide the setter
+ * type. Then we can use it as is in the .d.ts file. The getter type can be
+ * retrieved easily via `typeof` operator.
+ */
+export declare const explicitSetterType: ESLintUtils.RuleModule<"explicitSetterType" | "addExplicitSetterType", [], import('../../utils/makePlugin').CommonDocs, ESLintUtils.RuleListener>;

package/dist/plugins/lumina/utils/checker.d.ts

@@ -1,2 +1,4 @@
 import { default as ts } from 'typescript';
 export declare function isLuminaJsxType(type: ts.Type): boolean;
+export declare const hasTypeFlag: (type: ts.Type, flag: ts.TypeFlags) => boolean;
+export declare const literalTypeFlag: number;

package/dist/plugins/webgis/index.js

@@ -1,4 +1,4 @@
-import { m as makeEslintPlugin } from "../../makePlugin-B2kjgMoQ.js";
+import { m as makeEslintPlugin } from "../../makePlugin-DfmxVuno.js";
 import { ESLintUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
 import { resolve } from "node:path/posix";
 const isTestFile = (filePath) => filePath.includes("/test") || filePath.includes(".test") || filePath.includes(".spec") || filePath.includes("e2e") || filePath.includes("__") || filePath.includes("/.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/eslint-config",
-  "version": "4.33.0-next.64",
+  "version": "4.33.0-next.66",
   "description": "ESLint configuration for arcgis-web-components",
   "type": "module",
   "main": "index.js",
@@ -19,7 +19,7 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/components-utils": "4.33.0-next.64",
+    "@arcgis/components-utils": "4.33.0-next.66",
     "@eslint/js": "^9.17.0",
     "@types/confusing-browser-globals": "^1.0.3",
     "confusing-browser-globals": "^1.0.11",