@cedarjs/eslint-plugin 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/cell-type-annotations.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare const cellTypeAnnotations: TSESLint.RuleModule<"needsTypeAnnotation" | "beforeQueryParamNeedsType", [], unknown, TSESLint.RuleListener>;
+//# sourceMappingURL=cell-type-annotations.d.ts.map

package/dist/cell-type-annotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell-type-annotations.d.ts","sourceRoot":"","sources":["../src/cell-type-annotations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAA;AAwHlE,eAAO,MAAM,mBAAmB,8GAiZ9B,CAAA"}

package/dist/cell-type-annotations.js

@@ -0,0 +1,348 @@
+import { basename } from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+const LIFECYCLE_EXPORTS = /* @__PURE__ */ new Set(["beforeQuery", "afterQuery", "isEmpty"]);
+const RENDER_PROP_EXPORTS = /* @__PURE__ */ new Set(["Loading", "Failure", "Success"]);
+function getParamPattern(param) {
+  return param.type === AST_NODE_TYPES.AssignmentPattern ? param.left : param;
+}
+function paramHasTypeAnnotation(param) {
+  const pattern = getParamPattern(param);
+  return "typeAnnotation" in pattern && !!pattern.typeAnnotation;
+}
+function getParamsClosingParen(sourceCode, fn) {
+  if (fn.params.length > 0) {
+    const lastParam = fn.params[fn.params.length - 1];
+    return sourceCode.getTokenAfter(lastParam, (token) => token.value === ")");
+  }
+  return sourceCode.getFirstToken(fn, (token) => token.value === ")");
+}
+function isUnparenthesizedArrowParam(fn, param, sourceCode) {
+  if (fn.type !== AST_NODE_TYPES.ArrowFunctionExpression) {
+    return false;
+  }
+  if (fn.params.length !== 1 || fn.params[0] !== param) {
+    return false;
+  }
+  return sourceCode.getTokenBefore(param)?.value !== "(";
+}
+function* insertWrappedAnnotations(fixer, param, paramTypeText, returnTypeText) {
+  yield fixer.insertTextBefore(param, "(");
+  const paramPart = paramTypeText ? `: ${paramTypeText}` : "";
+  const returnPart = returnTypeText ? `: ${returnTypeText}` : "";
+  yield fixer.insertTextAfter(param, `${paramPart})${returnPart}`);
+}
+function extractTypedDocumentNodeArgs(typeAnnotation, sourceCode) {
+  const type = typeAnnotation?.typeAnnotation;
+  if (type?.type !== AST_NODE_TYPES.TSTypeReference) {
+    return null;
+  }
+  if (type.typeName.type !== AST_NODE_TYPES.Identifier || type.typeName.name !== "TypedDocumentNode") {
+    return null;
+  }
+  const args = type.typeArguments?.params;
+  if (!args || args.length < 2) {
+    return null;
+  }
+  return {
+    data: sourceCode.getText(args[0]),
+    variables: sourceCode.getText(args[1])
+  };
+}
+function isImportSpecifier(specifier) {
+  return specifier.type === AST_NODE_TYPES.ImportSpecifier;
+}
+const cellTypeAnnotations = createRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Sets the types on a Cell file's lifecycle hooks and render props to the correct @cedarjs/web Cell types"
+    },
+    messages: {
+      needsTypeAnnotation: "The `{{name}}` {{kind}} needs a type annotation of `{{typeName}}` ({{location}}).",
+      beforeQueryParamNeedsType: "`beforeQuery`'s first parameter needs a type annotation. Cedar infers the Cell's external props from it, so leaving it untyped degrades type checking at every call site of this Cell."
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const filename = basename(context.filename);
+    const filenameIndicatesCell = filename.endsWith("Cell.tsx");
+    let hasQueryOrFragment = false;
+    let hasSuccessExport = false;
+    let derivedQueryTypes = null;
+    let webTypeImport = null;
+    const importedWebTypeNames = /* @__PURE__ */ new Set();
+    const checks = [];
+    const claimedImportNames = /* @__PURE__ */ new Set();
+    function needsImportEdit(importName) {
+      if (!importName) {
+        return false;
+      }
+      if (importedWebTypeNames.has(importName)) {
+        return false;
+      }
+      if (claimedImportNames.has(importName)) {
+        return false;
+      }
+      claimedImportNames.add(importName);
+      return true;
+    }
+    function* importEdit(fixer, importName) {
+      const specifiers = webTypeImport?.specifiers.filter(isImportSpecifier) ?? [];
+      const lastSpecifier = specifiers[specifiers.length - 1];
+      if (lastSpecifier) {
+        yield fixer.insertTextAfter(lastSpecifier, `, ${importName}`);
+        return;
+      }
+      yield fixer.insertTextBeforeRange(
+        [0, 0],
+        `import type { ${importName} } from '@cedarjs/web'
+`
+      );
+    }
+    function checkBeforeQuery(fn, reportNode) {
+      const variablesType = derivedQueryTypes?.variables ?? "Record<string, unknown>";
+      if (!fn.returnType) {
+        const typeName = `CellBeforeQueryResult<${variablesType}>`;
+        const shouldImport = needsImportEdit("CellBeforeQueryResult");
+        context.report({
+          node: reportNode,
+          messageId: "needsTypeAnnotation",
+          data: {
+            name: "beforeQuery",
+            typeName,
+            kind: "function",
+            location: "return type"
+          },
+          *fix(fixer) {
+            const [firstParam2] = fn.params;
+            if (firstParam2 && isUnparenthesizedArrowParam(fn, firstParam2, sourceCode)) {
+              yield* insertWrappedAnnotations(fixer, firstParam2, null, typeName);
+            } else {
+              const closingParen = getParamsClosingParen(sourceCode, fn);
+              if (!closingParen) {
+                return;
+              }
+              yield fixer.insertTextAfter(closingParen, `: ${typeName}`);
+            }
+            if (shouldImport) {
+              yield* importEdit(fixer, "CellBeforeQueryResult");
+            }
+          }
+        });
+      }
+      const firstParam = fn.params[0];
+      if (firstParam && !paramHasTypeAnnotation(firstParam)) {
+        context.report({
+          node: reportNode,
+          messageId: "beforeQueryParamNeedsType"
+        });
+      }
+    }
+    function checkAfterQuery(fn, reportNode) {
+      const firstParam = fn.params[0];
+      const missingParam = !!firstParam && !paramHasTypeAnnotation(firstParam);
+      if (!missingParam) {
+        return;
+      }
+      const shouldImport = needsImportEdit("DataObject");
+      context.report({
+        node: reportNode,
+        messageId: "needsTypeAnnotation",
+        data: {
+          name: "afterQuery",
+          typeName: "DataObject",
+          kind: "function",
+          location: "parameter"
+        },
+        *fix(fixer) {
+          if (firstParam && isUnparenthesizedArrowParam(fn, firstParam, sourceCode)) {
+            yield* insertWrappedAnnotations(
+              fixer,
+              firstParam,
+              "DataObject",
+              null
+            );
+          } else if (firstParam) {
+            yield fixer.insertTextAfter(
+              getParamPattern(firstParam),
+              ": DataObject"
+            );
+          }
+          if (shouldImport) {
+            yield* importEdit(fixer, "DataObject");
+          }
+        }
+      });
+    }
+    function checkIsEmpty(fn, reportNode) {
+      const [responseParam, optionsParam] = fn.params;
+      const missingResponseType = !!responseParam && !paramHasTypeAnnotation(responseParam);
+      const missingOptionsType = !!optionsParam && !paramHasTypeAnnotation(optionsParam);
+      if (!missingResponseType && !missingOptionsType) {
+        return;
+      }
+      const shouldImport = needsImportEdit("DataObject");
+      context.report({
+        node: reportNode,
+        messageId: "needsTypeAnnotation",
+        data: {
+          name: "isEmpty",
+          typeName: "DataObject",
+          kind: "function",
+          location: "parameters"
+        },
+        *fix(fixer) {
+          if (responseParam && isUnparenthesizedArrowParam(fn, responseParam, sourceCode)) {
+            yield* insertWrappedAnnotations(
+              fixer,
+              responseParam,
+              missingResponseType ? "DataObject" : null,
+              null
+            );
+          } else {
+            if (missingResponseType && responseParam) {
+              yield fixer.insertTextAfter(
+                getParamPattern(responseParam),
+                ": DataObject"
+              );
+            }
+            if (missingOptionsType && optionsParam) {
+              yield fixer.insertTextAfter(
+                getParamPattern(optionsParam),
+                ": { isDataEmpty: (data: DataObject) => boolean }"
+              );
+            }
+          }
+          if (shouldImport) {
+            yield* importEdit(fixer, "DataObject");
+          }
+        }
+      });
+    }
+    function checkRenderProp(name, fn, reportNode) {
+      const [propsParam] = fn.params;
+      if (!propsParam || paramHasTypeAnnotation(propsParam)) {
+        return;
+      }
+      const variablesType = derivedQueryTypes?.variables;
+      let insertText;
+      if (name === "Success") {
+        insertText = derivedQueryTypes ? `CellSuccessProps<${derivedQueryTypes.data}, ${derivedQueryTypes.variables}>` : "CellSuccessProps";
+      } else if (name === "Failure") {
+        insertText = variablesType ? `CellFailureProps<${variablesType}>` : "CellFailureProps";
+      } else {
+        insertText = variablesType ? `CellLoadingProps<${variablesType}>` : "CellLoadingProps";
+      }
+      const importName = `Cell${name}Props`;
+      const shouldImport = needsImportEdit(importName);
+      context.report({
+        node: reportNode,
+        messageId: "needsTypeAnnotation",
+        data: {
+          name,
+          typeName: insertText,
+          kind: "component",
+          location: "parameter"
+        },
+        *fix(fixer) {
+          if (isUnparenthesizedArrowParam(fn, propsParam, sourceCode)) {
+            yield* insertWrappedAnnotations(fixer, propsParam, insertText, null);
+          } else {
+            yield fixer.insertTextAfter(
+              getParamPattern(propsParam),
+              `: ${insertText}`
+            );
+          }
+          if (shouldImport) {
+            yield* importEdit(fixer, importName);
+          }
+        }
+      });
+    }
+    function checkExport(name, fn, reportNode) {
+      if (name === "beforeQuery") {
+        checkBeforeQuery(fn, reportNode);
+      } else if (name === "afterQuery") {
+        checkAfterQuery(fn, reportNode);
+      } else if (name === "isEmpty") {
+        checkIsEmpty(fn, reportNode);
+      } else if (RENDER_PROP_EXPORTS.has(name)) {
+        checkRenderProp(name, fn, reportNode);
+      }
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== "@cedarjs/web") {
+          return;
+        }
+        if (node.importKind === "type") {
+          webTypeImport = node;
+        }
+        node.specifiers.filter(isImportSpecifier).forEach((specifier) => {
+          if (node.importKind === "type" || specifier.importKind === "type") {
+            importedWebTypeNames.add(specifier.local.name);
+          }
+        });
+      },
+      ExportNamedDeclaration(node) {
+        if (node.declaration?.type === AST_NODE_TYPES.FunctionDeclaration) {
+          const fn = node.declaration;
+          const idNode = fn.id;
+          if (!idNode) {
+            return;
+          }
+          const name = idNode.name;
+          if (name === "Success") {
+            hasSuccessExport = true;
+          }
+          if (LIFECYCLE_EXPORTS.has(name) || RENDER_PROP_EXPORTS.has(name)) {
+            checks.push(() => checkExport(name, fn, idNode));
+          }
+          return;
+        }
+        if (node.declaration?.type !== AST_NODE_TYPES.VariableDeclaration) {
+          return;
+        }
+        node.declaration.declarations.forEach((vd) => {
+          if (vd.type !== AST_NODE_TYPES.VariableDeclarator || vd.id.type !== AST_NODE_TYPES.Identifier) {
+            return;
+          }
+          const name = vd.id.name;
+          if (name === "QUERY") {
+            derivedQueryTypes ||= extractTypedDocumentNodeArgs(
+              vd.id.typeAnnotation,
+              sourceCode
+            );
+            hasQueryOrFragment = true;
+            return;
+          }
+          if (name === "FRAGMENT") {
+            hasQueryOrFragment = true;
+            return;
+          }
+          if (name === "Success") {
+            hasSuccessExport = true;
+          }
+          if ((LIFECYCLE_EXPORTS.has(name) || RENDER_PROP_EXPORTS.has(name)) && (vd.init?.type === AST_NODE_TYPES.ArrowFunctionExpression || vd.init?.type === AST_NODE_TYPES.FunctionExpression)) {
+            const fn = vd.init;
+            checks.push(() => checkExport(name, fn, vd.id));
+          }
+        });
+      },
+      "Program:exit"() {
+        const isCellFile = filenameIndicatesCell && hasQueryOrFragment && hasSuccessExport;
+        if (!isCellFile) {
+          return;
+        }
+        checks.forEach((check) => check());
+      }
+    };
+  }
+});
+export {
+  cellTypeAnnotations
+};

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import type { ESLintUtils } from '@typescript-eslint/utils';
 export declare const meta: {
     name: string;
-    version: any;
+    version: string;
 };
 export declare const rules: {
+    'cell-type-annotations': ESLintUtils.RuleModule<"needsTypeAnnotation" | "beforeQueryParamNeedsType", [], unknown, ESLintUtils.RuleListener>;
     'process-env-computed': ESLintUtils.RuleModule<"unexpected", [], unknown, ESLintUtils.RuleListener>;
     'service-type-annotations': ESLintUtils.RuleModule<"needsType", [], unknown, ESLintUtils.RuleListener>;
     'unsupported-route-components': ESLintUtils.RuleModule<"unexpected", [], unknown, ESLintUtils.RuleListener>;
@@ -11,9 +12,10 @@ export declare const rules: {
 declare const plugin: {
     meta: {
         name: string;
-        version: any;
+        version: string;
     };
     rules: {
+        'cell-type-annotations': ESLintUtils.RuleModule<"needsTypeAnnotation" | "beforeQueryParamNeedsType", [], unknown, ESLintUtils.RuleListener>;
         'process-env-computed': ESLintUtils.RuleModule<"unexpected", [], unknown, ESLintUtils.RuleListener>;
         'service-type-annotations': ESLintUtils.RuleModule<"needsType", [], unknown, ESLintUtils.RuleListener>;
         'unsupported-route-components': ESLintUtils.RuleModule<"unexpected", [], unknown, ESLintUtils.RuleListener>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAM3D,eAAO,MAAM,IAAI;;;CAGhB,CAAA;AAED,eAAO,MAAM,KAAK;;;;CAIwC,CAAA;AAE1D,QAAA,MAAM,MAAM;;;;;;;;;;CAAkB,CAAA;AAE9B,eAAe,MAAM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAS3D,eAAO,MAAM,IAAI;;;CAGhB,CAAA;AAED,eAAO,MAAM,KAAK;;;;;CAKwC,CAAA;AAE1D,QAAA,MAAM,MAAM;;;;;;;;;;;CAAkB,CAAA;AAE9B,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -1,44 +1,22 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-__export(src_exports, {
-  default: () => src_default,
-  meta: () => meta,
-  rules: () => rules
-});
-module.exports = __toCommonJS(src_exports);
-var import_process_env_computed = require("./process-env-computed.js");
-var import_service_type_annotations = require("./service-type-annotations.js");
-var import_unsupported_route_components = require("./unsupported-route-components.js");
+import pkgJson from "../package.json" with { type: "json" };
+import { cellTypeAnnotations } from "./cell-type-annotations.js";
+import { processEnvComputedRule } from "./process-env-computed.js";
+import { serviceTypeAnnotations } from "./service-type-annotations.js";
+import { unsupportedRouteComponents } from "./unsupported-route-components.js";
 const meta = {
   name: "@cedarjs/eslint-plugin",
-  version: require("../package.json").version
+  version: pkgJson.version
 };
 const rules = {
-  "process-env-computed": import_process_env_computed.processEnvComputedRule,
-  "service-type-annotations": import_service_type_annotations.serviceTypeAnnotations,
-  "unsupported-route-components": import_unsupported_route_components.unsupportedRouteComponents
+  "cell-type-annotations": cellTypeAnnotations,
+  "process-env-computed": processEnvComputedRule,
+  "service-type-annotations": serviceTypeAnnotations,
+  "unsupported-route-components": unsupportedRouteComponents
 };
 const plugin = { meta, rules };
-var src_default = plugin;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+var index_default = plugin;
+export {
+  index_default as default,
   meta,
   rules
-});
+};

package/dist/process-env-computed.js

@@ -1,33 +1,10 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var process_env_computed_exports = {};
-__export(process_env_computed_exports, {
-  processEnvComputedRule: () => processEnvComputedRule
-});
-module.exports = __toCommonJS(process_env_computed_exports);
-var import_utils = require("@typescript-eslint/utils");
-const createRule = import_utils.ESLintUtils.RuleCreator.withoutDocs;
+import { ESLintUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
 function isProcessEnv(node) {
-  return node.type === import_utils.AST_NODE_TYPES.MemberExpression && hasName(node.object, "process") && hasName(node.property, "env");
+  return node.type === AST_NODE_TYPES.MemberExpression && hasName(node.object, "process") && hasName(node.property, "env");
 }
 function hasName(node, name) {
-  return node.type === import_utils.AST_NODE_TYPES.Identifier && node.name === name;
+  return node.type === AST_NODE_TYPES.Identifier && node.name === name;
 }
 function isTestFile(filename) {
   return filename.endsWith(".test.ts") || filename.endsWith(".test.js") || filename.endsWith(".test.tsx") || filename.endsWith(".test.jsx") || filename.endsWith(".test.mts") || filename.endsWith(".test.mjs") || filename.endsWith(".test.cjs") || filename.endsWith(".spec.ts") || filename.endsWith(".spec.js") || filename.endsWith(".spec.tsx") || filename.endsWith(".spec.jsx") || filename.endsWith(".spec.mts") || filename.endsWith(".spec.mjs") || filename.endsWith(".spec.cjs") || filename.includes("/__tests__/");
@@ -59,7 +36,6 @@ const processEnvComputedRule = createRule({
     };
   }
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   processEnvComputedRule
-});
+};

package/dist/service-type-annotations.js

@@ -1,29 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var service_type_annotations_exports = {};
-__export(service_type_annotations_exports, {
-  serviceTypeAnnotations: () => serviceTypeAnnotations
-});
-module.exports = __toCommonJS(service_type_annotations_exports);
-var import_node_path = require("node:path");
-var import_utils = require("@typescript-eslint/utils");
-const createRule = import_utils.ESLintUtils.RuleCreator.withoutDocs;
+import { basename } from "node:path";
+import { ESLintUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
 const capitalizeFirstLetter = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 const serviceTypeAnnotations = createRule({
   meta: {
@@ -39,7 +16,7 @@ const serviceTypeAnnotations = createRule({
   },
   defaultOptions: [],
   create(context) {
-    const thisFilename = (0, import_node_path.basename)(context.filename);
+    const thisFilename = basename(context.filename);
     const sansTS = thisFilename.replace(".ts", "");
     const thisFileCorrespondingImport = `types/${sansTS}`;
     let importForThisFile = null;
@@ -51,18 +28,18 @@ const serviceTypeAnnotations = createRule({
       },
       // Then start looking at every exported fn/const
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type !== import_utils.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type !== AST_NODE_TYPES.VariableDeclaration) {
           return;
         }
         node.declaration.declarations.forEach((vd) => {
-          if (vd.type === import_utils.AST_NODE_TYPES.VariableDeclarator && vd.id.type === import_utils.AST_NODE_TYPES.Identifier) {
+          if (vd.type === AST_NODE_TYPES.VariableDeclarator && vd.id.type === AST_NODE_TYPES.Identifier) {
             if (vd.id.name.startsWith("_")) {
               return;
             }
             const isGlobalOrMutationResolver = /^[a-z]/.test(vd.id.name);
             const suffix = isGlobalOrMutationResolver ? "Resolver" : "TypeResolvers";
             const typeName = capitalizeFirstLetter(vd.id.name) + suffix;
-            if (isGlobalOrMutationResolver && vd.init?.type !== import_utils.AST_NODE_TYPES.ArrowFunctionExpression) {
+            if (isGlobalOrMutationResolver && vd.init?.type !== AST_NODE_TYPES.ArrowFunctionExpression) {
               return;
             }
             const tsID = vd.id;
@@ -98,7 +75,7 @@ const serviceTypeAnnotations = createRule({
               if (!("typeName" in type)) {
                 return;
               }
-              const isCorrectType = type.typeName?.type === import_utils.AST_NODE_TYPES.Identifier && type.typeName?.name === typeName;
+              const isCorrectType = type.typeName?.type === AST_NODE_TYPES.Identifier && type.typeName?.name === typeName;
               if (isCorrectType) {
                 return;
               }
@@ -134,7 +111,6 @@ const serviceTypeAnnotations = createRule({
     };
   }
 });
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   serviceTypeAnnotations
-});
+};

package/dist/unsupported-route-components.js

@@ -1,35 +1,12 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var unsupported_route_components_exports = {};
-__export(unsupported_route_components_exports, {
-  unsupportedRouteComponents: () => unsupportedRouteComponents
-});
-module.exports = __toCommonJS(unsupported_route_components_exports);
-var import_utils = require("@typescript-eslint/utils");
-const createRule = import_utils.ESLintUtils.RuleCreator.withoutDocs;
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
 function isAllowedElement(name) {
   const allowedElements = ["Router", "Route", "Set", "PrivateSet", "Private"];
   return allowedElements.includes(name);
 }
 function checkNodes(nodesToCheck, context) {
-  if (nodesToCheck.type === import_utils.AST_NODE_TYPES.JSXElement) {
-    const name = nodesToCheck.openingElement.name.type === import_utils.AST_NODE_TYPES.JSXIdentifier ? nodesToCheck.openingElement.name.name : null;
+  if (nodesToCheck.type === AST_NODE_TYPES.JSXElement) {
+    const name = nodesToCheck.openingElement.name.type === AST_NODE_TYPES.JSXIdentifier ? nodesToCheck.openingElement.name.name : null;
     if (name && !isAllowedElement(name)) {
       context.report({
         node: nodesToCheck,
@@ -59,11 +36,11 @@ const unsupportedRouteComponents = createRule({
       VariableDeclaration(node) {
         if (isRoutesRenderBlock(node.declarations[0])) {
           const routesDeclaration = node.declarations[0].init;
-          if (routesDeclaration?.type === import_utils.AST_NODE_TYPES.ArrowFunctionExpression) {
-            if (routesDeclaration.body.type === import_utils.AST_NODE_TYPES.JSXElement) {
+          if (routesDeclaration?.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+            if (routesDeclaration.body.type === AST_NODE_TYPES.JSXElement) {
               checkNodes(routesDeclaration.body, context);
-            } else if (routesDeclaration.body.type === import_utils.AST_NODE_TYPES.BlockStatement) {
-              if (routesDeclaration.body.body[0].type === import_utils.AST_NODE_TYPES.ReturnStatement && routesDeclaration.body.body[0].argument?.type === import_utils.AST_NODE_TYPES.JSXElement) {
+            } else if (routesDeclaration.body.type === AST_NODE_TYPES.BlockStatement) {
+              if (routesDeclaration.body.body[0].type === AST_NODE_TYPES.ReturnStatement && routesDeclaration.body.body[0].argument?.type === AST_NODE_TYPES.JSXElement) {
                 const routesReturnStatement = routesDeclaration.body.body[0].argument;
                 checkNodes(routesReturnStatement, context);
               }
@@ -75,9 +52,8 @@ const unsupportedRouteComponents = createRule({
   }
 });
 function isRoutesRenderBlock(node) {
-  return node?.type === import_utils.AST_NODE_TYPES.VariableDeclarator && node?.id.type === import_utils.AST_NODE_TYPES.Identifier && node?.id.name === "Routes";
+  return node?.type === AST_NODE_TYPES.VariableDeclarator && node?.id.type === AST_NODE_TYPES.Identifier && node?.id.name === "Routes";
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   unsupportedRouteComponents
-});
+};

package/package.json

@@ -1,42 +1,45 @@
 {
   "name": "@cedarjs/eslint-plugin",
-  "version": "9.0.0-canary.1784+baa47810a",
+  "version": "9.0.0-canary.3124",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cedarjs/cedar.git",
     "directory": "packages/eslint-plugin"
   },
   "license": "MIT",
+  "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsx ./build.mts && yarn build:types",
+    "build": "node ./build.mts",
     "build:pack": "yarn pack -o cedarjs-eslint-plugin.tgz",
-    "build:types": "tsc --build --verbose",
+    "build:types": "tsc --build --verbose ./tsconfig.build.json",
     "build:watch": "nodemon --watch src --ext \"js,jsx,ts,tsx\" --ignore dist --exec \"yarn build\"",
     "prepublishOnly": "NODE_ENV=production yarn build",
     "test": "vitest run",
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "8.54.0",
+    "@typescript-eslint/utils": "8.69.0",
     "eslint": "8.57.1"
   },
   "devDependencies": {
-    "@cedarjs/framework-tools": "9.0.0-canary.1784",
+    "@cedarjs/framework-tools": "9.0.0-canary.3124",
     "@types/eslint": "8.56.12",
-    "@types/estree": "1.0.8",
-    "@typescript-eslint/parser": "8.54.0",
-    "@typescript-eslint/rule-tester": "8.54.0",
-    "tsx": "4.21.0",
+    "@types/estree": "1.0.9",
+    "@typescript-eslint/parser": "8.69.0",
+    "@typescript-eslint/rule-tester": "8.69.0",
     "typescript": "5.9.3",
-    "vitest": "3.2.4"
+    "vitest": "4.1.11"
+  },
+  "engines": {
+    "node": ">=24"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "baa47810a7defb73de27fdf513b815d679509b5e"
+  "gitHead": "3905ed045508b861b495f8d5630d76c7a157d8f1"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Cedar
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.