eslint-plugin-absolute 0.11.0-beta.1 → 0.11.0-beta.3

package/dist/index.js

@@ -3653,6 +3653,20 @@ var noRedundantTypeAnnotation = createRule({
       return {};
     }
     const stringify = (type) => tsChecker.typeToString(type, undefined, ts2.TypeFormatFlags.NoTruncation | ts2.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+    const referencesTypeParam = (typeNode, name) => {
+      let found = false;
+      const visit = (node) => {
+        if (found)
+          return;
+        if (ts2.isTypeReferenceNode(node) && ts2.isIdentifier(node.typeName) && node.typeName.text === name) {
+          found = true;
+          return;
+        }
+        ts2.forEachChild(node, visit);
+      };
+      visit(typeNode);
+      return found;
+    };
     const leansOnContextualInference = (initNode) => {
       const callLike = ts2.isCallExpression(initNode) || ts2.isNewExpression(initNode) ? initNode : null;
       if (!callLike)
@@ -3660,6 +3674,14 @@ var noRedundantTypeAnnotation = createRule({
       if (callLike.typeArguments && callLike.typeArguments.length > 0) {
         return false;
       }
+      const resolved = tsChecker.getResolvedSignature(callLike);
+      const declaration = resolved?.declaration;
+      if (declaration && !ts2.isJSDocSignature(declaration)) {
+        const typeParams = declaration.typeParameters;
+        if (!typeParams || typeParams.length === 0)
+          return false;
+        return typeParams.some((typeParam) => !declaration.parameters.some((parameter) => parameter.type !== undefined && referencesTypeParam(parameter.type, typeParam.name.text)));
+      }
       const calleeType = tsChecker.getTypeAtLocation(callLike.expression);
       const signatures = ts2.isNewExpression(callLike) ? calleeType.getConstructSignatures() : calleeType.getCallSignatures();
       return signatures.some((signature) => (signature.getTypeParameters()?.length ?? 0) > 0);
@@ -3722,6 +3744,65 @@ var noRedundantTypeAnnotation = createRule({
   name: "no-redundant-type-annotation"
 });
 
+// src/rules/no-import-meta-path.ts
+var FILESYSTEM_PATH_PROPERTIES = new Set(["dir", "dirname", "filename"]);
+var isImportMeta = (node) => node.type === "MetaProperty" && node.meta.name === "import" && node.property.name === "meta";
+var importMetaProperty = (node) => {
+  if (!isImportMeta(node.object))
+    return null;
+  if (node.computed || node.property.type !== "Identifier")
+    return null;
+  return node.property.name;
+};
+var calleeName = (callee) => {
+  if (callee.type === "Identifier")
+    return callee.name;
+  if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+    return callee.property.name;
+  }
+  return null;
+};
+var noImportMetaPath = createRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (calleeName(node.callee) !== "fileURLToPath")
+          return;
+        const urlArgument = node.arguments.find((argument) => argument.type === "MemberExpression" && importMetaProperty(argument) === "url");
+        if (urlArgument) {
+          context.report({
+            messageId: "importMetaUrl",
+            node: urlArgument
+          });
+        }
+      },
+      MemberExpression(node) {
+        const property = importMetaProperty(node);
+        if (property && FILESYSTEM_PATH_PROPERTIES.has(property)) {
+          context.report({
+            data: { property },
+            messageId: "importMetaPath",
+            node
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow deriving filesystem paths from a module's own location (`import.meta.dir`/`dirname`/`filename`, `fileURLToPath(import.meta.url)`). They move when the server is bundled, so paths break in `absolute start`. Anchor to `projectRoot` from @absolutejs/absolute or `process.cwd()`."
+    },
+    messages: {
+      importMetaPath: "`import.meta.{{property}}` resolves this module's own location, which is your src/ tree in `absolute dev` but the bundled dist/ in `absolute start` \u2014 module-relative paths silently break in production. Anchor runtime/data paths to `projectRoot` from @absolutejs/absolute (or `process.cwd()`).",
+      importMetaUrl: "`fileURLToPath(import.meta.url)` derives a filesystem path from this module's own location, which moves when the server is bundled (src/ in `absolute dev`, dist/ in `absolute start`) \u2014 so the path silently breaks in production. Anchor runtime/data paths to `projectRoot` from @absolutejs/absolute (or `process.cwd()`)."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-import-meta-path"
+});
+
 // src/rules/no-trivial-alias.ts
 var isBareTypeReference = (node) => {
   if (node.type === "TSTypeReference") {
@@ -3973,6 +4054,7 @@ var src_default = {
     "min-var-length": minVarLength,
     "no-button-navigation": noButtonNavigation,
     "no-explicit-return-type": noExplicitReturnTypes,
+    "no-import-meta-path": noImportMetaPath,
     "no-inline-object-types": noInlineObjectTypes,
     "no-multi-style-objects": noMultiStyleObjects,
     "no-nested-jsx-return": noNestedJSXReturn,

package/package.json

@@ -40,5 +40,5 @@
 		"typecheck": "bun run tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.11.0-beta.1"
+	"version": "0.11.0-beta.3"
 }