eslint-plugin-use-agnostic 1.3.5 → 1.4.1

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"
         },

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

@@ -138,11 +138,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

@@ -67,7 +67,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 +85,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 +99,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({

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.5",
+  "version": "1.4.1",
   "description": "Highlights problematic server-client imports in projects made with the Fullstack React Architecture.",
   "keywords": [
     "eslint",
@@ -44,12 +44,12 @@
   "dependencies": {
     "get-sourcecode-from-file-path": "^1.1.2",
     "resolve-importing-path": "^1.0.3",
-    "tsconfig-paths": "^4.2.0",
     "typescript-eslint": "^8.32.0"
   },
   "devDependencies": {
     "@typescript-eslint/utils": "^8.31.1",
     "eslint": ">=9.0.0",
+    "tsconfig-paths": "^4.2.0",
     "typescript": "^5.8.3"
   },
   "peerDependencies": {

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;