eslint-plugin-use-agnostic 0.9.0 → 0.9.1

package/README.md

@@ -85,7 +85,7 @@ Only the first line of code in a file is observed for the presence of a directiv
 
 Aliased import paths are resolved only if your ESLint config file and your `tsconfig.json` file are in the same directory. (At least to my knowledge.)
 
-It is up to you to confirm that your Agnostic Modules are indeed agnostic, meaning that they do not have neither server- nor client-side code. `eslint-plugin-use-agnostic`, at least at this time, does not do this verification for you.
+It is up to you to confirm that your Agnostic Modules are indeed agnostic, meaning that they do have neither server- nor client-side code. `eslint-plugin-use-agnostic`, at least at this time, does not do this verification for you.
 
 It is also up to you to ensure, as outlined above, that **you do not mix** exporting React components with exporting other logics within the same module. Separating exporting React components from their own modules ending with a JSX extension, from other logics from modules that don't end with a JSX extension, is crucial for distinguishing between Logics Modules and Components Modules.
 
@@ -109,4 +109,4 @@ But not having a directive to distinguish between 1. non-special Server Modules
 
 This is what the 'use agnostic' directive solves. It clearly marks a module to be an Agnostic Module. And if a module that used to lack a directive can now be marked as an Agnostic Module, this allows modules without a directive to finally, truly be Server Modules by default. And eslint-plugin-use-agnostic can work from there.
 
-A lot more work needs to be done, and a lot of it unfortunately can only be optimized deeper into React's innerworkings. But if the introduction of 'use agnostic' can already create such powerful static analysis, imagine what it could produce if only it were incorporated into React as an official directive of the Fullstack React Architecture.
+A lot more work has to be done, and a lot of it unfortunately can only be optimized deeper into React's innerworkings. But if the introduction of 'use agnostic' can already create such powerful static analysis, imagine what it could produce if only it were incorporated into React as an official directive of the Fullstack React Architecture.

package/library/_commons/constants/bases.js

@@ -1,7 +1,7 @@
 /* plugin names */
 // use-agnostic
 export const useAgnosticPluginName = "use-agnostic";
-// crossingStrategies
+// crossingStrategies (canceled)
 export const strategiesPluginName = "strategies";
 
 /* config names */
@@ -18,7 +18,7 @@ export const enforceEffectiveDirectivesRuleName =
 export const enforceCommentedDirectivesRuleName =
   "enforce-commented-directives-import-rules";
 
-// crossingStrategies
+// crossingStrategies (canceled)
 export const verifySpecifierImportRuleName =
   "verify-specifier-import-export-same-strategy";
 export const verifyDefaultImportRuleName =
@@ -44,6 +44,8 @@ export const exportNotStrategized =
   "export-from-use-agnostic-strategies-not-strategized";
 
 // all "resolved" directives (from AIA/agnostic20 & DFA/directive21)
+// - AIA: Agnostic-Included Architecture (agnostic20)
+// - DFA: Directive-First Architecture (directive21)
 export const USE_SERVER_LOGICS = "use server logics";
 export const USE_CLIENT_LOGICS = "use client logics";
 export const USE_AGNOSTIC_LOGICS = "use agnostic logics";

package/library/_commons/utilities/helpers.js

@@ -97,6 +97,18 @@ export const getImportedFileFirstLine = (resolvedImportPath) => {
   return importedFileFirstLine;
 };
 
