eslint-plugin-use-agnostic 1.7.5 → 1.7.9

package/jscomments/jsdoc/alias-variables.js

@@ -1,6 +1,12 @@
 export const forAliasVariables = Object.freeze({
   importsFlow:
     "The full flow for import traversals to enforce effective directives import rules." /* $COMMENT#JSDOC#FORALIASVARIABLES#IMPORTSFLOW */,
+  importsFlowRequire:
+    "The `importsFlow` adapted for `require` calls to enforce effective directives import rules." /* $COMMENT#JSDOC#FORALIASVARIABLES#IMPORTSFLOWREQUIRE */,
+  importsFlowCommented:
+    "The full flow for import traversals to enforce commented directives import rules." /* $COMMENT#JSDOC#FORALIASVARIABLES#IMPORTSFLOWCOMMENTED */,
+  importsFlowCommentedRequire:
+    "The `importsFlow` adapted for `require` calls to enforce commented directives import rules." /* $COMMENT#JSDOC#FORALIASVARIABLES#IMPORTSFLOWCOMMENTEDREQUIRE */,
   flowReturnsEarly:
     "Early if the flow needs to be interrupted." /* $COMMENT#JSDOC#FORALIASVARIABLES#FLOWRETURNSEARLY */,
 });

package/jscomments/jsdoc/comments.js

