eslint-plugin-use-agnostic 0.9.7 → 0.9.8

package/README.md

@@ -10,7 +10,7 @@
 npm install eslint@^9.0.0 eslint-plugin-use-agnostic --save-dev
 ```
 
-## Setup (using TypeScript and the Flat Config)
+## Setup
 
 ```js
 // eslint.config.js
@@ -20,13 +20,20 @@ import { defineConfig, globalIgnores } from "eslint/config";
 import useAgnostic, {
   useAgnosticPluginName,
   agnostic20ConfigName,
+  // enforceEffectiveDirectivesRuleName
 } from "eslint-plugin-use-agnostic";
 
 export default defineConfig([
   globalIgnores([".next", ".react-router", "node_modules"]),
   {
-    // files: ['**/*.js', '**/*.jsx'], // if you're using vanilla JavaScript
-    files: ["**/*.ts", "**/*.tsx"],
+    files: [
+      "**/*.tsx",
+      "**/*.ts",
+      "**/*.jsx",
+      "**/*.js",
+      "**/*.mjs",
+      "**/*.cjs",
+    ],
     plugins: {
       [useAgnosticPluginName]: useAgnostic,
     },

package/library/_commons/constants/bases.js

@@ -104,7 +104,6 @@ export const MJS = ".mjs";
 export const CJS = ".cjs";
 
 // JavaScript/TypeScript extensions array
-// /** @type {readonly [TSX, TS, JSX, JS, MJS, CJS]} */
 /** @type {Extensions} */
 export const EXTENSIONS = [TSX, TS, JSX, JS, MJS, CJS]; // In priority order
 

package/library/_commons/utilities/helpers.js

@@ -6,7 +6,6 @@ import { loadConfig, createMatchPath } from "tsconfig-paths";
 import { EXTENSIONS, ARE_NOT_ALLOWED_TO_IMPORT } from "../constants/bases.js";
 
 /**
- * @typedef {import('../../../types/_commons/typedefs').ResolvedDirective} ResolvedDirective
  * @typedef {import('../../../types/_commons/typedefs').ResolvedDirectives_ResolvedModules} ResolvedDirectives_ResolvedModules
  * @typedef {import('../../../types/_commons/typedefs').CurrentFileResolvedDirective} CurrentFileResolvedDirective
  * @typedef {import('../../../types/_commons/typedefs').Context<string, readonly unknown[]>} Context
@@ -148,26 +147,27 @@ export const makeIntroForSpecificViolationMessage = (
 ) =>
   `${resolvedDirectives_resolvedModules[currentFileResolvedDirective]}s ${ARE_NOT_ALLOWED_TO_IMPORT} ${resolvedDirectives_resolvedModules[importedFileResolvedDirective]}s.`;
 
-/* makeMessageFromResolvedDirective */
+/* makeMessageFromCurrentFileResolvedDirective */
 
 /**
  * Lists in an message the "resolved" modules incompatible with a "resolved" module based on its "resolved" directive.
  * @template {CurrentFileResolvedDirective} T
  * @param {ResolvedDirectives_ResolvedModules} resolvedDirectives_resolvedModules The resolved modules object, either for agnostic20 or for directive21.
  * @param {ResolvedDirectives_BlockedImports<T>} resolvedDirectives_blockedImports The blocked imports object, either for agnostic20 or for directive21.
- * @param {T} resolvedDirective The "resolved" directive of the "resolved" module.
+ * @param {T} currentFileResolvedDirective The "resolved" directive of the "resolved" module.
  * @returns The message listing the incompatible "resolved" modules.
  */
-export const makeMessageFromResolvedDirective = (
+export const makeMessageFromCurrentFileResolvedDirective = (
   resolvedDirectives_resolvedModules,
   resolvedDirectives_blockedImports,
-  resolvedDirective
+  currentFileResolvedDirective
 ) => {
-  const effectiveModule = resolvedDirectives_resolvedModules[resolvedDirective];
+  const effectiveModule =
+    resolvedDirectives_resolvedModules[currentFileResolvedDirective];
   const effectiveModulesString = effectiveModule + "s"; // plural
 
   const blockedImports =
-    resolvedDirectives_blockedImports[resolvedDirective].map(
+    resolvedDirectives_blockedImports[currentFileResolvedDirective].map(
       (e) => e.blockedImport
     ) || [];
 

package/library/agnostic20/_commons/constants/bases.js

@@ -15,10 +15,11 @@ import { makeIntroForSpecificViolationMessage as commonsMakeIntroForSpecificViol
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Directive} Directive
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Directives} Directives
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').EffectiveDirective} EffectiveDirective
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Directives_EffectiveDirectives} Directives_EffectiveDirectives
  */
 
 // directives
-export const NO_DIRECTIVE = null;
+export const NO_DIRECTIVE = "no directive";
 export const USE_SERVER = "use server";
 export const USE_CLIENT = "use client";
 export const USE_AGNOSTIC = "use agnostic";
@@ -40,28 +41,33 @@ export const USE_CLIENT_COMPONENTS = COMMONS_USE_CLIENT_COMPONENTS;
 export const USE_AGNOSTIC_LOGICS = COMMONS_USE_AGNOSTIC_LOGICS;
 export const USE_AGNOSTIC_COMPONENTS = COMMONS_USE_AGNOSTIC_COMPONENTS;
 
+// module kinds
+export const LOGICS = "logics";
+export const COMPONENTS = "components";
+export const FUNCTIONS = "functions";
+
 // mapping directives with effective directives
-/** @type {Readonly<Record<Directive | null, { logics: EffectiveDirective | null, components: EffectiveDirective | null, functions: EffectiveDirective | null }>>} */
+/** @type {Directives_EffectiveDirectives} */
 export const directives_effectiveDirectives = Object.freeze({
   [NO_DIRECTIVE]: {
-    logics: USE_SERVER_LOGICS,
-    components: USE_SERVER_COMPONENTS,
-    functions: null,
+    [LOGICS]: USE_SERVER_LOGICS,
+    [COMPONENTS]: USE_SERVER_COMPONENTS,
+    [FUNCTIONS]: null,
   },
   [USE_SERVER]: {
-    logics: null,
-    components: null,
-    functions: USE_SERVER_FUNCTIONS,
+    [LOGICS]: null,
+    [COMPONENTS]: null,
+    [FUNCTIONS]: USE_SERVER_FUNCTIONS,
   },
   [USE_CLIENT]: {
-    logics: USE_CLIENT_LOGICS,
-    components: USE_CLIENT_COMPONENTS,
-    functions: null,
+    [LOGICS]: USE_CLIENT_LOGICS,
+    [COMPONENTS]: USE_CLIENT_COMPONENTS,
+    [FUNCTIONS]: null,
   },
   [USE_AGNOSTIC]: {
-    logics: USE_AGNOSTIC_LOGICS,
-    components: USE_AGNOSTIC_COMPONENTS,
-    functions: null,
+    [LOGICS]: USE_AGNOSTIC_LOGICS,
+    [COMPONENTS]: USE_AGNOSTIC_COMPONENTS,
+    [FUNCTIONS]: null,
   },
 });
 

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

@@ -8,6 +8,7 @@ import {
   skip,
 } from "../../../_commons/constants/bases.js";
 import {
+  NO_DIRECTIVE,
   USE_SERVER,
   // currentFileEffectiveDirective,
   // importedFileEffectiveDirective,
@@ -24,7 +25,7 @@ import {
   getDirectiveFromImportedModule,
   getEffectiveDirective,
   isImportBlocked,
-  makeMessageFromEffectiveDirective,
+  makeMessageFromCurrentFileEffectiveDirective,
   findSpecificViolationMessage,
 } from "./helpers.js";
 
@@ -38,7 +39,6 @@ import {
 
 /* currentFileFlow */
 
-// {{skip: true; currentFileEffectiveDirective: undefined;} | {skip: undefined; currentFileEffectiveDirective: EffectiveDirective;}}
 /**
  * The flow that begins the import rules enforcement rule, retrieving the valid directive of the current file before comparing it to upcoming valid directives of the files it imports.
  * @param {Context} context The ESLint rule's `context` object.
@@ -61,8 +61,9 @@ export const currentFileFlow = (context) => {
     return skipTrue;
   }
 
-  /* GETTING THE DIRECTIVE (or lack thereof) OF THE CURRENT FILE */
-  const currentFileDirective = getDirectiveFromCurrentModule(context);
+  // GETTING THE DIRECTIVE (or lack thereof) OF THE CURRENT FILE
+  const currentFileDirective =
+    getDirectiveFromCurrentModule(context) ?? NO_DIRECTIVE;
 
   // reports if a file marked "use server" has a JSX extension
   if (
@@ -76,7 +77,7 @@ export const currentFileFlow = (context) => {
     return skipTrue;
   }
 
-  // GETTING THE EFFECTIVE DIRECTIVE OF THE CURRENT FILE
+  // GETTING THE EFFECTIVE DIRECTIVE (no lack thereof) OF THE CURRENT FILE
   const currentFileEffectiveDirective = getEffectiveDirective(
     currentFileDirective,
     currentFileExtension
@@ -93,7 +94,6 @@ export const currentFileFlow = (context) => {
 
 /* importedFileFlow */
 
-// {{skip: true; importedFileEffectiveDirective: undefined;} | {skip: undefined; importedFileEffectiveDirective: EffectiveDirective;}}
 /**
  * The flow that is shared between import and re-export traversals to obtain the import file's effective directive.
  * @param {Context} context The ESLint rule's `context` object.
@@ -118,12 +118,14 @@ const importedFileFlow = (context, node) => {
   );
   if (!isImportedFileJS) return skipTrue;
 
-  /* GETTING THE DIRECTIVE (or lack thereof) OF THE IMPORTED FILE */
+  // GETTING THE DIRECTIVE (or lack thereof) OF THE IMPORTED FILE
   const importedFileDirective =
-    getDirectiveFromImportedModule(resolvedImportPath);
+    getDirectiveFromImportedModule(resolvedImportPath) ?? NO_DIRECTIVE;
+
   // GETTING THE EXTENSION OF THE IMPORTED FILE
   const importedFileFileExtension = path.extname(resolvedImportPath);
-  // GETTING THE EFFECTIVE DIRECTIVE OF THE IMPORTED FILE
+
+  // GETTING THE EFFECTIVE DIRECTIVE (no lack thereof) OF THE IMPORTED FILE
   const importedFileEffectiveDirective = getEffectiveDirective(
     importedFileDirective,
     importedFileFileExtension
@@ -135,7 +137,7 @@ const importedFileFlow = (context, node) => {
     return skipTrue;
   }
 
-  // For now skipping on both "does not operate" (which should ignore) and "fails" albeit with console.error (which should crash).
+  // For now skipping on both "does not operate" (which should ignore) and "fails" (which should crash) albeit with console.error.
 
   return { skip: undefined, importedFileEffectiveDirective };
 };
@@ -167,9 +169,10 @@ export const importsFlow = (context, node, currentFileEffectiveDirective) => {
       node,
       messageId: importBreaksEffectiveImportRulesMessageId,
       data: {
-        [effectiveDirectiveMessage]: makeMessageFromEffectiveDirective(
-          currentFileEffectiveDirective
-        ),
+        [effectiveDirectiveMessage]:
+          makeMessageFromCurrentFileEffectiveDirective(
+            currentFileEffectiveDirective
+          ),
         [specificViolationMessage]: findSpecificViolationMessage(
           currentFileEffectiveDirective,
           importedFileEffectiveDirective

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

@@ -1,15 +1,9 @@
 import { effectiveDirectives_effectiveModules } from "../../../_commons/constants/bases.js";
 import {
   USE_SERVER,
-  USE_CLIENT,
-  USE_AGNOSTIC,
-  USE_SERVER_LOGICS,
-  USE_SERVER_COMPONENTS,
-  USE_SERVER_FUNCTIONS,
-  USE_CLIENT_LOGICS,
-  USE_CLIENT_COMPONENTS,
-  USE_AGNOSTIC_LOGICS,
-  USE_AGNOSTIC_COMPONENTS,
+  LOGICS,
+  COMPONENTS,
+  FUNCTIONS,
   directivesArray,
   directives_effectiveDirectives,
   effectiveDirectives_blockedImports,
@@ -18,13 +12,14 @@ import {
 import {
   getImportedFileFirstLine,
   isImportBlocked as commonsIsImportBlocked,
-  makeMessageFromResolvedDirective,
+  makeMessageFromCurrentFileResolvedDirective,
   findSpecificViolationMessage as commonsFindSpecificViolationMessage,
 } from "../../../_commons/utilities/helpers.js";
 
 /**
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Context} Context
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Directive} Directive
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').NoDirective} NoDirective
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Extension} Extension
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').EffectiveDirective} EffectiveDirective
  */
@@ -75,44 +70,18 @@ export const getDirectiveFromCurrentModule = (context) => {
  * - `'use client components'` denotes a Client Components Module.
  * - `'use agnostic logics'` denotes an Agnostic Logics Module.
  * - `'use agnostic components'` denotes an Agnostic Components Module.
- * @param {Directive | null} directive The directive as written on top of the file (`null` if no valid directive).
+ * @param {Directive | NoDirective} directive The directive as written on top of the file (`"no directive"` if no valid directive).
  * @param {Extension} extension The JavaScript (TypeScript) extension of the file.
  * @returns The effective directive, from which imports rules are applied.
  */
 export const getEffectiveDirective = (directive, extension) => {
-  // I could use a map, but because this is in JS with JSDoc, a manual solution is peculiarly more typesafe.
-  if (directive === null && !extension.endsWith("x")) return USE_SERVER_LOGICS;
-  if (directive === null && extension.endsWith("x"))
-    return USE_SERVER_COMPONENTS;
-  if (directive === USE_SERVER && !extension.endsWith("x"))
-    return USE_SERVER_FUNCTIONS;
-  if (directive === USE_CLIENT && !extension.endsWith("x"))
-    return USE_CLIENT_LOGICS;
-  if (directive === USE_CLIENT && extension.endsWith("x"))
-    return USE_CLIENT_COMPONENTS;
-  if (directive === USE_AGNOSTIC && !extension.endsWith("x"))
-    return USE_AGNOSTIC_LOGICS;
-  if (directive === USE_AGNOSTIC && extension.endsWith("x"))
-    return USE_AGNOSTIC_COMPONENTS;
-
-  return null; // default error, should be unreachable
-};
-// directives_effectiveDirectives
-/**
- * @param {Directive | null} directive
- * @param {Extension} extension
- * @returns
- */
-export const trueGetEffectiveDirective = (directive, extension) => {
-  const type = extension.endsWith("x")
-    ? "components"
+  const moduleKind = extension.endsWith("x")
+    ? COMPONENTS
     : directive === USE_SERVER
-    ? "functions"
-    : "logics";
+    ? FUNCTIONS
+    : LOGICS;
 
-  const a = directives_effectiveDirectives[directive];
-
-  return directives_effectiveDirectives[directive]?.[type] ?? null;
+  return directives_effectiveDirectives[directive][moduleKind];
 };
 
 /* getDirectiveFromImportedModule */
@@ -165,15 +134,17 @@ export const isImportBlocked = (
     importedFileEffectiveDirective
   );
 
-/* makeMessageFromEffectiveDirective */
+/* makeMessageFromCurrentFileEffectiveDirective */
 
 /**
  * Lists in an message the effective modules incompatible with an effective module based on its effective directive.
  * @param {EffectiveDirective} effectiveDirective The effective directive of the effective module.
  * @returns The message listing the incompatible effective modules.
  */
-export const makeMessageFromEffectiveDirective = (effectiveDirective) =>
-  makeMessageFromResolvedDirective(
+export const makeMessageFromCurrentFileEffectiveDirective = (
+  effectiveDirective
+) =>
+  makeMessageFromCurrentFileResolvedDirective(
     effectiveDirectives_effectiveModules,
     effectiveDirectives_blockedImports,
     effectiveDirective

package/library/directive21/_commons/constants/bases.js

@@ -36,7 +36,7 @@ export const USE_AGNOSTIC_STRATEGIES = COMMONS_USE_AGNOSTIC_STRATEGIES;
 
 // commented directives array
 /** @type {CommentedDirectives} */
-export const directivesArray = [
+export const commentedDirectivesArray = [
   USE_SERVER_LOGICS,
   USE_CLIENT_LOGICS,
   USE_AGNOSTIC_LOGICS,
@@ -51,7 +51,21 @@ export const directivesArray = [
 
 // commented directives set
 /** @type {ReadonlySet<CommentedDirective>} */
-export const directivesSet = new Set(directivesArray); // no longer used exported to satisfy static type inference
+export const commentedDirectivesSet = new Set(commentedDirectivesArray); // no longer used exported to satisfy static type inference
+
+// mapped commented directives to their extension rules
+export const commentedDirectives_extensionRules = {
+  [USE_SERVER_LOGICS]: false, // Must not end with 'x'
+  [USE_CLIENT_LOGICS]: false,
+  [USE_AGNOSTIC_LOGICS]: false,
+  [USE_SERVER_COMPONENTS]: true, // Must end with 'x'
+  [USE_CLIENT_COMPONENTS]: true,
+  [USE_AGNOSTIC_COMPONENTS]: true,
+  [USE_SERVER_FUNCTIONS]: false,
+  [USE_CLIENT_CONTEXTS]: true,
+  [USE_AGNOSTIC_CONDITIONS]: true,
+  [USE_AGNOSTIC_STRATEGIES]: null, // Any extension allowed
+};
 
 // commented strategies
 export const AT_SERVER_LOGICS = "@serverLogics";
@@ -145,7 +159,6 @@ const _DIRECTIVE_MUST_HAVE_A_JSX_FILE_EXTENSION =
   "directive must have a JSX file extension";
 
 export const commentedDirectives_verificationReports = Object.freeze({
-  // somehow doing it by hand is better for type inference in raw JS
   [USE_SERVER_LOGICS]: `${MODULES_MARKED_WITH_THE_} "${USE_SERVER_LOGICS}" ${_DIRECTIVE_MUST_HAVE_A_NON_JSX_FILE_EXTENSION}.`,
   [USE_CLIENT_LOGICS]: `${MODULES_MARKED_WITH_THE_} "${USE_CLIENT_LOGICS}" ${_DIRECTIVE_MUST_HAVE_A_NON_JSX_FILE_EXTENSION}.`,
   [USE_AGNOSTIC_LOGICS]: `${MODULES_MARKED_WITH_THE_} "${USE_AGNOSTIC_LOGICS}" ${_DIRECTIVE_MUST_HAVE_A_NON_JSX_FILE_EXTENSION}.`,

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

@@ -28,7 +28,7 @@ import {
   getVerifiedCommentedDirective,
   getCommentedDirectiveFromImportedModule,
   isImportBlocked,
-  makeMessageFromCommentedDirective,
+  makeMessageFromCurrentFileCommentedDirective,
   findSpecificViolationMessage,
   getStrategizedDirective,
   addressDirectiveIfAgnosticStrategies,
@@ -53,7 +53,7 @@ import {
 export const currentFileFlow = (context) => {
   const skipTrue = { ...skip, verifiedCommentedDirective: undefined };
 
-  // GETTING THE EXTENSION OF THE CURRENT FILE
+  // gets the extension of the current file
   const currentFileExtension = path.extname(context.filename);
 
   // fails if the file is not JavaScript (TypeScript)
@@ -79,6 +79,7 @@ export const currentFileFlow = (context) => {
     return skipTrue;
   }
 
+  // verifies the commented directive from the current file
   const verifiedCommentedDirective = getVerifiedCommentedDirective(
     commentedDirective,
     currentFileExtension
@@ -126,7 +127,7 @@ const importedFileFlow = (context, node) => {
   );
   if (!isImportedFileJS) return skipTrue;
 
-  /* GETTING THE DIRECTIVE (or lack thereof) OF THE IMPORTED FILE */
+  // GETTING THE DIRECTIVE (or lack thereof) OF THE IMPORTED FILE
   let importedFileCommentedDirective =
     getCommentedDirectiveFromImportedModule(resolvedImportPath);
 
@@ -141,19 +142,17 @@ const importedFileFlow = (context, node) => {
   /* 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, this feature is currently canceled, mainly since the amount of work it will require will not be able to be transferred in a future where commented strategies will actually be real syntax.
+  After a short attempt, the feature to address this (crossingStrategies) is currently canceled, mainly since the amount of work it will require will not be able to be transferred in a future where commented strategies will actually be real syntax.
   
   (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
     );
 
-    // 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;
-
     if (importingFileCommentedDirective === null) {
       context.report({
         node,
@@ -161,6 +160,9 @@ const importedFileFlow = (context, node) => {
       });
       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;
   }
 
   return { skip: undefined, importedFileCommentedDirective };
@@ -194,9 +196,10 @@ export const importsFlow = (context, node, currentFileCommentedDirective) => {
       node,
       messageId: importBreaksCommentedImportRulesMessageId,
       data: {
-        [commentedDirectiveMessage]: makeMessageFromCommentedDirective(
-          currentFileCommentedDirective
-        ),
+        [commentedDirectiveMessage]:
+          makeMessageFromCurrentFileCommentedDirective(
+            currentFileCommentedDirective
+          ),
         [specificViolationMessage]: findSpecificViolationMessage(
           currentFileCommentedDirective,
           importedFileCommentedDirective
@@ -244,7 +247,9 @@ export const allExportsFlow = (
       currentFileCommentedDirective
     );
 
+    // returns early if an address has been made
     if (!addressedDirective) return;
+    // moves on to the re-export check otherwise
     else currentFileCommentedDirective = addressedDirective;
 
     if (currentFileCommentedDirective !== importedFileCommentedDirective) {

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

@@ -3,18 +3,11 @@ import {
   commentedDirectives_commentedModules,
 } from "../../../_commons/constants/bases.js";
 import {
-  USE_SERVER_LOGICS,
-  USE_CLIENT_LOGICS,
   USE_AGNOSTIC_LOGICS,
-  USE_SERVER_COMPONENTS,
-  USE_CLIENT_COMPONENTS,
-  USE_AGNOSTIC_COMPONENTS,
-  USE_SERVER_FUNCTIONS,
-  USE_CLIENT_CONTEXTS,
-  USE_AGNOSTIC_CONDITIONS,
   USE_AGNOSTIC_STRATEGIES,
-  directivesArray,
+  commentedDirectivesArray,
   strategiesArray,
+  commentedDirectives_extensionRules,
   commentedDirectives_4RawImplementations,
   commentedStrategies_commentedDirectives,
   commentedDirectives_blockedImports,
@@ -23,7 +16,7 @@ import {
 import {
   getImportedFileFirstLine,
   isImportBlocked as commonsIsImportBlocked,
-  makeMessageFromResolvedDirective,
+  makeMessageFromCurrentFileResolvedDirective,
   findSpecificViolationMessage as commonsFindSpecificViolationMessage,
 } from "../../../_commons/utilities/helpers.js";
 
@@ -124,7 +117,7 @@ export const getCommentedDirectiveFromCurrentModule = (context) => {
 
   // certifies the directive or lack thereof from the obtained value
   const commentedDirective =
-    directivesArray.find((directive) => directive === value) ?? null;
+    commentedDirectivesArray.find((directive) => directive === value) ?? null;
 
   return commentedDirective;
 };
@@ -145,31 +138,17 @@ export const getCommentedDirectiveFromCurrentModule = (context) => {
  * - `'use agnostic strategies'`: Agnostic Strategies Modules may export JSX.
  * @param {CommentedDirective} directive The commented directive as written on top of the file (cannot be `null` at that stage).
  * @param {Extension} extension The JavaScript (TypeScript) extension of the file.
- * @returns The verified commented directive, from which imports rules are applied. Returns `null` if the verification failed, upon which an error will be reported depending on the commented directive, since the error logic here is strictly binary.
+ * @returns {CommentedDirective | null} The verified commented directive, from which imports rules are applied. Returns `null` if the verification failed, upon which an error will be reported depending on the commented directive, since the error logic here is strictly binary.
  */
 export const getVerifiedCommentedDirective = (directive, extension) => {
-  // I could use a map, but because this is in JS with JSDoc, a manual solution is peculiarly more typesafe.
-  if (directive === USE_SERVER_LOGICS && !extension.endsWith("x"))
-    return directive;
-  if (directive === USE_CLIENT_LOGICS && !extension.endsWith("x"))
-    return directive;
-  if (directive === USE_AGNOSTIC_LOGICS && !extension.endsWith("x"))
-    return directive;
-  if (directive === USE_SERVER_COMPONENTS && extension.endsWith("x"))
-    return directive;
-  if (directive === USE_CLIENT_COMPONENTS && extension.endsWith("x"))
-    return directive;
-  if (directive === USE_AGNOSTIC_COMPONENTS && extension.endsWith("x"))
-    return directive;
-  if (directive === USE_SERVER_FUNCTIONS && !extension.endsWith("x"))
-    return directive;
-  if (directive === USE_CLIENT_CONTEXTS && extension.endsWith("x"))
-    return directive;
-  if (directive === USE_AGNOSTIC_CONDITIONS && extension.endsWith("x"))
-    return directive;
-  if (directive === USE_AGNOSTIC_STRATEGIES) return directive;
-
-  return null; // verification error
+  const rule = commentedDirectives_extensionRules[directive];
+  const isExtensionJSX = extension.endsWith("x");
+
+  if (rule === true && isExtensionJSX) return directive; // requires JSX extension
+  if (rule === false && !isExtensionJSX) return directive; // forbids JSX extension
+  if (rule === null) return directive; // no extension constraint, specifically for "use agnostic strategies"
+
+  return null; // verification failed
 };
 
 /* getCommentedDirectiveFromImportedModule */
@@ -197,7 +176,7 @@ export const getCommentedDirectiveFromImportedModule = (resolvedImportPath) => {
   const importedFileFirstLine = getImportedFileFirstLine(resolvedImportPath);
 
   // sees if the first line includes any of the directives and finds the directive that it includes, with USE_AGNOSTIC_LOGICS as a default
-  const includedDirective = directivesArray.reduce((acc, curr) => {
+  const includedDirective = commentedDirectivesArray.reduce((acc, curr) => {
     if (importedFileFirstLine.includes(curr)) return curr;
     else return acc;
   }, USE_AGNOSTIC_LOGICS);
@@ -221,19 +200,23 @@ export const getCommentedDirectiveFromImportedModule = (resolvedImportPath) => {
  * @returns The interpreted directive, a.k.a. strategized directive, or lack thereof via `null`.
  */
 export const getStrategizedDirective = (context, node) => {
+  // gets the first nested `/* */` comment inside the node
   const firstNestedComment = context.sourceCode.getCommentsInside(node)[0];
 
   // returns null early if there is no nested comments
   if (!firstNestedComment) return null;
 
+  // gets and trims the first nested comment raw
   const rawStrategy = firstNestedComment.value.trim() || "";
 
+  // asserts whether that first nested comment is or isn't a Strategy
   const strategy =
     strategiesArray.find((strategy) => strategy === rawStrategy) ?? null;
 
   // returns null early if no strategy was identified
   if (!strategy) return null;
 
+  // maps the strategy to the its relevant directive
   const commentedDirective = commentedStrategies_commentedDirectives[strategy];
 
   return commentedDirective;
@@ -257,15 +240,17 @@ export const isImportBlocked = (
     importedFileCommentedDirective
   );
 
-/* makeMessageFromCommentedDirective */
+/* makeMessageFromCurrentFileCommentedDirective */
 
 /**
  * Lists in an message the commented modules incompatible with a commented module based on its commented directive.
  * @param {CommentedDirective} commentedDirective The commented directive of the commented module.
  * @returns The message listing the incompatible commented modules.
  */
-export const makeMessageFromCommentedDirective = (commentedDirective) =>
-  makeMessageFromResolvedDirective(
+export const makeMessageFromCurrentFileCommentedDirective = (
+  commentedDirective
+) =>
+  makeMessageFromCurrentFileResolvedDirective(
     commentedDirectives_commentedModules,
     commentedDirectives_blockedImports,
     commentedDirective

package/package.json

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