eslint-plugin-use-agnostic 1.7.6 → 1.8.0

package/library/directive21/_commons/utilities/flows.js

@@ -10,7 +10,7 @@ import {
   noCommentedDirectiveMessageId,
   commentedDirectiveVerificationFailedMessageId,
   commentedDirectiveReactDirectiveFailedMessageId,
-  importNotStrategizedMessageId,
+  // importNotStrategizedMessageId,
   cantChainImportAcrossEnvironmentsMessageId,
   skip,
 } from "../../../_commons/constants/bases.js";
@@ -40,7 +40,7 @@ import {
   isImportBlocked,
   makeMessageFromCurrentFileCommentedDirective,
   findSpecificViolationMessage,
-  getStrategizedDirective,
+  // getStrategizedDirective,
   addressDirectiveIfAgnosticStrategies,
 } from "./helpers.js";
 import { analyzeExportsForReExports } from "./analyze-exports-re.js";
@@ -52,12 +52,13 @@ import { analyzeExportsForReExports } from "./analyze-exports-re.js";
  * @typedef {import('../../../../types/directive21/_commons/typedefs.js').ExportNamedDeclaration} ExportNamedDeclaration
  * @typedef {import('../../../../types/directive21/_commons/typedefs.js').ExportAllDeclaration} ExportAllDeclaration
  * @typedef {import('../../../../types/directive21/_commons/typedefs.js').ExportDefaultDeclaration} ExportDefaultDeclaration
+ * @typedef {import('../../../../types/directive21/_commons/typedefs.js').CallExpression} CallExpression
  * @typedef {import('../../../../types/directive21/_commons/typedefs.js').Environment} Environment
  */
 
 /* currentFileFlow */
 
-// copied from eXtra JSX (further proving that all core constants and utilities from eXtra JSX should live inside use-agnostic)
+// copied from eXtra JSX (further proving that all core constants and utilities from eXtra JSX should live inside use-agnostic in v2)
 
 /**
  * @type {readonly [".x.jsx", ".x.cjsx", ".x.mjsx", ".x.tsx", ".x.ctsx", ".x.mtsx"]}
@@ -191,13 +192,12 @@ export const currentFileFlow = (context) => {
     }
 
     // NEW
-    // do not report if the module is a non-Extra JavaScript Agnostic Strategies Module, in order to allow them the freedom of doing whatever they want so they can behave in any which way they need to as convention files
-    if (
-      !(
-        fileIsRegularJavaScript(context.filename) &&
-        verifiedCommentedDirective === USE_AGNOSTIC_STRATEGIES
-      )
-    )
+    const isRegularJavaScriptAgnosticStrategies =
+      fileIsRegularJavaScript(context.filename) &&
+      verifiedCommentedDirective === USE_AGNOSTIC_STRATEGIES;
+
+    // do not report if the module is a non-Extra JavaScript Agnostic Strategies Module, in order to allow them the freedom of doing whatever they want so they can behave in any which way they need to as convention files (JSX extension still required though)
+    if (!isRegularJavaScriptAgnosticStrategies)
       context.report({
         loc: highlightFirstLineOfCode(context),
         messageId: commentedDirectiveReactDirectiveFailedMessageId,
@@ -270,23 +270,29 @@ const importedFileFlow = (context, node) => {
   (Consequently, details below are currently at the stage of wishful thinking.)
   Strategy exports are planned to be linting in the future within their own Agnostic Strategies Modules to ensure they respect import rules within their own scopes. It may also become possible to check whether the export and import Strategies are the same in the future when identifiers are defined and the same, especially for components modules where a convention could be for all non-type exports to be named and PascalCase. */
 