@@ -15,8 +15,10 @@ export const jsDocComments = Object.freeze({
       "$COMMENT#JSDOC#FORCOMPOSEDVARIABLES#LISTSINMESSAGE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#RESOLVED $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#MODULESINCOMPATIBLE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#RESOLVED $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#MODULEBASEDON $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#RESOLVED $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVEPERIOD" /* $COMMENT#JSDOC#DEFINITIONS#MAKEMESSAGEFROMCURRENTFILERESOLVEDDIRECTIVE */,
     findSpecificViolationMessage:
       "$COMMENT#JSDOC#FORCOMPOSEDVARIABLES#FINDTHEMESSAGE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#RESOLVED $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#RULESBASEDON $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#RDBIPERIOD" /* $COMMENT#JSDOC#DEFINITIONS#FINDSPECIFICVIOLATIONMESSAGE */,
-    walkAST: "Walks an AST with a given callback." /* $COMMENT#JSDOC#DEFINITIONS#WALKAST */,
-    visitNode: "Recursively visits an AST node with a given callback." /* $COMMENT#JSDOC#DEFINITIONS#VISITNODE */,
+    walkAST:
+      "Walks an AST with a given callback." /* $COMMENT#JSDOC#DEFINITIONS#WALKAST */,
+    visitNode:
+      "Recursively visits an AST node with a given callback." /* $COMMENT#JSDOC#DEFINITIONS#VISITNODE */,
     analyzeExportsForReExports:
       "Analyzes a source code's exports to detect re-exports." /* $COMMENT#JSDOC#DEFINITIONS#ANALYZEEXPORTSFORREEXPORTS */,
     agnostic20: Object.freeze({
@@ -44,6 +46,8 @@ export const jsDocComments = Object.freeze({
         "$COMMENT#JSDOC#FORCOMPOSEDVARIABLES#FLOWTHATBEGINS $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#EFFECTIVE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#OFCURRENTFILE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#EFFECTIVE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVES $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#OFFILESITIMPORTS" /* $COMMENT#JSDOC#DEFINITIONS#AGNOSTIC20#CURRENTFILEFLOW */,
       importedFileFlow:
         "$COMMENT#JSDOC#FORCOMPOSEDVARIABLES#FLOWIMPORTREEXPORT $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#EFFECTIVE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVEPERIOD" /* $COMMENT#JSDOC#DEFINITIONS#AGNOSTIC20#IMPORTEDFILEFLOW */,
+      importedFileFlowRequire:
+        "The `importedFileFlow` adapted for `require` calls to obtain the import file's effective directive." /* $COMMENT#JSDOC#DEFINITIONS#AGNOSTIC20#IMPORTEDFILEFLOWREQUIRE */,
       importsFlow:
         "JSDOC#FORALIASVARIABLES#IMPORTSFLOW" /* $COMMENT#JSDOC#DEFINITIONS#AGNOSTIC20#IMPORTSFLOW */,
       reExportsFlow:
@@ -88,6 +92,8 @@ export const jsDocComments = Object.freeze({
         "$COMMENT#JSDOC#FORCOMPOSEDVARIABLES#FLOWTHATBEGINS $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#VERIFIEDCOMMENTED $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#OFCURRENTFILE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#VERIFIEDCOMMENTED $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVES $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#OFFILESITIMPORTS" /* $COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#CURRENTFILEFLOW */,
       importedFileFlow:
         "$COMMENT#JSDOC#FORCOMPOSEDVARIABLES#FLOWIMPORTREEXPORT $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#COMMENTED $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVEPERIOD" /* $COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#IMPORTEDFILEFLOW */,
+      importedFileFlowRequire:
+        "The `importedFileFlow` adapted for `require` calls to obtain the import file's commented directive." /* $COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#IMPORTEDFILEFLOWREQUIRE */,
       importsFlow:
         "JSDOC#FORALIASVARIABLES#IMPORTSFLOW" /* $COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#IMPORTSFLOW */,
       allExportsFlow:
@@ -130,12 +136,17 @@ export const jsDocComments = Object.freeze({
     extension:
       "The JavaScript (TypeScript) extension of the file." /* $COMMENT#JSDOC#PARAMS#EXTENSION */,
     node: "The ESLint `node` of the rule's current traversal." /* $COMMENT#JSDOC#PARAMS#NODE */,
-    sourceCodeA: "The `SourceCode` where the AST comes from." /* $COMMENT#JSDOC#PARAMS#SOURCECODEA */,
-    callback: "The callback that runs during the walk." /* $COMMENT#JSDOC#PARAMS#CALLBACK */,
+    sourceCodeA:
+      "The `SourceCode` where the AST comes from." /* $COMMENT#JSDOC#PARAMS#SOURCECODEA */,
+    callback:
+      "The callback that runs during the walk." /* $COMMENT#JSDOC#PARAMS#CALLBACK */,
     nodeB: "The node being visited." /* $COMMENT#JSDOC#PARAMS#NODEB */,
-    parent: "The parent of the node being visited." /* $COMMENT#JSDOC#PARAMS#PARENT */,
-    visitorKeys: "The visitor keys of the node being visited." /* $COMMENT#JSDOC#PARAMS#VISITORKEYS */,
-    sourceCodeB: "The `SourceCode` to analyze." /* $COMMENT#JSDOC#PARAMS#SOURCECODEB */,
+    parent:
+      "The parent of the node being visited." /* $COMMENT#JSDOC#PARAMS#PARENT */,
+    visitorKeys:
+      "The visitor keys of the node being visited." /* $COMMENT#JSDOC#PARAMS#VISITORKEYS */,
+    sourceCodeB:
+      "The `SourceCode` to analyze." /* $COMMENT#JSDOC#PARAMS#SOURCECODEB */,
     agnostic20: Object.freeze({
       currentFileEffectiveDirective:
         "$COMMENT#JSDOC#FORCOMPOSEDVARIABLES#THECURRENTFILE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#EFFECTIVE $COMMENT#JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVEPERIOD" /* $COMMENT#JSDOC#PARAMS#AGNOSTIC20#CURRENTFILEEFFECTIVEDIRECTIVE */,

package/library/agnostic20/_commons/rules/import-rules.js

@@ -14,6 +14,7 @@ import {
   currentFileFlow,
   importsFlow,
   reExportsFlow,
+  importsFlowRequire,
 } from "../utilities/flows.js";
 
 /**
@@ -54,7 +55,8 @@ Indeed, Server Functions Modules have no business exporting JSX. `,
       ExportAllDeclaration: (node) =>
         reExportsFlow(context, node, currentFileEffectiveDirective),
       // Unlike directive21, no ExportDefaultDeclaration because ExportDefaultDeclaration don't have source. The reason they're addressed in directive21 is specifically for Agnostic Strategies.
-      // ...but removed because export default can only be
+      CallExpression: (node) =>
+        importsFlowRequire(context, node, currentFileEffectiveDirective),
     };
   },
 };

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

@@ -35,6 +35,7 @@ import {
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').ImportDeclaration} ImportDeclaration
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').ExportNamedDeclaration} ExportNamedDeclaration
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').ExportAllDeclaration} ExportAllDeclaration
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').CallExpression} CallExpression
  */
 
 /* currentFileFlow */
@@ -144,6 +145,68 @@ const importedFileFlow = (context, node) => {
   return { skip: undefined, importedFileEffectiveDirective };
 };
 
+// NEW!! Currently strictly adapted from importedFileFlow
+/**
+ * The `importedFileFlow` adapted for `require` calls to obtain the import file's effective 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 `importedFileEffectiveDirective`.
+ */
+const importedFileFlowRequire = (context, node) => {
+  const skipTrue = { ...skip, importedFileEffectiveDirective: 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
+    const importedFileDirective =
+      getDirectiveFromImportedModule(resolvedImportPath) ?? NO_DIRECTIVE;
+
+    // GETTING THE EXTENSION OF THE IMPORTED FILE
+    const importedFileFileExtension = path.extname(resolvedImportPath);
+
+    // GETTING THE EFFECTIVE DIRECTIVE (no lack thereof) OF THE IMPORTED FILE
+    const importedFileEffectiveDirective = getEffectiveDirective(
+      importedFileDirective,
+      importedFileFileExtension
+    );
+
+    // also fails if one of the seven effective directives has not been obtained
+    if (importedFileEffectiveDirective === null) {
+      console.error("ERROR. Effective directive should never be null.");
+      return skipTrue;
+    }
+
+    // For now skipping on both "does not operate" (which should ignore) and "fails" (which should crash) albeit with console.error.
+
+    return { skip: undefined, importedFileEffectiveDirective };
+  } else return skipTrue;
+};
+
 /* importsFlow */
 
 /** The full flow for import traversals to enforce effective directives import rules.
@@ -184,6 +247,46 @@ export const importsFlow = (context, node, currentFileEffectiveDirective) => {
   }
 };
 
+// NEW!! Currently strictly adapted from importsFlow
+/** The `importsFlow` adapted for `require` calls to enforce effective 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 {EffectiveDirective} currentFileEffectiveDirective The current file's effective directive.
+ * @returns Early if the flow needs to be interrupted.
+ */
+export const importsFlowRequire = (
+  context,
+  node,
+  currentFileEffectiveDirective
+) => {
+  const result = importedFileFlowRequire(context, node);
+
+  if (result.skip) return;
+  const { importedFileEffectiveDirective } = result;
+
+  if (
+    isImportBlocked(
+      currentFileEffectiveDirective,
+      importedFileEffectiveDirective
+    )
+  ) {
+    context.report({
+      node,
+      messageId: importBreaksEffectiveImportRulesMessageId,
+      data: {
+        [effectiveDirectiveMessage]:
+          makeMessageFromCurrentFileEffectiveDirective(
+            currentFileEffectiveDirective
+          ),
+        [specificViolationMessage]: findSpecificViolationMessage(
+          currentFileEffectiveDirective,
+          importedFileEffectiveDirective
+        ),
+      },
+    });
+  }
+};
+
 /* reExportsFlow */
 
 /** The full flow for export traversals, shared between `ExportNamedDeclaration` and `ExportAllDeclaration`, to ensure same effective directive re-exports.

package/library/directive21/_commons/rules/import-rules.js

@@ -24,6 +24,7 @@ import {
   currentFileFlow,
   importsFlow,
   allExportsFlow,
+  importsFlowRequire,
 } from "../utilities/flows.js";
 
 /**
@@ -73,6 +74,8 @@ Please include a Strategy that corresponds to the kind of module this export wou
         allExportsFlow(context, node, verifiedCommentedDirective),
       ExportDefaultDeclaration: (node) =>
         allExportsFlow(context, node, verifiedCommentedDirective),
+      CallExpression: (node) =>
+        importsFlowRequire(context, node, verifiedCommentedDirective),
     };
   },
 };

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

@@ -52,11 +52,72 @@ 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 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);
+
+//
+
 /**
  * The flow that begins the import rules enforcement rule, retrieving the verified commented directive of the current file before comparing it to upcoming verified commented directives of the files it imports.
  * @param {Context} context The ESLint rule's `context` object.
@@ -130,16 +191,24 @@ export const currentFileFlow = (context) => {
       return { skip: undefined, verifiedCommentedDirective }; // at this time, behaves as if the new implementation didn't exist yet
     }
 
-    context.report({
-      loc: highlightFirstLineOfCode(context),
-      messageId: commentedDirectiveReactDirectiveFailedMessageId,
-      data: {
-        // verifiedCommentedDirective
-        verifiedCommentedDirective,
-        // expectedReactDirectiveAsText
-        expectedReactDirectiveAsText,
-      },
-    });
+    // 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
+      )
+    )
+      context.report({
+        loc: highlightFirstLineOfCode(context),
+        messageId: commentedDirectiveReactDirectiveFailedMessageId,
+        data: {
+          // verifiedCommentedDirective
+          verifiedCommentedDirective,
+          // expectedReactDirectiveAsText
+          expectedReactDirectiveAsText,
+        },
+      });
     return skipTrue;
   }
 
@@ -208,7 +277,10 @@ const importedFileFlow = (context, node) => {
       node
     );
 
-    if (importingFileCommentedDirective === null) {
+    if (
+      importingFileCommentedDirective === null &&
+      fileIsExtraJavaScript(context.filename)
+    ) {
       context.report({
         node,
         messageId: importNotStrategizedMessageId,
@@ -243,10 +315,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.
@@ -286,7 +468,82 @@ export const importsFlow = (context, node, currentFileCommentedDirective) => {
     });
   }
 
-  // NEW
+  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
+  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;

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

@@ -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,7 +323,10 @@ export const addressDirectiveIfAgnosticStrategies = (
 
   const exportStrategizedDirective = getStrategizedDirective(context, node);
 
-  if (exportStrategizedDirective === null) {
+  if (
+    exportStrategizedDirective === null &&
+    fileIsExtraJavaScript(context.filename)
+  ) {
     context.report({
       node,
       messageId: exportNotStrategizedMessageId,

package/package.json

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