+/* highlightFirstLineOfCode */
+
+/**
+ * Gets the coordinates for the first line of code of a file.
+ * @param {import('@typescript-eslint/utils').TSESLint.RuleContext} context An ESLint rule's `context` object.
+ * @returns The `context.report` `loc`-compatible coordinates for the first line of code of a file.
+ */
+export const highlightFirstLineOfCode = (context) => ({
+  start: { line: 1, column: 0 },
+  end: { line: 1, column: context.sourceCode.lines[0].length },
+});
+
 /* isImportBlocked */
 
 /**
@@ -110,7 +122,7 @@ export const isImportBlocked = (
   // Note: "Blocked" here is preferred over "not allowed" because a specific message will be shared for each of the blocked situations, explaining their reasons and the solutions needed.
   resolvedDirectives_blockedImports,
   currentFileResolvedDirective,
-  importedFileResolvedDirective,
+  importedFileResolvedDirective
 ) =>
   resolvedDirectives_blockedImports[currentFileResolvedDirective]
     .map((e) => e.blockedImport)
@@ -123,12 +135,12 @@ export const isImportBlocked = (
  * @param {Readonly<{"use server logics": SERVER_LOGICS_MODULE; "use client logics": CLIENT_LOGICS_MODULE; "use agnostic logics": AGNOSTIC_LOGICS_MODULE; "use server components": SERVER_COMPONENTS_MODULE; "use client components": CLIENT_COMPONENTS_MODULE; "use agnostic components": AGNOSTIC_COMPONENTS_MODULE; "use server functions": SERVER_FUNCTIONS_MODULE; "use client contexts": CLIENT_CONTEXTS_MODULE; "use agnostic conditions": AGNOSTIC_CONDITIONS_MODULE; "use agnostic strategies": AGNOSTIC_STRATEGIES_MODULE;}>} resolvedDirectives_ResolvedModules The resolved modules object, either for agnostic20 or for directive21.
  * @param {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} currentFileResolvedDirective The current file's "resolved" directive.
  * @param {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} importedFileResolvedDirective The imported file's "resolved" directive.
- * @returns {string} Returns "[Current file 'resolved' modules] are not allowed to import [imported file 'resolved' modules]".
+ * @returns {string} Returns "[Current file 'resolved' modules] are not allowed to import [imported file 'resolved' modules]."
  */
 export const makeIntroForSpecificViolationMessage = (
   resolvedDirectives_ResolvedModules,
   currentFileResolvedDirective,
-  importedFileResolvedDirective,
+  importedFileResolvedDirective
 ) =>
   `${resolvedDirectives_ResolvedModules[currentFileResolvedDirective]}s ${ARE_NOT_ALLOWED_TO_IMPORT} ${resolvedDirectives_ResolvedModules[importedFileResolvedDirective]}s.`;
 
