eslint-plugin-use-agnostic 1.3.6 → 1.5.0

package/comments.config.js

@@ -12,9 +12,22 @@ export const data = Object.freeze({
 
 const ignores = [];
 
+const composedVariablesExclusives = [
+  "JSDOC#FORCOMPOSEDVARIABLES#AGNOSTIC20",
+  "JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVE21",
+  "JSDOC#FORCOMPOSEDVARIABLES#RESOLVED",
+  "JSDOC#FORCOMPOSEDVARIABLES#EFFECTIVE",
+  "JSDOC#FORCOMPOSEDVARIABLES#COMMENTED",
+  "JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVE",
+  "JSDOC#FORCOMPOSEDVARIABLES#DIRECTIVES",
+  "JSDOC#FORCOMPOSEDVARIABLES#INITIALTHE",
+  "TESTS#FORCOMPOSEDVARIABLES#MODULE",
+];
+
 const config = {
   data,
   ignores,
+  composedVariablesExclusives,
 };
 
 export default config;

package/comments.config.json

@@ -165,7 +165,7 @@
           "placeholder": "$COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#GETVERIFIEDCOMMENTEDDIRECTIVE"
         },
         "getStrategizedDirective": {
-          "value": "Gets the interpreted directive from a specified commented Strategy (such as `@serverLogics`) nested inside the import declaration for an import from an Agnostic Strategies Module.",
+          "value": "Gets the interpreted directive from a specified commented Strategy (such as `@serverLogics`) nested inside the import (or export) declaration for an import (or export) from an Agnostic Strategies Module.",
           "key": "JSDOC#DEFINITIONS#DIRECTIVE21#GETSTRATEGIZEDDIRECTIVE",
           "placeholder": "$COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#GETSTRATEGIZEDDIRECTIVE"
         },
@@ -1652,6 +1652,26 @@
       }
     },
     "forComposedVariables": {
+      "shouldNeverClient": {
+        "value": "should never leak to the client.",
+        "key": "AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERCLIENT",
+        "placeholder": "$COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERCLIENT"
+      },
+      "shouldNeverServer": {
+        "value": "should never leak to the server.",
+        "key": "AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERSERVER",
+        "placeholder": "$COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERSERVER"
+      },
+      "runServerLikeClient": {
+        "value": "can run safely on the server just like they can on the client.",
+        "key": "AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNSERVERLIKECLIENT",
+        "placeholder": "$COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNSERVERLIKECLIENT"
+      },
+      "runClientLikeServer": {
+        "value": "can run safely on the client just like they can on the server.",
+        "key": "AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNCLIENTLIKESERVER",
+        "placeholder": "$COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNCLIENTLIKESERVER"
+      },
       "canComposeOneAnother": {
         "value": "can compose with one another.",
         "key": "AGNOSTIC20#FORCOMPOSEDVARIABLES#CANCOMPOSEONEANOTHER",
@@ -2643,6 +2663,26 @@
       }
     },
     "forComposedVariables": {
+      "shouldNeverClient": {
+        "value": "should never leak to the client.",
+        "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#SHOULDNEVERCLIENT",
+        "placeholder": "$COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#SHOULDNEVERCLIENT"
+      },
+      "shouldNeverServer": {
+        "value": "should never leak to the server.",
+        "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#SHOULDNEVERSERVER",
+        "placeholder": "$COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#SHOULDNEVERSERVER"
+      },
+      "runServerLikeClient": {
+        "value": "can run safely on the server just like they can on the client.",
+        "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#RUNSERVERLIKECLIENT",
+        "placeholder": "$COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RUNSERVERLIKECLIENT"
+      },
+      "runClientLikeServer": {
+        "value": "can run safely on the client just like they can on the server.",
+        "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#RUNCLIENTLIKESERVER",
+        "placeholder": "$COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RUNCLIENTLIKESERVER"
+      },
       "canComposeOneAnother": {
         "value": "can compose with one another.",
         "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCOMPOSEONEANOTHER",
@@ -2773,15 +2813,15 @@
         "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCLIENTCOMPONENTS",
         "placeholder": "$COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCLIENTCOMPONENTS"
       },
-      "canServerLikeClient": {
+      "renderServerLikeClient": {
         "value": "can render safely on the server just like they can on the client.",
-        "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#CANSERVERLIKECLIENT",
-        "placeholder": "$COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANSERVERLIKECLIENT"
+        "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERSERVERLIKECLIENT",
+        "placeholder": "$COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERSERVERLIKECLIENT"
       },
-      "canClientLikeServer": {
+      "renderClientLikeServer": {
         "value": "can render safely on the client just like they can on the server.",
-        "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCLIENTLIKESERVER",
-        "placeholder": "$COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCLIENTLIKESERVER"
+        "key": "DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERCLIENTLIKESERVER",
+        "placeholder": "$COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERCLIENTLIKESERVER"
       }
     }
   }

package/jscomments/_commons/constants/bases.js

@@ -1,3 +1,5 @@
+// now obsolete
+
 import url from "url";
 import path from "path";
 

package/jscomments/_commons/constants/data.js

@@ -0,0 +1,6 @@
+/** @typedef {import("../../../comments.config.mjs").ResolvedConfigData} ResolvedConfigData */
+
+import { resolvedConfigData } from "../../../comments.config.mjs";
+
+/** @type {ResolvedConfigData} */
+export const commentVariablesData = resolvedConfigData;

package/jscomments/agnostic20/comments.js

@@ -18,13 +18,13 @@ export const agnostic20Comments = Object.freeze({
   "use agnostic components": agnosticComponentsComments,
   forAliasVariables: Object.freeze({
     serverNeverClient:
-      "Server Logics should never leak to the client." /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#SERVERNEVERCLIENT */,
+      "$COMMENT#AGNOSTIC20#USE_SERVER_LOGICS#KINDS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERCLIENT" /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#SERVERNEVERCLIENT */,
     clientNeverServer:
-      "Client Logics should never leak to the server." /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#CLIENTNEVERSERVER */,
+      "$COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#KINDS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERSERVER" /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#CLIENTNEVERSERVER */,
     agnosticCanServerClient:
-      "Agnostic Logics can run safely on the server just like they can on the client." /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#AGNOSTICCANSERVERCLIENT */,
+      "$COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#KINDS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNSERVERLIKECLIENT" /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#AGNOSTICCANSERVERCLIENT */,
     agnosticCanClientServer:
-      "Agnostic Logics can run safely on the client just like they can on the server." /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#AGNOSTICCANCLIENTSERVER */,
+      "$COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#KINDS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNCLIENTLIKESERVER" /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#AGNOSTICCANCLIENTSERVER */,
     serverFunctionsNoComponents:
       "Server Functions have no business working with React Components." /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#SERVERFUNCTIONSNOCOMPONENTS */,
     serverLogicsCantBoth:
@@ -33,6 +33,14 @@ export const agnostic20Comments = Object.freeze({
       "$COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#KINDS $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#CANTSERVERCLIENT" /* $COMMENT#AGNOSTIC20#FORALIASVARIABLES#CLIENTLOGICSCANTBOTH */,
   }),
   forComposedVariables: Object.freeze({
+    shouldNeverClient:
+      "should never leak to the client." /* $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERCLIENT */,
+    shouldNeverServer:
+      "should never leak to the server." /* $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERSERVER */,
+    runServerLikeClient:
+      "can run safely on the server just like they can on the client." /* $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNSERVERLIKECLIENT */,
+    runClientLikeServer:
+      "can run safely on the client just like they can on the server." /* $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNCLIENTLIKESERVER */,
     canComposeOneAnother:
       "can compose with one another." /* $COMMENT#AGNOSTIC20#FORCOMPOSEDVARIABLES#CANCOMPOSEONEANOTHER */,
     cantTinkeredServer:

package/jscomments/directive21/comments.js

@@ -24,13 +24,13 @@ export const directive21Comments = Object.freeze({
   "use agnostic strategies": agnosticStrategiesComments,
   forAliasVariables: Object.freeze({
     serverNeverClient:
-      "Prime Server Logics should never leak to the client." /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERNEVERCLIENT */,
+      "$COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#SHOULDNEVERCLIENT" /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERNEVERCLIENT */,
     clientNeverServer:
-      "Prime Client Logics should never leak to the server." /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#CLIENTNEVERSERVER */,
+      "$COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#SHOULDNEVERSERVER" /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#CLIENTNEVERSERVER */,
     agnosticCanServerClient:
-      "Prime Agnostic Logics can run safely on the server just like they can on the client." /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANSERVERCLIENT */,
+      "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RUNSERVERLIKECLIENT" /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANSERVERCLIENT */,
     agnosticCanClientServer:
-      "Prime Agnostic Logics can run safely on the client just like they can on the server." /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANCLIENTSERVER */,
+      "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RUNCLIENTLIKESERVER" /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCANCLIENTSERVER */,
     serverFunctionsNoComponents:
       "(Special) Server Functions have no business working with React Components." /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERFUNCTIONSNOCOMPONENTS */,
     serverLogicsCantBoth:
@@ -40,11 +40,19 @@ export const directive21Comments = Object.freeze({
     agnosticComponentsCanAny:
       "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANANYPRIMELOGICS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#NOEXPORTCOMPONENTS" /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCOMPONENTSCANANY */,
     agnosticComponentsRenderAny:
-      "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCLIENTLIKESERVER" /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCOMPONENTSRENDERANY */,
+      "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERCLIENTLIKESERVER" /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCOMPONENTSRENDERANY */,
     serverFunctionsClient:
       "$COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCLIENTCOMPONENTS" /* $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERFUNCTIONSCLIENT */,
   }),
   forComposedVariables: Object.freeze({
+    shouldNeverClient:
+      "AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERCLIENT" /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#SHOULDNEVERCLIENT */,
+    shouldNeverServer:
+      "AGNOSTIC20#FORCOMPOSEDVARIABLES#SHOULDNEVERSERVER" /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#SHOULDNEVERSERVER */,
+    runServerLikeClient:
+      "AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNSERVERLIKECLIENT" /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RUNSERVERLIKECLIENT */,
+    runClientLikeServer:
+      "AGNOSTIC20#FORCOMPOSEDVARIABLES#RUNCLIENTLIKESERVER" /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RUNCLIENTLIKESERVER */,
     canComposeOneAnother:
       "AGNOSTIC20#FORCOMPOSEDVARIABLES#CANCOMPOSEONEANOTHER" /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCOMPOSEONEANOTHER */,
     cantTinkeredServer:
@@ -97,9 +105,11 @@ export const directive21Comments = Object.freeze({
       "when the root of the application is planted on the server." /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#WHENROOTONSERVER */,
     canClientComponents:
       "can be specifically triggered by Client Components." /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCLIENTCOMPONENTS */,
-    canServerLikeClient:
-      "can render safely on the server just like they can on the client." /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANSERVERLIKECLIENT */,
-    canClientLikeServer:
-      "can render safely on the client just like they can on the server." /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCLIENTLIKESERVER */,
+    // renderServerLikeClient
+    renderServerLikeClient:
+      "can render safely on the server just like they can on the client." /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERSERVERLIKECLIENT */,
+    // renderClientLikeServer
+    renderClientLikeServer:
+      "can render safely on the client just like they can on the server." /* $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERCLIENTLIKESERVER */,
   }),
 });

package/jscomments/directive21/modules-comments.js

@@ -115,13 +115,13 @@ export const serverComponentsComments = Object.freeze({
   "use client components":
     /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANBENESTEDINSIDE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#TOCREATEBOUNDARIES $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#WHENROOTONSERVER" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_CLIENT_COMPONENTS */,
   "use agnostic components":
-    /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANSERVERLIKECLIENT" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_COMPONENTS */,
+    /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERSERVERLIKECLIENT" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_COMPONENTS */,
   "use server functions":
     /* valid */ "(Special) Server Functions can be passed to imported Client Components within Lineal Server Components Modules, even though indeed Lineal Server Components Modules and Lineal Server Components can make their own Server Functions through inline `'use server'` directives." /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_SERVER_FUNCTIONS */,
   "use client contexts":
     /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANBENESTEDINSIDE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#TOWRAPTREE $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#WHENROOTONSERVER" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_CLIENT_CONTEXTS */,
   "use agnostic conditions":
-    /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ASIFLINEALAGNOSTIC $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANSERVERLIKECLIENT" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_CONDITIONS */,
+    /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ASIFLINEALAGNOSTIC $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERSERVERLIKECLIENT" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_CONDITIONS */,
   kinds:
     "Lineal Server Components" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#KINDS */,
   kindsComma:
@@ -156,7 +156,7 @@ export const clientComponentsComments = Object.freeze({
   "use client contexts":
     /* valid */ "(Special) Client Contexts Components can effectively become Lineal and only render their children on the client via this mechanism since, by a Client Contexts Component being the child of a Lineal Client Component, the Client Contexts Component's children become the grandchildren of an ancestor Lineal Client Component, enforcing them to render exclusively on the client." /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_CLIENT_CONTEXTS */,
   "use agnostic conditions":
-    /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ASIFLINEALAGNOSTIC $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCLIENTLIKESERVER" /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_CONDITIONS */,
+    /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ASIFLINEALAGNOSTIC $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERCLIENTLIKESERVER" /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_CONDITIONS */,
   module:
     "Lineal Client Components Module" /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#MODULE */,
   modulePeriod:

package/jscomments/jsdoc/comments.js

@@ -71,7 +71,7 @@ export const jsDocComments = Object.freeze({
       getVerifiedCommentedDirective:
         "Ensures that a module's commented directive is consistent with its file extension (depending on whether it ends with 'x' for JSX)." /* $COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#GETVERIFIEDCOMMENTEDDIRECTIVE */,
       getStrategizedDirective:
-        "Gets the interpreted directive from a specified commented Strategy (such as `@serverLogics`) nested inside the import declaration for an import from an Agnostic Strategies Module." /* $COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#GETSTRATEGIZEDDIRECTIVE */,
+        "Gets the interpreted directive from a specified commented Strategy (such as `@serverLogics`) nested inside the import (or export) declaration for an import (or export) from an Agnostic Strategies Module." /* $COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#GETSTRATEGIZEDDIRECTIVE */,
       addressDirectiveIfAgnosticStrategies:
         '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.' /* $COMMENT#JSDOC#DEFINITIONS#DIRECTIVE21#ADDRESSDIRECTIVEIFAGNOSTICSTRATEGIES */,
       isImportBlocked:

package/library/_commons/constants/bases.js

@@ -104,14 +104,33 @@ export const resolvedDirectives_resolvedModules =
 // JavaScript/TypeScript extensions
 export const TSX = ".tsx";
 export const TS = ".ts";
+export const MTSX = ".mtsx";
+export const MTS = ".mts";
+export const CTSX = ".ctsx";
+export const CTS = ".cts";
 export const JSX = ".jsx";
 export const JS = ".js";
+export const MJSX = ".mjsx";
 export const MJS = ".mjs";
+export const CJSX = ".cjsx";
 export const CJS = ".cjs";
 
 // JavaScript/TypeScript extensions array
 /** @type {Extensions} */
-export const EXTENSIONS = Object.freeze([TSX, TS, JSX, JS, MJS, CJS]); // In priority order
+export const EXTENSIONS = Object.freeze([
+  TSX,
+  TS,
+  MTSX,
+  MTS,
+  CTSX,
+  CTS,
+  JSX,
+  JS,
+  MJSX,
+  MJS,
+  CJSX,
+  CJS,
+]); // In priority order
 
 // message strings
 export const ARE_NOT_ALLOWED_TO_IMPORT = "are not allowed to import";

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

@@ -11,7 +11,8 @@ import {
 
 import { makeIntroForSpecificViolationMessage } from "../../../_commons/utilities/helpers.js";
 
-import { resolvedConfigData } from "../../../../jscomments/_commons/constants/bases.js";
+// import { resolvedConfigData } from "../../../../jscomments/_commons/constants/bases.js";
+import { commentVariablesData } from "../../../../jscomments/_commons/constants/data.js";
 
 /**
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Directive} Directive
@@ -106,7 +107,7 @@ export const makeBlockedImport = (
       currentFileEffectiveDirective,
       importedFileEffectiveDirective
     )} ${
-      resolvedConfigData[agnostic20ConfigName][currentFileEffectiveDirective][
+      commentVariablesData[agnostic20ConfigName][currentFileEffectiveDirective][
         importedFileEffectiveDirective
       ].value
     }`,
@@ -138,11 +139,6 @@ const makeBlockedImportSuggestingUseAgnostic = (
   });
 };
 
-// The final boss is going to be to building this from the config.
-// Probably in the blocked import thing.
-// But so that means I'm going to need using resolveConfig, or maybe I could give resolveConfig an option that allows it to return the actual config data with all values recursively resolved.
-// That's what I would do, then I would just need to use the object of the config data instead of `jscommentsConfig[agnostic20ConfigName]` for makeBlockedImport.
-// const jscommentsConfigData = makeResolvedConfig(configPath)
 export const effectiveDirectives_blockedImports = Object.freeze({
   [USE_SERVER_LOGICS]: Object.freeze([
     // USE_SERVER_LOGICS allowed, because Server Logics can compose with one another.

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

@@ -14,7 +14,8 @@ import {
 
 import { makeIntroForSpecificViolationMessage } from "../../../_commons/utilities/helpers.js";
 
-import { resolvedConfigData } from "../../../../jscomments/_commons/constants/bases.js";
+// import { resolvedConfigData } from "../../../../jscomments/_commons/constants/bases.js";
+import { commentVariablesData } from "../../../../jscomments/_commons/constants/data.js";
 
 /**
  * @typedef {import('../../../../types/directive21/_commons/typedefs.js').CommentedDirective} CommentedDirective
@@ -67,7 +68,9 @@ export const commentedDirectives_extensionRules = Object.freeze({
   [USE_SERVER_FUNCTIONS]: false,
   [USE_CLIENT_CONTEXTS]: true,
   [USE_AGNOSTIC_CONDITIONS]: true,
-  [USE_AGNOSTIC_STRATEGIES]: null, // Any extension allowed
+  // CHANGE: Agnostic Strategies Modules must now be JSX modules (ending in `x`) in order to conform with eXtra JSX, and moreover to assert their capacity to adapt with both logics and components.
+  // [USE_AGNOSTIC_STRATEGIES]: null, // Any extension allowed
+  [USE_AGNOSTIC_STRATEGIES]: true,
 });
 
 // commented strategies
@@ -83,7 +86,7 @@ export const AT_AGNOSTIC_CONDITIONS = "@agnosticConditions";
 
 // commented strategies array
 /** @type {CommentedStrategies} */
-export const strategiesArray = Object.freeze([
+export const commentedStrategiesArray = Object.freeze([
   AT_SERVER_LOGICS,
   AT_CLIENT_LOGICS,
   AT_AGNOSTIC_LOGICS,
@@ -97,7 +100,7 @@ export const strategiesArray = Object.freeze([
 
 // commented strategies set
 /** @type {ReadonlySet<CommentedStrategy>} */
-export const strategiesSet = new Set(strategiesArray); // no longer used exported to satisfy static type inference
+export const commentedStrategiesSet = new Set(commentedStrategiesArray); // no longer used exported to satisfy static type inference
 
 // mapped commented strategies to their commented directives
 export const commentedStrategies_commentedDirectives = Object.freeze({
@@ -160,9 +163,9 @@ export const makeBlockedImport = (
       currentFileCommentedDirective,
       importedFileCommentedDirective
     )} ${
-      resolvedConfigData[directive21ConfigName][currentFileCommentedDirective][
-        importedFileCommentedDirective
-      ].value
+      commentVariablesData[directive21ConfigName][
+        currentFileCommentedDirective
+      ][importedFileCommentedDirective].value
     }`,
   });
 };

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

@@ -4,7 +4,7 @@ import { exportNotStrategized } from "../../../_commons/constants/bases.js";
 import {
   USE_AGNOSTIC_STRATEGIES,
   commentedDirectivesArray,
-  strategiesArray,
+  commentedStrategiesArray,
   commentedDirectives_extensionRules,
   commentedStrategies_commentedDirectives,
   commentedDirectives_blockedImports,
@@ -201,7 +201,8 @@ export const getVerifiedCommentedDirective = (directive, extension) => {
 
   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"
+  // CHANGE: no longer applies, Agnostic Strategies Modules are now required to ends in `x`.
+  // if (rule === null) return directive; // no extension constraint, specifically for "use agnostic strategies"
 
   return null; // verification failed
 };
@@ -209,9 +210,9 @@ export const getVerifiedCommentedDirective = (directive, extension) => {
 /* getStrategizedDirective */
 
 /**
- * Gets the interpreted directive from a specified commented Strategy (such as `@serverLogics`) nested inside the import declaration for an import from an Agnostic Strategies Module.
+ * Gets the interpreted directive from a specified commented Strategy (such as `@serverLogics`) nested inside the import (or export) declaration for an import (or export) from an Agnostic Strategies Module.
  * @param {Context} context The ESLint rule's `context` object.
- * @param {ImportDeclaration} node The ESLint `node` of the rule's current traversal.
+ * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ExportDefaultDeclaration} node The ESLint `node` of the rule's current traversal.
  * @returns The interpreted directive, a.k.a. strategized directive, or lack thereof via `null`.
  */
 export const getStrategizedDirective = (context, node) => {
@@ -226,7 +227,8 @@ export const getStrategizedDirective = (context, node) => {
 
   // asserts whether that first nested comment is or isn't a Strategy
   const strategy =
-    strategiesArray.find((strategy) => strategy === rawStrategy) ?? null;
+    commentedStrategiesArray.find((strategy) => strategy === rawStrategy) ??
+    null;
 
   // returns null early if no strategy was identified
   if (!strategy) return null;

package/library/index.js

@@ -45,3 +45,76 @@ export {
   enforceEffectiveDirectivesRuleName,
   enforceCommentedDirectivesRuleName,
 } from "./_commons/constants/bases.js";
+
+// NEW: eslint-plugin-use-agnostic is effectively the premier implementation of the Directive-First Architecture. As such, the following imports are to access its constants and utilities across other implementations of the Directive-First Architecture, such as eXtra JSX.
+
+// agnostic20
+
+export {
+  // directives
+  NO_DIRECTIVE,
+  USE_SERVER,
+  USE_CLIENT,
+  USE_AGNOSTIC,
+  // directives array
+  directivesArray,
+  // directives set
+  directivesSet,
+  // mapping directives with effective directives
+  directives_effectiveDirectives,
+} from "./agnostic20/_commons/constants/bases.js";
+
+export {
+  getDirectiveFromModule,
+  getDirectiveFromCurrentModule,
+  getDirectiveFromImportedModule,
+  getEffectiveDirective,
+  isImportBlocked as isImportBlockedAgnostic20,
+} from "./agnostic20/_commons/utilities/helpers.js";
+
+// directive21
+
+export {
+  // commented directives
+  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,
+  // commented directives array
+  commentedDirectivesArray,
+  // commented directives set
+  commentedDirectivesSet,
+  // mapped commented directives to their extension rules
+  commentedDirectives_extensionRules,
+  // commented strategies
+  AT_SERVER_LOGICS,
+  AT_CLIENT_LOGICS,
+  AT_AGNOSTIC_LOGICS,
+  AT_SERVER_COMPONENTS,
+  AT_CLIENT_COMPONENTS,
+  AT_AGNOSTIC_COMPONENTS,
+  AT_SERVER_FUNCTIONS,
+  AT_CLIENT_CONTEXTS,
+  AT_AGNOSTIC_CONDITIONS,
+  // commented strategies array
+  commentedStrategiesArray,
+  // commented strategies set
+  commentedStrategiesSet,
+  // mapped commented strategies to their commented directives
+  commentedStrategies_commentedDirectives,
+} from "./directive21/_commons/constants/bases.js";
+
+export {
+  getCommentedDirectiveFromSourceCode,
+  getCommentedDirectiveFromCurrentModule,
+  getCommentedDirectiveFromImportedModule,
+  getVerifiedCommentedDirective,
+  getStrategizedDirective,
+  isImportBlocked as isImportBlockedDirective21,
+} from "./directive21/_commons/utilities/helpers.js";

package/package.json

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

package/types/index.d.ts

@@ -1,4 +1,9 @@
-import type { ESLint } from "eslint";
+import type { ESLint, SourceCode as ESLintSourceCode } from "eslint";
+import type {
+  SourceCode as TSESLintSourceCode,
+  RuleContext,
+} from "@typescript-eslint/utils/dist/ts-eslint";
+import type { TSESTree } from "@typescript-eslint/types";
 
 declare const plugin: ESLint.Plugin;
 
@@ -10,3 +15,465 @@ export const agnostic20ConfigName: "agnostic20";
 export const directive21ConfigName: "directive21";
 export const enforceEffectiveDirectivesRuleName: "enforce-effective-directives-import-rules";
 export const enforceCommentedDirectivesRuleName: "enforce-commented-directives-import-rules";
+
+// NEW
+
+// agnostic20
+
+// directives
+export const NO_DIRECTIVE: "no directive";
+export const USE_SERVER: "use server";
+export const USE_CLIENT: "use client";
+export const USE_AGNOSTIC: "use agnostic";
+
+// directives array
+export const directivesArray: readonly [
+  typeof USE_SERVER,
+  typeof USE_CLIENT,
+  typeof USE_AGNOSTIC
+];
+
+// directives set
+export const directivesSet: ReadonlySet<
+  typeof USE_SERVER | typeof USE_CLIENT | typeof USE_AGNOSTIC
+>;
+
+// mapping directives with effective directives
+export const directives_effectiveDirectives: Readonly<{
+  [NO_DIRECTIVE]: Readonly<{
+    logics: "use server logics";
+    components: "use server components";
+    functions: null;
+  }>;
+  [USE_SERVER]: Readonly<{
+    logics: null;
+    components: null;
+    functions: "use server functions";
+  }>;
+  [USE_CLIENT]: Readonly<{
+    logics: "use client logics";
+    components: "use client components";
+    functions: null;
+  }>;
+  [USE_AGNOSTIC]: Readonly<{
+    logics: "use agnostic logics";
+    components: "use agnostic components";
+    functions: null;
+  }>;
+}>;
+
+/**
+ * Gets the directive of a module from its Abstract Syntax Tree.
+ * - `null` denotes a server-by-default module, ideally a Server Module.
+ * - `'use server'` denotes a Server Functions Module.
+ * - `'use client'` denotes a Client Module.
+ * - `'use agnostic'` denotes an Agnostic Module (formerly Shared Module).
+ * @param ast The module's AST (Abstract Syntax Tree).
+ * @returns The directive, or lack thereof via `null`. The lack of a directive is considered server-by-default.
+ */
+export const getDirectiveFromModule: (
+  ast: TSESLintSourceCode.Program
+) => "use server" | "use client" | "use agnostic" | null;
+
+/**
+ * Gets the directive of the current module.
+ * - `null` denotes a server-by-default module, ideally a Server Module.
+ * - `'use server'` denotes a Server Functions Module.
+ * - `'use client'` denotes a Client Module.
+ * - `'use agnostic'` denotes an Agnostic Module (formerly Shared Module).
+ * @param context The ESLint rule's `context` object.
+ * @returns The directive, or lack thereof via `null`. The lack of a directive is considered server-by-default.
+ */
+export const getDirectiveFromCurrentModule: (
+  context: RuleContext<string, readonly unknown[]>
+) => "use server" | "use client" | "use agnostic" | null;
+
+/**
+ * Gets the directive of the imported module.
+ * - `null` denotes a server-by-default module, ideally a Server Module.
+ * - `'use server'` denotes a Server Functions Module.
+ * - `'use client'` denotes a Client Module.
+ * - `'use agnostic'` denotes an Agnostic Module (formerly Shared Module).
+ * @param resolvedPath The resolved path of the imported module.
+ * @returns The directive, or lack thereof via `null`. The lack of a directive is considered server-by-default.
+ */
+export const getDirectiveFromImportedModule: (
+  resolvedPath: string
+) => "use server" | "use client" | "use agnostic" | null;
+
+/**
+ * Gets the effective directive of a module, based on the combination of its directive (or lack thereof) and its extension (depending on whether it ends with 'x' for JSX).
+ * - `'use server logics'` denotes a Server Logics Module.
+ * - `'use server components'` denotes a Server Components Module.
+ * - `'use server functions'` denotes a Server Functions Module.
+ * - `'use client logics'` denotes a Client Logics Module.
+ * - `'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 The directive as written on top of the file (`"no directive"` if no valid directive).
+ * @param extension The JavaScript (TypeScript) extension of the file.
+ * @returns The effective directive, from which imports rules are applied.
+ */
+export const getEffectiveDirective: (
+  directive: "use server" | "use client" | "use agnostic" | "no directive",
+  extension:
+    | ".tsx"
+    | ".ts"
+    | ".mtsx"
+    | ".mts"
+    | ".ctsx"
+    | ".cts"
+    | ".jsx"
+    | ".js"
+    | ".mjsx"
+    | ".mjs"
+    | ".cjsx"
+    | ".cjs"
+) =>
+  | "use server logics"
+  | "use server components"
+  | "use server functions"
+  | "use client logics"
+  | "use client components"
+  | "use agnostic logics"
+  | "use agnostic components"
+  | null;
+
+/**
+ * Returns a boolean deciding if an imported file's effective directive is incompatible with the current file's effective directive.
+ * @param currentFileEffectiveDirective The current file's effective directive.
+ * @param importedFileEffectiveDirective The imported file's effective directive.
+ * @returns `true` if the import is blocked, as established in `effectiveDirectives_BlockedImports`.
+ */
+export const isImportBlockedAgnostic20: (
+  currentFileEffectiveDirective:
+    | "use server logics"
+    | "use server components"
+    | "use server functions"
+    | "use client logics"
+    | "use client components"
+    | "use agnostic logics"
+    | "use agnostic components",
+  importedFileEffectiveDirective:
+    | "use server logics"
+    | "use server components"
+    | "use server functions"
+    | "use client logics"
+    | "use client components"
+    | "use agnostic logics"
+    | "use agnostic components"
+) => boolean;
+
+// directive21
+
+// commented directives
+export const USE_SERVER_LOGICS: "use server logics";
+export const USE_CLIENT_LOGICS: "use client logics";
+export const USE_AGNOSTIC_LOGICS: "use agnostic logics";
+export const USE_SERVER_COMPONENTS: "use server components";
+export const USE_CLIENT_COMPONENTS: "use client components";
+export const USE_AGNOSTIC_COMPONENTS: "use agnostic components";
+export const USE_SERVER_FUNCTIONS: "use server functions";
+export const USE_CLIENT_CONTEXTS: "use client contexts";
+export const USE_AGNOSTIC_CONDITIONS: "use agnostic conditions";
+export const USE_AGNOSTIC_STRATEGIES: "use agnostic strategies";
+
+// commented directives array
+export const commentedDirectivesArray: readonly [
+  typeof USE_SERVER_LOGICS,
+  typeof USE_CLIENT_LOGICS,
+  typeof USE_AGNOSTIC_LOGICS,
+  typeof USE_SERVER_COMPONENTS,
+  typeof USE_CLIENT_COMPONENTS,
+  typeof USE_AGNOSTIC_COMPONENTS,
+  typeof USE_SERVER_FUNCTIONS,
+  typeof USE_CLIENT_CONTEXTS,
+  typeof USE_AGNOSTIC_CONDITIONS,
+  typeof USE_AGNOSTIC_STRATEGIES
+];
+
+// commented directives set
+export const commentedDirectivesSet: ReadonlySet<
+  | typeof USE_SERVER_LOGICS
+  | typeof USE_CLIENT_LOGICS
+  | typeof USE_AGNOSTIC_LOGICS
+  | typeof USE_SERVER_COMPONENTS
+  | typeof USE_CLIENT_COMPONENTS
+  | typeof USE_AGNOSTIC_COMPONENTS
+  | typeof USE_SERVER_FUNCTIONS
+  | typeof USE_CLIENT_CONTEXTS
+  | typeof USE_AGNOSTIC_CONDITIONS
+  | typeof USE_AGNOSTIC_STRATEGIES
+>;
+
+// mapped commented directives to their extension rules
+/**
+ * - `true` means requires the presence of a JSX extension (`.jsx`)
+ * - `false` means requires the absence of a JSX extension (`.js`)
+ * */
+export const commentedDirectives_extensionRules: Readonly<{
+  [USE_SERVER_LOGICS]: false;
+  [USE_CLIENT_LOGICS]: false;
+  [USE_AGNOSTIC_LOGICS]: false;
+  [USE_SERVER_COMPONENTS]: true;
+  [USE_CLIENT_COMPONENTS]: true;
+  [USE_AGNOSTIC_COMPONENTS]: true;
+  [USE_SERVER_FUNCTIONS]: false;
+  [USE_CLIENT_CONTEXTS]: true;
+  [USE_AGNOSTIC_CONDITIONS]: true;
+  [USE_AGNOSTIC_STRATEGIES]: true;
+}>;
+
+// commented strategies
+export const AT_SERVER_LOGICS: "@serverLogics";
+export const AT_CLIENT_LOGICS: "@clientLogics";
+export const AT_AGNOSTIC_LOGICS: "@agnosticLogics";
+export const AT_SERVER_COMPONENTS: "@serverComponents";
+export const AT_CLIENT_COMPONENTS: "@clientComponents";
+export const AT_AGNOSTIC_COMPONENTS: "@agnosticComponents";
+export const AT_SERVER_FUNCTIONS: "@serverFunctions";
+export const AT_CLIENT_CONTEXTS: "@clientContexts";
+export const AT_AGNOSTIC_CONDITIONS: "@agnosticConditions";
+
+// commented strategies array
+export const commentedStrategiesArray: readonly [
+  typeof AT_SERVER_LOGICS,
+  typeof AT_CLIENT_LOGICS,
+  typeof AT_AGNOSTIC_LOGICS,
+  typeof AT_SERVER_COMPONENTS,
+  typeof AT_CLIENT_COMPONENTS,
+  typeof AT_AGNOSTIC_COMPONENTS,
+  typeof AT_SERVER_FUNCTIONS,
+  typeof AT_CLIENT_CONTEXTS,
+  typeof AT_AGNOSTIC_CONDITIONS
+];
+
+// commented strategies set
+export const commentedStrategiesSet: ReadonlySet<
+  | typeof AT_SERVER_LOGICS
+  | typeof AT_CLIENT_LOGICS
+  | typeof AT_AGNOSTIC_LOGICS
+  | typeof AT_SERVER_COMPONENTS
+  | typeof AT_CLIENT_COMPONENTS
+  | typeof AT_AGNOSTIC_COMPONENTS
+  | typeof AT_SERVER_FUNCTIONS
+  | typeof AT_CLIENT_CONTEXTS
+  | typeof AT_AGNOSTIC_CONDITIONS
+>;
+
+// mapped commented strategies to their commented directives
+export const commentedStrategies_commentedDirectives: Readonly<{
+  [AT_SERVER_LOGICS]: "use server logics";
+  [AT_CLIENT_LOGICS]: "use client logics";
+  [AT_AGNOSTIC_LOGICS]: "use agnostic logics";
+  [AT_SERVER_COMPONENTS]: "use server components";
+  [AT_CLIENT_COMPONENTS]: "use client components";
+  [AT_AGNOSTIC_COMPONENTS]: "use agnostic components";
+  [AT_SERVER_FUNCTIONS]: "use server functions";
+  [AT_CLIENT_CONTEXTS]: "use client contexts";
+  [AT_AGNOSTIC_CONDITIONS]: "use agnostic conditions";
+}>;
+
+/**
+ * Gets the commented directive of a module from its ESLint `SourceCode` object.
+ *
+ * Accepted directives for the default Directive-First Architecture are (single or double quotes included):
+ * - `'use server logics'`, `"use server logics"` denoting a Server Logics Module.
+ * - `'use client logics'`, `"use client logics"` denoting a Client Logics Module.
+ * - `'use agnostic logics'`, `"use agnostic logics"` denoting an Agnostic Logics Module.
+ * - `'use server components'`, `"use server components"` denoting a Server Components Module.
+ * - `'use client components'`, `"use client components"` denoting a Client Components Module.
+ * - `'use agnostic components'`, `"use agnostic components"` denoting an Agnostic Components Module.
+ * - `'use server functions'`, `"use server functions"` denoting a Server Functions Module.
+ * - `'use client contexts'`, `"use client contexts"` denoting a Client Contexts Module.
+ * - `'use agnostic conditions'`, `"use agnostic conditions"` denoting an Agnostic Conditions Module.
+ * - `'use agnostic strategies'`, `"use agnostic strategies"` denoting an Agnostic Strategies Module.
+ * @param sourceCode The ESLint SourceCode object.
+ * @returns The commented directive, or lack thereof via `null`. Given the strictness of this architecture, the lack of a directive is considered a mistake. (Though rules may provide the opportunity to declare a default, and configs with preset defaults may become provided.)
+ */
+export const getCommentedDirectiveFromSourceCode: (
+  sourceCode: ESLintSourceCode
+) =>
+  | "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"
+  | null;
+
+/**
+ * Gets the commented directive of the current module.
+ *
+ * Accepted directives for the default Directive-First Architecture are (single or double quotes included):
+ * - `'use server logics'`, `"use server logics"` denoting a Server Logics Module.
+ * - `'use client logics'`, `"use client logics"` denoting a Client Logics Module.
+ * - `'use agnostic logics'`, `"use agnostic logics"` denoting an Agnostic Logics Module.
+ * - `'use server components'`, `"use server components"` denoting a Server Components Module.
+ * - `'use client components'`, `"use client components"` denoting a Client Components Module.
+ * - `'use agnostic components'`, `"use agnostic components"` denoting an Agnostic Components Module.
+ * - `'use server functions'`, `"use server functions"` denoting a Server Functions Module.
+ * - `'use client contexts'`, `"use client contexts"` denoting a Client Contexts Module.
+ * - `'use agnostic conditions'`, `"use agnostic conditions"` denoting an Agnostic Conditions Module.
+ * - `'use agnostic strategies'`, `"use agnostic strategies"` denoting an Agnostic Strategies Module.
+ * @param context The ESLint rule's `context` object.
+ * @returns The commented directive, or lack thereof via `null`. Given the strictness of this architecture, the lack of a directive is considered a mistake. (Though rules may provide the opportunity to declare a default, and configs with preset defaults may become provided.)
+ */
+export const getCommentedDirectiveFromCurrentModule: (
+  context: RuleContext<string, readonly unknown[]>
+) =>
+  | "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"
+  | null;
+
+/**
+ * Gets the commented directive of the imported module.
+ *
+ * Accepted directives for the default Directive-First Architecture are (single or double quotes included):
+ * - `'use server logics'`, `"use server logics"` denoting a Server Logics Module.
+ * - `'use client logics'`, `"use client logics"` denoting a Client Logics Module.
+ * - `'use agnostic logics'`, `"use agnostic logics"` denoting an Agnostic Logics Module.
+ * - `'use server components'`, `"use server components"` denoting a Server Components Module.
+ * - `'use client components'`, `"use client components"` denoting a Client Components Module.
+ * - `'use agnostic components'`, `"use agnostic components"` denoting an Agnostic Components Module.
+ * - `'use server functions'`, `"use server functions"` denoting a Server Functions Module.
+ * - `'use client contexts'`, `"use client contexts"` denoting a Client Contexts Module.
+ * - `'use agnostic conditions'`, `"use agnostic conditions"` denoting an Agnostic Conditions Module.
+ * - `'use agnostic strategies'`, `"use agnostic strategies"` denoting an Agnostic Strategies Module.
+ * @param resolvedPath The resolved path of the imported module.
+ * @returns The commented directive, or lack thereof via `null`. Given the strictness of this architecture, the lack of a directive is considered a mistake. (Though rules may provide the opportunity to declare a default, and configs with preset defaults may become provided.)
+ */
+export const getCommentedDirectiveFromImportedModule: (
+  resolvedPath: string
+) =>
+  | "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"
+  | null;
+
+/**
+ * Ensures that a module's commented directive is consistent with its file extension (depending on whether it ends with 'x' for JSX).
+ * - `'use server logics'`: Server Logics Modules do NOT export JSX.
+ * - `'use client logics'`: Client Logics Modules do NOT export JSX.
+ * - `'use agnostic logics'`: Agnostic Logics Modules do NOT export JSX.
+ * - `'use server components'`: Server Components Modules ONLY export JSX.
+ * - `'use client components'`: Client Components Modules ONLY export JSX.
+ * - `'use agnostic components'`: Agnostic Components Modules ONLY export JSX.
+ * - `'use server functions'`: Server Functions Modules do NOT export JSX.
+ * - `'use client contexts'`: Client Contexts Modules ONLY export JSX.
+ * - `'use agnostic conditions'`: Agnostic Conditions Modules ONLY export JSX.
+ * - `'use agnostic strategies'`: Agnostic Strategies Modules may export JSX.
+ * @param directive The commented directive as written on top of the file (cannot be `null` at that stage).
+ * @param 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.
+ */
+export const getVerifiedCommentedDirective: (
+  directive:
+    | "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",
+  extension:
+    | ".tsx"
+    | ".ts"
+    | ".mtsx"
+    | ".mts"
+    | ".ctsx"
+    | ".cts"
+    | ".jsx"
+    | ".js"
+    | ".mjsx"
+    | ".mjs"
+    | ".cjsx"
+    | ".cjs"
+) =>
+  | "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"
+  | null;
+
+/**
+ * Gets the interpreted directive from a specified commented Strategy (such as `@serverLogics`) nested inside the import (or export) declaration for an import (or export) from an Agnostic Strategies Module.
+ * @param context The ESLint rule's `context` object.
+ * @param node The ESLint `node` of the rule's current traversal.
+ * @returns The interpreted directive, a.k.a. strategized directive, or lack thereof via `null`.
+ */
+export const getStrategizedDirective: (
+  context: RuleContext<string, readonly unknown[]>,
+  node:
+    | TSESTree.ImportDeclaration
+    | TSESTree.ExportNamedDeclaration
+    | TSESTree.ExportAllDeclaration
+    | TSESTree.ExportDefaultDeclaration
+) =>
+  | "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"
+  | null;
+
+/**
+ * Returns a boolean deciding if an imported file's commented directive is incompatible with the current file's commented directive.
+ * @param currentFileCommentedDirective The current file's commented directive.
+ * @param importedFileCommentedDirective The imported file's commented directive.
+ * @returns `true` if the import is blocked, as established in `commentedDirectives_BlockedImports`.
+ */
+export const isImportBlockedDirective21: (
+  currentFileCommentedDirective:
+    | "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:
+    | "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"
+) => boolean;