-  if (importedFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
-    const importingFileCommentedDirective = getStrategizedDirective(
-      context,
-      node
-    );
-
-    if (importingFileCommentedDirective === null) {
-      context.report({
-        node,
-        messageId: importNotStrategizedMessageId,
-      });
-      return skipTrue;
-    }
-
-    // FOR NOW, we consider the importingFileCommentedDirective (which is strategized) and the importedFileCommentedDirective (which should be strategized on its own imported file) to be same, given the limitation highlighted above.
-    importedFileCommentedDirective = importingFileCommentedDirective;
-  }
+  // NEW!!
+  // No changes anymore. Agnostic Strategies Modules from now on are going to be considered regularly checked module that simply CANNOT be imported anywhere.
+
+  // if (importedFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
+  //   const importingFileCommentedDirective = getStrategizedDirective(
+  //     context,
+  //     node
+  //   );
+
+  //   if (
+  //     importingFileCommentedDirective === null &&
+  //     fileIsExtraJavaScript(context.filename)
+  //   ) {
+  //     context.report({
+  //       node,
+  //       messageId: importNotStrategizedMessageId,
+  //     });
+  //     return skipTrue;
+  //   }
+
+  //   // FOR NOW, we consider the importingFileCommentedDirective (which is strategized) and the importedFileCommentedDirective (which should be strategized on its own imported file) to be same, given the limitation highlighted above.
+  //   importedFileCommentedDirective = importingFileCommentedDirective;
+  // }
 
   // you never know
   if (!importedFileSourceCode) {
@@ -311,10 +317,120 @@ const importedFileFlow = (context, node) => {
   };
 };
 