@@ -144,14 +156,14 @@ export const makeIntroForSpecificViolationMessage = (
 export const makeMessageFromResolvedDirective = (
   resolvedDirectives_ResolvedModules,
   resolvedDirectives_blockedImports,
-  resolvedDirective,
+  resolvedDirective
 ) => {
   const effectiveModule = resolvedDirectives_ResolvedModules[resolvedDirective];
   const effectiveModulesString = effectiveModule + "s"; // plural
 
   const blockedImports =
     resolvedDirectives_blockedImports[resolvedDirective].map(
-      (e) => e.blockedImport,
+      (e) => e.blockedImport
     ) || [];
 
   if (blockedImports.length === 0) {
@@ -159,7 +171,7 @@ export const makeMessageFromResolvedDirective = (
   }
 
   const blockedEffectiveModules = blockedImports.map(
-    (e) => resolvedDirectives_ResolvedModules[e] + "s", // plural
+    (e) => resolvedDirectives_ResolvedModules[e] + "s" // plural
   );
 
   const blockedEffectiveModulesString =
@@ -184,8 +196,8 @@ export const makeMessageFromResolvedDirective = (
 export const findSpecificViolationMessage = (
   resolvedDirectives_blockedImports,
   currentFileResolvedDirective,
-  importedFileResolvedDirective,
+  importedFileResolvedDirective
 ) =>
   resolvedDirectives_blockedImports[currentFileResolvedDirective].find(
-    (e) => e.blockedImport === importedFileResolvedDirective,
+    (e) => e.blockedImport === importedFileResolvedDirective
   ).message;

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

@@ -65,6 +65,7 @@ export const directivesSet = new Set([USE_SERVER, USE_CLIENT, USE_AGNOSTIC]);
 
 /* from the getDirectiveFromImportedModule utility */
 
+/** @type {readonly [USE_SERVER, USE_CLIENT, USE_AGNOSTIC]} */
 export const directivesArray = Array.from(directivesSet);
 
 /* from the isImportBlocked utility */
@@ -75,7 +76,7 @@ export const directivesArray = Array.from(directivesSet);
  * Makes the intro for each specific import rule violation messages.
  * @param {USE_SERVER_LOGICS | USE_SERVER_COMPONENTS | USE_SERVER_FUNCTIONS | USE_CLIENT_LOGICS | USE_CLIENT_COMPONENTS | USE_AGNOSTIC_LOGICS | USE_AGNOSTIC_COMPONENTS} currentFileEffectiveDirective The current file's effective directive.
  * @param {USE_SERVER_LOGICS | USE_SERVER_COMPONENTS | USE_SERVER_FUNCTIONS | USE_CLIENT_LOGICS | USE_CLIENT_COMPONENTS | USE_AGNOSTIC_LOGICS | USE_AGNOSTIC_COMPONENTS} importedFileEffectiveDirective The imported file's effective directive.
- * @returns {string} Returns "[Current file effective modules] are not allowed to import [imported file effective modules]".
+ * @returns {string} Returns "[Current file effective modules] are not allowed to import [imported file effective modules]."
  */
 const makeIntroForSpecificViolationMessage = (
   currentFileEffectiveDirective,

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

@@ -20,7 +20,10 @@ import {
   specificViolationMessage,
 } from "../constants/bases.js";
 
-import { resolveImportPath } from "../../../_commons/utilities/helpers.js";
+import {
+  resolveImportPath,
+  highlightFirstLineOfCode,
+} from "../../../_commons/utilities/helpers.js";
 import {
   getDirectiveFromCurrentModule,
   getDirectiveFromImportedModule,
@@ -61,10 +64,7 @@ export const currentFileFlow = (context) => {
     currentFileExtension.endsWith("x")
   ) {
     context.report({
-      loc: {
-        start: { line: 1, column: 0 },
-        end: { line: 1, column: context.sourceCode.lines[0].length },
-      },
+      loc: highlightFirstLineOfCode(context),
       messageId: useServerJSXMessageId,
     });
     return { skip: true };
@@ -91,9 +91,6 @@ export const currentFileFlow = (context) => {
 
 /**
  * The flow that is shared between import and re-export traversals to obtain the import file's effective directive.
- * @param {string} currentDir Directory of the file containing the import (from `path.dirname(context.filename)`).
- * @param {string} importPath The import specifier (e.g., `@/components/Button` or `./utils`).
- * @param {string} cwd Project root (from `context.cwd`). Caveat: only as an assumption currently.
  * @param {Readonly<import('@typescript-eslint/utils').TSESLint.RuleContext<typeof reExportNotSameMessageId | typeof importBreaksEffectiveImportRulesMessageId | typeof useServerJSXMessageId, []>>} context The ESLint rule's `context` object.
  * @param {import('@typescript-eslint/types').TSESTree.ImportDeclaration} node The ESLint `node` of the rule's current traversal.
  * @returns {{skip: true; importedFileEffectiveDirective: undefined; resolvedImportPath: undefined;} | {skip: undefined; importedFileEffectiveDirective: USE_SERVER_LOGICS | USE_SERVER_COMPONENTS | USE_SERVER_FUNCTIONS | USE_CLIENT_LOGICS | USE_CLIENT_COMPONENTS | USE_AGNOSTIC_LOGICS | USE_AGNOSTIC_COMPONENTS; resolvedImportPath: string;}} Returns either an object with `skip: true` to disregard or one with the non-null `importedFileEffectiveDirective`.
@@ -202,9 +199,9 @@ export const reExportsFlow = (context, node, currentFileEffectiveDirective) => {
       node,
       messageId: reExportNotSameMessageId,
       data: {
-        // currentFileEffectiveDirective
+        // currentFileEffectiveDirective:
         currentFileEffectiveDirective,
-        // importedFileEffectiveDirective
+        // importedFileEffectiveDirective:
         importedFileEffectiveDirective,
       },
     });

package/library/agnostic20/config.js

@@ -9,6 +9,8 @@ import {
 
 /**
  * Makes the agnostic20 config for the use-agnostic ESLint plugin.
+ * @param {import('eslint').ESLint.Plugin} plugin The use-agnostic ESLint plugin itself.
+ * @returns The agnostic20 config's name as a key and its config as its value.
  */
 export const makeAgnostic20Config = (plugin) => ({
   [agnostic20ConfigName]: defineConfig([

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

@@ -86,27 +86,29 @@ export const directivesSet = new Set([
 
 /* from the getCommentedDirectiveFromImportedModule utility */
 
+/** @type {readonly [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]} */
 export const directivesArray = Array.from(directivesSet);
 
 /* commentedDirectives_4RawImplementations */
 
-// make all four accepted commented directive implementations
-const makeRawCommentedDirectiveV1of4 = (directive) => `// '${directive}'`;
-const makeRawCommentedDirectiveV2of4 = (directive) => `// "${directive}"`;
-const makeRawCommentedDirectiveV3of4 = (directive) => `/* '${directive}' */`;
-const makeRawCommentedDirectiveV4of4 = (directive) => `/* "${directive}" */`;
+// all formatting styles as an array of [prefix, quote, suffix]
+const commentStyles = [
+  [`// `, `'`, ``], // V1: `// 'directive'`
+  [`// `, `"`, ``], // V2: `// "directive"`
+  [`/* `, `'`, ` */`], // V3: `/* 'directive' */`
+  [`/* `, `"`, ` */`], // V4: `/* "directive" */`
+];
 
 /**
  * Makes the array of all four accepted commented directive implementations on a directive basis.
- * @param {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} directive
- * @returns
+ * @param {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} directive The commented directive.
+ * @returns {string[]} The array of formatted commented directives.
  */
-const make4RawImplementations = (directive) => [
-  makeRawCommentedDirectiveV1of4(directive),
-  makeRawCommentedDirectiveV2of4(directive),
-  makeRawCommentedDirectiveV3of4(directive),
-  makeRawCommentedDirectiveV4of4(directive),
-];
+const make4RawImplementations = (directive) =>
+  commentStyles.map(
+    ([prefix, quote, suffix]) =>
+      `${prefix}${quote}${directive}${quote}${suffix}`
+  );
 
 // mapped commented directives to their 4 raw implementations
 export const commentedDirectives_4RawImplementations = Object.freeze({
@@ -152,7 +154,7 @@ export const commentedStrategies_CommentedDirectives = Object.freeze({
  * Makes the intro for each specific import rule violation messages.
  * @param {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} currentFileCommentedDirective The current file's commented directive.
  * @param {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} importedFileCommentedDirective The imported file's commented directive.
- * @returns {string} Returns "[Current file commented modules] are not allowed to import [imported file commented modules]".
+ * @returns {string} Returns "[Current file commented modules] are not allowed to import [imported file commented modules]."
  */
 const makeIntroForSpecificViolationMessage = (
   currentFileCommentedDirective,

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

@@ -28,7 +28,10 @@ import {
   specificFailure,
 } from "../constants/bases.js";
 
-import { resolveImportPath } from "../../../_commons/utilities/helpers.js";
+import {
+  resolveImportPath,
+  highlightFirstLineOfCode,
+} from "../../../_commons/utilities/helpers.js";
 import {
   getCommentedDirectiveFromCurrentModule,
   getVerifiedCommentedDirective,
@@ -37,6 +40,7 @@ import {
   makeMessageFromCommentedDirective,
   findSpecificViolationMessage,
   getStrategizedDirective,
+  addressDirectiveIfAgnosticStrategies,
 } from "./helpers.js";
 
 /* currentFileFlow */
@@ -67,10 +71,7 @@ export const currentFileFlow = (context) => {
   // reports if there is no directive or no valid directive (same, but eventually no directive could have defaults)
   if (!commentedDirective) {
     context.report({
-      loc: {
-        start: { line: 1, column: 0 },
-        end: { line: 1, column: context.sourceCode.lines[0].length },
-      },
+      loc: highlightFirstLineOfCode(context),
       messageId: noCommentedDirective,
     });
     return { skip: true };
@@ -84,10 +85,7 @@ export const currentFileFlow = (context) => {
   // reports if the verification failed
   if (!verifiedCommentedDirective) {
     context.report({
-      loc: {
-        start: { line: 1, column: 0 },
-        end: { line: 1, column: context.sourceCode.lines[0].length },
-      },
+      loc: highlightFirstLineOfCode(context),
       messageId: commentedDirectiveVerificationFailed,
       data: {
         [specificFailure]:
@@ -139,10 +137,11 @@ 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 a @clientLogics strategy could be wrongly imported and interpreted as a @serverLogics strategy.
+  (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 cancelled, 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, 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.
   
+  // (Consequently, details below are currently at the stage of wishful thinking.)
   However, 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 to for all non-type export to be named and PascalCase.) */
   if (importedFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
     const importingFileCommentedDirective = getStrategizedDirective(
@@ -222,27 +221,29 @@ export const allExportsFlow = (
   // does not operate on `export type`
   if (node.exportKind === "type") return;
 
-  if (node.source) {
+  // regular exports scenarios
+  if (!node.source) {
+    addressDirectiveIfAgnosticStrategies(
+      context,
+      node,
+      currentFileCommentedDirective
+    );
+  }
+  // re-exports scenarios
+  else {
     const result = importedFileFlow(context, node);
 
     if (result.skip) return;
     const { importedFileCommentedDirective } = result;
 
-    // ignores if this is NOT an Agnostic Strategies Module
-    // verifies current node export strategy if "use agnostic strategies"
-    if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
-      const exportStrategizedDirective = getStrategizedDirective(context, node);
-
-      if (exportStrategizedDirective === null) {
-        context.report({
-          node,
-          messageId: exportNotStrategized,
-        });
-        return;
-      }
+    const addressedDirective = addressDirectiveIfAgnosticStrategies(
+      context,
+      node,
+      currentFileCommentedDirective
+    );
 
-      currentFileCommentedDirective = exportStrategizedDirective;
-    }
+    if (!addressedDirective) return;
+    else currentFileCommentedDirective = addressedDirective;
 
     if (currentFileCommentedDirective !== importedFileCommentedDirective) {
       context.report({
@@ -255,24 +256,6 @@ export const allExportsFlow = (
           importedFileCommentedDirective,
         },
       });
-      return;
-    }
-  } else {
-    // ignores if this is NOT an Agnostic Strategies Module
-    // verifies current node export strategy if "use agnostic strategies"
-    if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
-      const exportStrategizedDirective = getStrategizedDirective(context, node);
-
-      if (exportStrategizedDirective === null) {
-        context.report({
-          node,
-          messageId: exportNotStrategized,
-        });
-        return;
-      }
-
-      // just to emphasize that this is the same short flow from above
-      currentFileCommentedDirective = exportStrategizedDirective;
     }
   }
 };

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

@@ -190,9 +190,11 @@ 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
+  /** @type {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 | ""} */
   let includedDirective = "";
-  const lengthOne = directivesArray.length;
-  for (let i = 0; i < lengthOne; i++) {
+  const firstLength = directivesArray.length;
+
+  for (let i = 0; i < firstLength; i++) {
     const directive = directivesArray[i];
     if (importedFileFirstLine.includes(directive)) {
       includedDirective = directive;
@@ -203,12 +205,14 @@ export const getCommentedDirectiveFromImportedModule = (resolvedImportPath) => {
   // returns null early if there is none of the directives in the first line
   if (includedDirective === "") return null;
 
+  /** @type {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 | ""} */
   let importFileDirective = "";
-  const lengthTwo =
-    // sucks for that any but, I'm working in JS here
-    commentedDirectives_4RawImplementations[includedDirective].length;
-  for (let i = 0; i < lengthTwo; i++) {
-    const raw = commentedDirectives_4RawImplementations[includedDirective][i];
+  const rawImplementations =
+    commentedDirectives_4RawImplementations[includedDirective];
+  const secondLength = rawImplementations.length;
+
+  for (let i = 0; i < secondLength; i++) {
+    const raw = rawImplementations[i];
     if (raw === importedFileFirstLine) {
       importFileDirective = includedDirective;
       break;
@@ -289,3 +293,33 @@ export const findSpecificViolationMessage = (
     currentFileCommentedDirective,
     importedFileCommentedDirective
   );
+
+/* addressDirectiveIfAgnosticStrategies */
+
+/**
+ * Verifies the current node's export strategy if `"use agnostic strategies"` by reporting `exportNotStrategized` in case an export is not strategized in an Agnostic Strategies Module.
+ * @param {Readonly<import('@typescript-eslint/utils').TSESLint.RuleContext<typeof reExportNotSameMessageId | typeof importBreaksCommentedImportRulesMessageId | typeof noCommentedDirective | typeof commentedDirectiveVerificationFailed | typeof importNotStrategized | typeof exportNotStrategized, []>>} context The ESLint rule's `context` object.
+ * @param {import('@typescript-eslint/types').TSESTree.ExportNamedDeclaration | import('@typescript-eslint/types').TSESTree.ExportAllDeclaration | import('@typescript-eslint/types').TSESTree.ExportDefaultDeclaration} node The ESLint `node` of the rule's current traversal.
+ * @param {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} currentFileCommentedDirective The current file's commented directive.
+ * @returns The commented directive, the addressed strategy (as a commented directive) or null in case of failure.
+ */
+export const addressDirectiveIfAgnosticStrategies = (
+  context,
+  node,
+  currentFileCommentedDirective
+) => {
+  // ignores if not addressing an Agnostic Strategies Module
+  if (currentFileCommentedDirective !== USE_AGNOSTIC_STRATEGIES)
+    return currentFileCommentedDirective;
+
+  const exportStrategizedDirective = getStrategizedDirective(context, node);
+
+  if (exportStrategizedDirective === null) {
+    context.report({
+      node,
+      messageId: exportNotStrategized,
+    });
+  }
+
+  return exportStrategizedDirective; // null indicates failure
+};

package/library/directive21/config.js

@@ -9,6 +9,8 @@ import {
 
 /**
  * Makes the directive21 config for the use-agnostic ESLint plugin.
+ * @param {import('eslint').ESLint.Plugin} plugin The use-agnostic ESLint plugin itself.
+ * @returns The directive21 config's name as a key and its config as its value.
  */
 export const makeDirective21Config = (plugin) => ({
   [directive21ConfigName]: defineConfig([

package/package.json

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