+// NEW!! Currently strictly adapted from importedFileFlow
+/**
+ * The `importedFileFlow` adapted for `require` calls to obtain the import file's commented directive.
+ * @param {Context} context The ESLint rule's `context` object.
+ * @param {CallExpression} node The ESLint `node` of the rule's current traversal.
+ * @returns Either an object with `skip: true` to disregard or one with the non-null `importedFileCommentedDirective`. And now with the added results of `analyzeExportsForReExports`.
+ */
+const importedFileFlowRequire = (context, node) => {
+  const skipTrue = {
+    ...skip,
+    importedFileCommentedDirective: undefined,
+    analyzeExportsForReExportsResults: undefined,
+  };
+
+  if (
+    node.callee.type === "Identifier" &&
+    node.callee.name === "require" &&
+    node.arguments.length === 1 &&
+    node.arguments[0].type === "Literal"
+  ) {
+    const importPath = node.arguments[0].value;
+
+    if (typeof importPath !== "string") return skipTrue;
+
+    // finds the full path of the import
+    const resolvedImportPath = resolveImportingPath(
+      path.dirname(context.filename),
+      importPath,
+      findUpSync("tsconfig.json", {
+        cwd: path.dirname(context.filename),
+      }) ?? context.cwd
+    );
+
+    // does not operate on paths it did not resolve
+    if (resolvedImportPath === null) return skipTrue;
+    // does not operate on non-JS files
+    const isImportedFileJS = EXTENSIONS.some((ext) =>
+      resolvedImportPath.endsWith(ext)
+    );
+    if (!isImportedFileJS) return skipTrue;
+
+    // GETTING THE DIRECTIVE (or lack thereof) OF THE IMPORTED FILE
+    let {
+      commentedDirective: importedFileCommentedDirective,
+      sourceCode: importedFileSourceCode,
+    } = getCommentedDirectiveFromImportedModule(resolvedImportPath);
+
+    // returns early if there is no directive or no valid directive (same, but eventually no directive could have defaults)
+    if (!importedFileCommentedDirective) {
+      // Now silencing the warning as superfluous, in order to not warn on imports of files without a commented directive that are outside of linting range.
+
+      // console.warn(
+      //   `WARNING. The imported file ${resolvedImportPath}, whose path has been resolved from ${context.filename}, has no commented directive. It is thus ignored since the report on that circumstance would be available on the imported file itself.`
+      // ); // The decision not to report has been taken to not inflate the number of warnings.
+      return skipTrue;
+    }
+
+    /* GETTING THE CORRECT DIRECTIVE INTERPRETATION OF STRATEGY FOR AGNOSTIC STRATEGIES MODULES IMPORTS. 
+  The Directive-First Architecture does not check whether the export and import Strategies are the same at this time, meaning an @clientLogics strategy could be wrongly imported and interpreted as an @serverLogics strategy.
+  
+  After a short attempt, the feature to address this (crossingStrategies) is currently canceled, mainly due to the exponential complexity provided by the different ways in which exports can be made in JavaScript.
+  
+  (Consequently, details below are currently at the stage of wishful thinking.)
+  Strategy exports are planned to be linting in the future within their own Agnostic Strategies Modules to ensure they respect import rules within their own scopes. It may also become possible to check whether the export and import Strategies are the same in the future when identifiers are defined and the same, especially for components modules where a convention could be for all non-type exports to be named and PascalCase. */
+
+    // if (importedFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
+    //   const importingFileCommentedDirective = getStrategizedDirective(
+    //     context,
+    //     node
+    //   );
+
+    //   if (
+    //     importingFileCommentedDirective === null &&
+    //     fileIsExtraJavaScript(context.filename)
+    //   ) {
+    //     context.report({
+    //       node,
+    //       messageId: importNotStrategizedMessageId,
+    //     });
+    //     return skipTrue;
+    //   }
+
+    //   // FOR NOW, we consider the importingFileCommentedDirective (which is strategized) and the importedFileCommentedDirective (which should be strategized on its own imported file) to be same, given the limitation highlighted above.
+    //   importedFileCommentedDirective = importingFileCommentedDirective;
+    // }
+
+    // you never know
+    if (!importedFileSourceCode) {
+      console.warn(
+        `Somehow, file "${resolvedImportPath}" does not have a SourceCode object obtainable.`
+      );
+      return {
+        skip: undefined,
+        importedFileCommentedDirective,
+        analyzeExportsForReExportsResults: undefined,
+      };
+    }
+
+    const analyzeExportsForReExportsResults = analyzeExportsForReExports(
+      importedFileSourceCode
+    );
+
+    return {
+      skip: undefined,
+      importedFileCommentedDirective,
+      analyzeExportsForReExportsResults,
+    };
+  } else return skipTrue;
+};
+
 /* importsFlow */
 
 /**
- * The full flow for import traversals to enforce effective directives import rules.
+ * The full flow for import traversals to enforce commented directives import rules.
  * @param {Context} context The ESLint rule's `context` object.
  * @param {ImportDeclaration} node The ESLint `node` of the rule's current traversal.
  * @param {CommentedDirective} currentFileCommentedDirective The current file's commented directive.
@@ -329,8 +445,84 @@ export const importsFlow = (context, node, currentFileCommentedDirective) => {
   if (result.skip) return;
   const { importedFileCommentedDirective } = result;
 
-  // returns early is the current file is an Agnostic Strategies Module
-  if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) return;
+  // returns early is the current file is an Agnostic Strategies Module // not anymore
+  // if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) return;
+
+  if (
+    isImportBlocked(
+      currentFileCommentedDirective,
+      importedFileCommentedDirective
+    )
+  ) {
+    context.report({
+      node,
+      messageId: importBreaksCommentedImportRulesMessageId,
+      data: {
+        [commentedDirectiveMessage]:
+          makeMessageFromCurrentFileCommentedDirective(
+            currentFileCommentedDirective
+          ),
+        [specificViolationMessage]: findSpecificViolationMessage(
+          currentFileCommentedDirective,
+          importedFileCommentedDirective
+        ),
+      },
+    });
+  }
+
+  if (result.analyzeExportsForReExportsResults) {
+    const { reExportsWithSource, reExportsViaLocal } =
+      result.analyzeExportsForReExportsResults;
+
+    // immediately returns if no re-exports are found
+    if (reExportsWithSource.length === 0 && reExportsViaLocal.length === 0)
+      return;
+
+    /** @type {Environment} */
+    const currentFileEnvironment = currentFileCommentedDirective.split(" ")[1];
+    /** @type {Environment} */
+    const importedFileEnvironment =
+      importedFileCommentedDirective.split(" ")[1];
+
+    if (
+      !environments_allowedChainImportEnvironments[
+        currentFileEnvironment
+      ].includes(importedFileEnvironment)
+    ) {
+      context.report({
+        node,
+        messageId: cantChainImportAcrossEnvironmentsMessageId,
+        data: {
+          // currentFileEnvironment:
+          currentFileEnvironment,
+          // importedFileEnvironment:
+          importedFileEnvironment,
+        },
+      });
+    }
+  }
+};
+
+// NEW!! Currently strictly adapted from importsFlow
+/**
+ * The `importsFlow` adapted for `require` calls to enforce commented directives import rules.
+ * @param {Context} context The ESLint rule's `context` object.
+ * @param {CallExpression} node The ESLint `node` of the rule's current traversal.
+ * @param {CommentedDirective} currentFileCommentedDirective The current file's commented directive.
+ * @returns Early if the flow needs to be interrupted.
+ */
+export const importsFlowRequire = (
+  context,
+  node,
+  currentFileCommentedDirective
+) => {
+  const result = importedFileFlowRequire(context, node);
+
+  if (result.skip) return;
+  const { importedFileCommentedDirective } = result;
+
+  // returns early is the current file is an Agnostic Strategies Module // not anymore
+  // if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) return;
 
   if (
     isImportBlocked(
@@ -354,7 +546,6 @@ export const importsFlow = (context, node, currentFileCommentedDirective) => {
     });
   }
 
-  // NEW
   if (result.analyzeExportsForReExportsResults) {
     const { reExportsWithSource, reExportsViaLocal } =
       result.analyzeExportsForReExportsResults;

package/library/directive21/_commons/utilities/helpers.js

@@ -1,6 +1,6 @@
 import { getSourceCodeFromFilePath } from "get-sourcecode-from-file-path";
 
-import { exportNotStrategizedMessageId } from "../../../_commons/constants/bases.js";
+// import { exportNotStrategizedMessageId } from "../../../_commons/constants/bases.js";
 import {
   USE_AGNOSTIC_STRATEGIES,
   commentedDirectivesArray,
@@ -245,6 +245,66 @@ export const getStrategizedDirective = (context, node) => {
 
 /* addressDirectiveIfAgnosticStrategies */
 
+// copied from eXtra JSX (further proving that all core constants and utilities from eXtra JSX should live inside use-agnostic in v2)
+
+/**
+ * @type {readonly [".x.jsx", ".x.cjsx", ".x.mjsx", ".x.tsx", ".x.ctsx", ".x.mtsx"]}
+ */
+export const eXtraJsxExtensions = Object.freeze([
+  ".x.jsx",
+  ".x.cjsx",
+  ".x.mjsx",
+  ".x.tsx",
+  ".x.ctsx",
+  ".x.mtsx",
+]);
+
+/**
+ * @type {readonly [".x.js", ".x.cjs", ".x.mjs", ".x.ts", ".x.cts", ".x.mts"]}
+ */
+export const eXtraJsExtensions = Object.freeze([
+  ".x.js",
+  ".x.cjs",
+  ".x.mjs",
+  ".x.ts",
+  ".x.cts",
+  ".x.mts",
+]);
+
+/**
+ * @type {readonly [".x.jsx", ".x.cjsx", ".x.mjsx", ".x.tsx", ".x.ctsx", ".x.mtsx", ".x.js", ".x.cjs", ".x.mjs", ".x.ts", ".x.cts", ".x.mts"]}
+ */
+export const extraJavaScriptExtensions = Object.freeze([
+  ...eXtraJsxExtensions,
+  ...eXtraJsExtensions,
+]);
+
+/**
+ * $COMMENT#JSDOC#CORE#DEFS#FILEISANYJAVASCRIPT
+ * @param {string} filePath $COMMENT#JSDOC#CORE#PARAMS#FILEPATH
+ * @returns $COMMENT#JSDOC#CORE#RETURNS#FILEISANYJAVASCRIPT
+ */
+export const fileIsAnyJavaScript = (filePath) =>
+  EXTENSIONS.some((e) => filePath.endsWith(e));
+
+/**
+ * $COMMENT#JSDOC#CORE#DEFS#FILEISEXTRAJAVASCRIPT
+ * @param {string} filePath $COMMENT#JSDOC#CORE#PARAMS#FILEPATH
+ * @returns $COMMENT#JSDOC#CORE#RETURNS#FILEISEXTRAJAVASCRIPT
+ */
+export const fileIsExtraJavaScript = (filePath) =>
+  extraJavaScriptExtensions.some((e) => filePath.endsWith(e));
+
+/**
+ * $COMMENT#JSDOC#CORE#DEFS#FILEISREGULARJAVASCRIPT
+ * @param {string} filePath $COMMENT#JSDOC#CORE#PARAMS#FILEPATH
+ * @returns $COMMENT#JSDOC#CORE#RETURNS#FILEISREGULARJAVASCRIPT
+ */
+export const fileIsRegularJavaScript = (filePath) =>
+  fileIsAnyJavaScript(filePath) && !fileIsExtraJavaScript(filePath);
+
+//
+
 /**
  * Verifies the current node's export strategy if the current commented directive is `"use agnostic strategies"` by reporting `exportNotStrategized` in case an export is not strategized in an Agnostic Strategies Module.
  * @param {Context} context The ESLint rule's `context` object.
@@ -263,12 +323,20 @@ export const addressDirectiveIfAgnosticStrategies = (
 
   const exportStrategizedDirective = getStrategizedDirective(context, node);
 
-  if (exportStrategizedDirective === null) {
-    context.report({
-      node,
-      messageId: exportNotStrategizedMessageId,
-    });
-  }
+  // NEW!!
+  // Now entirely neutralized. Agnostic Strategies Modules are now going to be vetted module just like the others from now on.
+  // BUT!!
+  // Still acknowledges ongoing strategies since they are indeed still acknowledged, though in a unreliable way, by the eXtra JSX's TypeScript server plugin.
+
+  // if (
+  //   exportStrategizedDirective === null &&
+  //   fileIsExtraJavaScript(context.filename)
+  // ) {
+  //   context.report({
+  //     node,
+  //     messageId: exportNotStrategizedMessageId,
+  //   });
+  // }
 
   return exportStrategizedDirective; // null indicates failure
 };
@@ -277,8 +345,8 @@ export const addressDirectiveIfAgnosticStrategies = (
 
 /**
  * Returns a boolean deciding if an imported file's commented directive is incompatible with the current file's commented directive.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} currentFileCommentedDirective The current file's commented directive.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} importedFileCommentedDirective The imported file's commented directive.
+ * @param {CommentedDirective} currentFileCommentedDirective The current file's commented directive.
+ * @param {CommentedDirective} importedFileCommentedDirective The imported file's commented directive.
  * @returns `true` if the import is blocked, as established in `commentedDirectives_BlockedImports`.
  */
 export const isImportBlocked = (
@@ -310,8 +378,8 @@ export const makeMessageFromCurrentFileCommentedDirective = (
 
 /**
  * Finds the `message` for the specific violation of commented directives import rules based on `commentedDirectives_BlockedImports`.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} currentFileCommentedDirective The current file's commented directive.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} importedFileCommentedDirective The imported file's commented directive.
+ * @param {CommentedDirective} currentFileCommentedDirective The current file's commented directive.
+ * @param {CommentedDirective} importedFileCommentedDirective The imported file's commented directive.
  * @returns The corresponding `message`.
  */
 export const findSpecificViolationMessage = (

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-use-agnostic",
-  "version": "1.7.6",
+  "version": "1.8.0",
   "description": "Highlights problematic server-client imports in projects made with the Fullstack React Architecture.",
   "keywords": [
     "eslint",