eslint-plugin-use-agnostic 0.9.6 → 0.9.8

package/README.md

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

package/library/_commons/constants/bases.js

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import('../../../types/_commons/typedefs').Extensions} Extensions
+ */
+
 /* plugin names */
 // use-agnostic
 export const useAgnosticPluginName = "use-agnostic";
@@ -45,6 +49,7 @@ export const exportNotStrategized =
 // all "resolved" directives (from AIA/agnostic20 & DFA/directive21)
 // - AIA: Agnostic-Included Architecture (agnostic20)
 // - DFA: Directive-First Architecture (directive21)
+// agnostic20
 export const USE_SERVER_LOGICS = "use server logics";
 export const USE_CLIENT_LOGICS = "use client logics";
 export const USE_AGNOSTIC_LOGICS = "use agnostic logics";
@@ -52,11 +57,13 @@ 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";
+// and directive21
 export const USE_CLIENT_CONTEXTS = "use client contexts";
 export const USE_AGNOSTIC_CONDITIONS = "use agnostic conditions";
 export const USE_AGNOSTIC_STRATEGIES = "use agnostic strategies";
 
 // all "resolved" modules (from AIA/agnostic20 & DFA/directive21)
+// agnostic20
 export const SERVER_LOGICS_MODULE = "Server Logics Module";
 export const CLIENT_LOGICS_MODULE = "Client Logics Module";
 export const AGNOSTIC_LOGICS_MODULE = "Agnostic Logics Module";
@@ -64,10 +71,30 @@ export const SERVER_COMPONENTS_MODULE = "Server Components Module";
 export const CLIENT_COMPONENTS_MODULE = "Client Components Module";
 export const AGNOSTIC_COMPONENTS_MODULE = "Agnostic Components Module";
 export const SERVER_FUNCTIONS_MODULE = "Server Functions Module";
+// and directive21
 export const CLIENT_CONTEXTS_MODULE = "Client Contexts Module";
 export const AGNOSTIC_CONDITIONS_MODULE = "Agnostic Conditions Module";
 export const AGNOSTIC_STRATEGIES_MODULE = "Agnostic Strategies Module";
 
+// all mappings of "resolved" directives with "resolved" modules
+// agnostic20
+export const effectiveDirectives_effectiveModules = Object.freeze({
+  [USE_SERVER_LOGICS]: SERVER_LOGICS_MODULE,
+  [USE_SERVER_COMPONENTS]: SERVER_COMPONENTS_MODULE,
+  [USE_SERVER_FUNCTIONS]: SERVER_FUNCTIONS_MODULE,
+  [USE_CLIENT_LOGICS]: CLIENT_LOGICS_MODULE,
+  [USE_CLIENT_COMPONENTS]: CLIENT_COMPONENTS_MODULE,
+  [USE_AGNOSTIC_LOGICS]: AGNOSTIC_LOGICS_MODULE,
+  [USE_AGNOSTIC_COMPONENTS]: AGNOSTIC_COMPONENTS_MODULE,
+});
+// and directive21
+export const commentedDirectives_commentedModules = Object.freeze({
+  [USE_CLIENT_CONTEXTS]: CLIENT_CONTEXTS_MODULE,
+  [USE_AGNOSTIC_CONDITIONS]: AGNOSTIC_CONDITIONS_MODULE,
+  [USE_AGNOSTIC_STRATEGIES]: AGNOSTIC_STRATEGIES_MODULE,
+  ...effectiveDirectives_effectiveModules,
+});
+
 // JavaScript/TypeScript extensions
 export const TSX = ".tsx";
 export const TS = ".ts";
@@ -77,8 +104,13 @@ export const MJS = ".mjs";
 export const CJS = ".cjs";
 
 // JavaScript/TypeScript extensions array
-/** @type {readonly [TSX, TS, JSX, JS, MJS, CJS]} */
+/** @type {Extensions} */
 export const EXTENSIONS = [TSX, TS, JSX, JS, MJS, CJS]; // In priority order
 
 // message strings
 export const ARE_NOT_ALLOWED_TO_IMPORT = "are not allowed to import";
+
+// skipping object for flows
+export const skip = Object.freeze({
+  skip: true,
+});

package/library/_commons/utilities/helpers.js

@@ -3,30 +3,22 @@ import path from "path";
 
 import { loadConfig, createMatchPath } from "tsconfig-paths";
 
-import {
-  USE_SERVER_LOGICS,
-  USE_CLIENT_LOGICS,
-  USE_AGNOSTIC_LOGICS,
-  USE_SERVER_COMPONENTS,
-  USE_CLIENT_COMPONENTS,
-  USE_AGNOSTIC_COMPONENTS,
-  USE_SERVER_FUNCTIONS,
-  USE_CLIENT_CONTEXTS,
-  USE_AGNOSTIC_CONDITIONS,
-  USE_AGNOSTIC_STRATEGIES,
-  SERVER_LOGICS_MODULE,
-  CLIENT_LOGICS_MODULE,
-  AGNOSTIC_LOGICS_MODULE,
-  SERVER_COMPONENTS_MODULE,
-  CLIENT_COMPONENTS_MODULE,
-  AGNOSTIC_COMPONENTS_MODULE,
-  SERVER_FUNCTIONS_MODULE,
-  CLIENT_CONTEXTS_MODULE,
-  AGNOSTIC_CONDITIONS_MODULE,
-  AGNOSTIC_STRATEGIES_MODULE,
-  EXTENSIONS,
-  ARE_NOT_ALLOWED_TO_IMPORT,
-} from "../constants/bases.js";
+import { EXTENSIONS, ARE_NOT_ALLOWED_TO_IMPORT } from "../constants/bases.js";
+
+/**
+ * @typedef {import('../../../types/_commons/typedefs').ResolvedDirectives_ResolvedModules} ResolvedDirectives_ResolvedModules
+ * @typedef {import('../../../types/_commons/typedefs').CurrentFileResolvedDirective} CurrentFileResolvedDirective
+ * @typedef {import('../../../types/_commons/typedefs').Context<string, readonly unknown[]>} Context
+ */
+
+/**
+ * @template {CurrentFileResolvedDirective} T
+ * @typedef {import('../../../types/_commons/typedefs').ImportedFileResolvedDirective<T>} ImportedFileResolvedDirective
+ */
+/**
+ * @template {CurrentFileResolvedDirective} T
+ * @typedef {import('../../../types/_commons/typedefs').ResolvedDirectives_BlockedImports<T>} ResolvedDirectives_BlockedImports
+ */
 
 /* resolveImportPath */
 
@@ -110,7 +102,7 @@ export const getImportedFileFirstLine = (resolvedImportPath) => {
 
 /**
  * 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.
+ * @param {Context} 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) => ({
@@ -122,10 +114,11 @@ export const highlightFirstLineOfCode = (context) => ({
 
 /**
  * Returns a boolean deciding if an imported file's "resolved" directive is incompatible with the current file's "resolved" directive.
- * @param {Readonly<{"use server logics": {blockedImport: string; message: string;}[]; "use client logics": {blockedImport: string; message: string;}[]; "use agnostic logics": {blockedImport: string; message: string;}[]; "use server components": {blockedImport: string; message: string;}[]; "use client components": {blockedImport: string; message: string;}[]; "use agnostic components": {blockedImport: string; message: string;}[]; "use server functions": {blockedImport: string; message: string;}[]; "use client contexts"?: {blockedImport: string; message: string;}[]; "use agnostic conditions"?: {blockedImport: string; message: string;}[]; "use agnostic strategies"?: {blockedImport: string; message: string;}[];}>} resolvedDirectives_blockedImports The blocked imports 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 Returns `true` if the import is blocked, as established in respective `resolvedDirectives_blockedImports`.
+ * @template {CurrentFileResolvedDirective} T
+ * @param {ResolvedDirectives_BlockedImports<T>} resolvedDirectives_blockedImports The blocked imports object, either for agnostic20 or for directive21.
+ * @param {T} currentFileResolvedDirective The current file's "resolved" directive.
+ * @param {ImportedFileResolvedDirective<T>} importedFileResolvedDirective The imported file's "resolved" directive.
+ * @returns `true` if the import is blocked, as established in respective `resolvedDirectives_blockedImports`.
  */
 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.
@@ -141,37 +134,40 @@ export const isImportBlocked = (
 
 /**
  * Makes the intro for each specific import rule violation messages.
- * @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 Returns "[Current file 'resolved' modules] are not allowed to import [imported file 'resolved' modules]."
+ * @template {CurrentFileResolvedDirective} T
+ * @param {ResolvedDirectives_ResolvedModules} resolvedDirectives_resolvedModules The resolved modules object, either for agnostic20 or for directive21.
+ * @param {CurrentFileResolvedDirective} currentFileResolvedDirective The current file's "resolved" directive.
+ * @param {ImportedFileResolvedDirective<T>} importedFileResolvedDirective The imported file's "resolved" directive.
+ * @returns "[Current file 'resolved' modules] are not allowed to import [imported file 'resolved' modules]."
  */
 export const makeIntroForSpecificViolationMessage = (
-  resolvedDirectives_ResolvedModules,
+  resolvedDirectives_resolvedModules,
   currentFileResolvedDirective,
   importedFileResolvedDirective
 ) =>
-  `${resolvedDirectives_ResolvedModules[currentFileResolvedDirective]}s ${ARE_NOT_ALLOWED_TO_IMPORT} ${resolvedDirectives_ResolvedModules[importedFileResolvedDirective]}s.`;
+  `${resolvedDirectives_resolvedModules[currentFileResolvedDirective]}s ${ARE_NOT_ALLOWED_TO_IMPORT} ${resolvedDirectives_resolvedModules[importedFileResolvedDirective]}s.`;
 
-/* makeMessageFromResolvedDirective */
+/* makeMessageFromCurrentFileResolvedDirective */
 
 /**
  * Lists in an message the "resolved" modules incompatible with a "resolved" module based on its "resolved" directive.
- * @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 {Readonly<{"use server logics": {blockedImport: string; message: string;}[]; "use client logics": {blockedImport: string; message: string;}[]; "use agnostic logics": {blockedImport: string; message: string;}[]; "use server components": {blockedImport: string; message: string;}[]; "use client components": {blockedImport: string; message: string;}[]; "use agnostic components": {blockedImport: string; message: string;}[]; "use server functions": {blockedImport: string; message: string;}[]; "use client contexts"?: {blockedImport: string; message: string;}[]; "use agnostic conditions"?: {blockedImport: string; message: string;}[]; "use agnostic strategies"?: {blockedImport: string; message: string;}[];}>} resolvedDirectives_blockedImports The blocked imports 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} resolvedDirective The "resolved" directive of the "resolved" module.
+ * @template {CurrentFileResolvedDirective} T
+ * @param {ResolvedDirectives_ResolvedModules} resolvedDirectives_resolvedModules The resolved modules object, either for agnostic20 or for directive21.
+ * @param {ResolvedDirectives_BlockedImports<T>} resolvedDirectives_blockedImports The blocked imports object, either for agnostic20 or for directive21.
+ * @param {T} currentFileResolvedDirective The "resolved" directive of the "resolved" module.
  * @returns The message listing the incompatible "resolved" modules.
  */
-export const makeMessageFromResolvedDirective = (
-  resolvedDirectives_ResolvedModules,
+export const makeMessageFromCurrentFileResolvedDirective = (
+  resolvedDirectives_resolvedModules,
   resolvedDirectives_blockedImports,
-  resolvedDirective
+  currentFileResolvedDirective
 ) => {
-  const effectiveModule = resolvedDirectives_ResolvedModules[resolvedDirective];
+  const effectiveModule =
+    resolvedDirectives_resolvedModules[currentFileResolvedDirective];
   const effectiveModulesString = effectiveModule + "s"; // plural
 
   const blockedImports =
-    resolvedDirectives_blockedImports[resolvedDirective].map(
+    resolvedDirectives_blockedImports[currentFileResolvedDirective].map(
       (e) => e.blockedImport
     ) || [];
 
@@ -180,7 +176,7 @@ export const makeMessageFromResolvedDirective = (
   }
 
   const blockedEffectiveModules = blockedImports.map(
-    (e) => resolvedDirectives_ResolvedModules[e] + "s" // plural
+    (e) => resolvedDirectives_resolvedModules[e] + "s" // plural
   );
 
   const blockedEffectiveModulesString =
@@ -197,9 +193,10 @@ export const makeMessageFromResolvedDirective = (
 
 /**
  * Finds the `message` for the specific violation of "resolved" directives import rules based on `resolvedDirectives_blockedImports`.
- * @param {Readonly<{"use server logics": {blockedImport: string; message: string;}[]; "use client logics": {blockedImport: string; message: string;}[]; "use agnostic logics": {blockedImport: string; message: string;}[]; "use server components": {blockedImport: string; message: string;}[]; "use client components": {blockedImport: string; message: string;}[]; "use agnostic components": {blockedImport: string; message: string;}[]; "use server functions": {blockedImport: string; message: string;}[]; "use client contexts"?: {blockedImport: string; message: string;}[]; "use agnostic conditions"?: {blockedImport: string; message: string;}[]; "use agnostic strategies"?: {blockedImport: string; message: string;}[];}>} resolvedDirectives_blockedImports The blocked imports 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.
+ * @template {CurrentFileResolvedDirective} T
+ * @param {ResolvedDirectives_BlockedImports<T>} resolvedDirectives_blockedImports The blocked imports object, either for agnostic20 or for directive21.
+ * @param {T} currentFileResolvedDirective The current file's "resolved" directive.
+ * @param {ImportedFileResolvedDirective<T>} importedFileResolvedDirective The imported file's "resolved" directive.
  * @returns The corresponding `message`.
  */
 export const findSpecificViolationMessage = (

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

@@ -6,29 +6,30 @@ import {
   USE_CLIENT_COMPONENTS as COMMONS_USE_CLIENT_COMPONENTS,
   USE_AGNOSTIC_LOGICS as COMMONS_USE_AGNOSTIC_LOGICS,
   USE_AGNOSTIC_COMPONENTS as COMMONS_USE_AGNOSTIC_COMPONENTS,
-  SERVER_LOGICS_MODULE as COMMONS_SERVER_LOGICS_MODULE,
-  SERVER_COMPONENTS_MODULE as COMMONS_SERVER_COMPONENTS_MODULE,
-  SERVER_FUNCTIONS_MODULE as COMMONS_SERVER_FUNCTIONS_MODULE,
-  CLIENT_LOGICS_MODULE as COMMONS_CLIENT_LOGICS_MODULE,
-  CLIENT_COMPONENTS_MODULE as COMMONS_CLIENT_COMPONENTS_MODULE,
-  AGNOSTIC_LOGICS_MODULE as COMMONS_AGNOSTIC_LOGICS_MODULE,
-  AGNOSTIC_COMPONENTS_MODULE as COMMONS_AGNOSTIC_COMPONENTS_MODULE,
+  effectiveDirectives_effectiveModules,
 } from "../../../_commons/constants/bases.js";
 
 import { makeIntroForSpecificViolationMessage as commonsMakeIntroForSpecificViolationMessage } from "../../../_commons/utilities/helpers.js";
 
+/**
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Directive} Directive
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Directives} Directives
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').EffectiveDirective} EffectiveDirective
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Directives_EffectiveDirectives} Directives_EffectiveDirectives
+ */
+
 // directives
-export const NO_DIRECTIVE = null;
+export const NO_DIRECTIVE = "no directive";
 export const USE_SERVER = "use server";
 export const USE_CLIENT = "use client";
 export const USE_AGNOSTIC = "use agnostic";
 
 // directives array
-/** @type {readonly [USE_SERVER, USE_CLIENT, USE_AGNOSTIC]} */
+/** @type {Directives} */
 export const directivesArray = [USE_SERVER, USE_CLIENT, USE_AGNOSTIC];
 
 // directives set
-/** @type {ReadonlySet<USE_SERVER | USE_CLIENT | USE_AGNOSTIC>} */
+/** @type {ReadonlySet<Directive>} */
 export const directivesSet = new Set(directivesArray); // no longer used exported to satisfy static type inference
 
 // effective directives
@@ -40,24 +41,34 @@ export const USE_CLIENT_COMPONENTS = COMMONS_USE_CLIENT_COMPONENTS;
 export const USE_AGNOSTIC_LOGICS = COMMONS_USE_AGNOSTIC_LOGICS;
 export const USE_AGNOSTIC_COMPONENTS = COMMONS_USE_AGNOSTIC_COMPONENTS;
 
-// effective modules
-const SERVER_LOGICS_MODULE = COMMONS_SERVER_LOGICS_MODULE;
-const SERVER_COMPONENTS_MODULE = COMMONS_SERVER_COMPONENTS_MODULE;
-const SERVER_FUNCTIONS_MODULE = COMMONS_SERVER_FUNCTIONS_MODULE;
-const CLIENT_LOGICS_MODULE = COMMONS_CLIENT_LOGICS_MODULE;
-const CLIENT_COMPONENTS_MODULE = COMMONS_CLIENT_COMPONENTS_MODULE;
-const AGNOSTIC_LOGICS_MODULE = COMMONS_AGNOSTIC_LOGICS_MODULE;
-const AGNOSTIC_COMPONENTS_MODULE = COMMONS_AGNOSTIC_COMPONENTS_MODULE;
+// module kinds
+export const LOGICS = "logics";
+export const COMPONENTS = "components";
+export const FUNCTIONS = "functions";
 
-// mapping effective directives with effective modules
-export const effectiveDirectives_EffectiveModules = Object.freeze({
-  [USE_SERVER_LOGICS]: SERVER_LOGICS_MODULE,
-  [USE_SERVER_COMPONENTS]: SERVER_COMPONENTS_MODULE,
-  [USE_SERVER_FUNCTIONS]: SERVER_FUNCTIONS_MODULE,
-  [USE_CLIENT_LOGICS]: CLIENT_LOGICS_MODULE,
-  [USE_CLIENT_COMPONENTS]: CLIENT_COMPONENTS_MODULE,
-  [USE_AGNOSTIC_LOGICS]: AGNOSTIC_LOGICS_MODULE,
-  [USE_AGNOSTIC_COMPONENTS]: AGNOSTIC_COMPONENTS_MODULE,
+// mapping directives with effective directives
+/** @type {Directives_EffectiveDirectives} */
+export const directives_effectiveDirectives = Object.freeze({
+  [NO_DIRECTIVE]: {
+    [LOGICS]: USE_SERVER_LOGICS,
+    [COMPONENTS]: USE_SERVER_COMPONENTS,
+    [FUNCTIONS]: null,
+  },
+  [USE_SERVER]: {
+    [LOGICS]: null,
+    [COMPONENTS]: null,
+    [FUNCTIONS]: USE_SERVER_FUNCTIONS,
+  },
+  [USE_CLIENT]: {
+    [LOGICS]: USE_CLIENT_LOGICS,
+    [COMPONENTS]: USE_CLIENT_COMPONENTS,
+    [FUNCTIONS]: null,
+  },
+  [USE_AGNOSTIC]: {
+    [LOGICS]: USE_AGNOSTIC_LOGICS,
+    [COMPONENTS]: USE_AGNOSTIC_COMPONENTS,
+    [FUNCTIONS]: null,
+  },
 });
 
 // message placeholders
@@ -70,8 +81,8 @@ export const specificViolationMessage = "specificViolationMessage";
 
 /**
  * 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.
+ * @param {EffectiveDirective} currentFileEffectiveDirective The current file's effective directive.
+ * @param {EffectiveDirective} importedFileEffectiveDirective The imported file's effective directive.
  * @returns "[Current file effective modules] are not allowed to import [imported file effective modules]."
  */
 const makeIntroForSpecificViolationMessage = (
@@ -79,7 +90,7 @@ const makeIntroForSpecificViolationMessage = (
   importedFileEffectiveDirective
 ) =>
   commonsMakeIntroForSpecificViolationMessage(
-    effectiveDirectives_EffectiveModules,
+    effectiveDirectives_effectiveModules,
     currentFileEffectiveDirective,
     importedFileEffectiveDirective
   );
@@ -87,7 +98,7 @@ const makeIntroForSpecificViolationMessage = (
 const SUGGEST_USE_AGNOSTIC =
   "If the module you're trying to import does not possess any server-side code however, please mark it with this plugin's own and eponymous 'use agnostic' directive to signal its compatibility across all environments.";
 
-export const effectiveDirectives_BlockedImports = Object.freeze({
+export const effectiveDirectives_blockedImports = Object.freeze({
   [USE_SERVER_LOGICS]: [
     // USE_SERVER_LOGICS allowed, because Server Logics can compose with one another.
     // USE_SERVER_COMPONENTS allowed, because Server Components are OK to be composed with Server Logics as long as the Server Logics Module, by convention, does not export React components.

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

@@ -16,7 +16,11 @@ import {
   reExportsFlow,
 } from "../utilities/flows.js";
 
-/** @type {import('@typescript-eslint/utils').TSESLint.RuleModule<typeof reExportNotSameMessageId | typeof importBreaksEffectiveImportRulesMessageId | typeof useServerJSXMessageId, []>} */
+/**
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Rule} Rule
+ */
+
+/** @type {Rule} */
 const rule = {
   meta: {
     type: "problem",

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

@@ -5,16 +5,11 @@ import {
   useServerJSXMessageId,
   importBreaksEffectiveImportRulesMessageId,
   reExportNotSameMessageId,
+  skip,
 } from "../../../_commons/constants/bases.js";
 import {
+  NO_DIRECTIVE,
   USE_SERVER,
-  USE_SERVER_LOGICS,
-  USE_SERVER_COMPONENTS,
-  USE_SERVER_FUNCTIONS,
-  USE_CLIENT_LOGICS,
-  USE_CLIENT_COMPONENTS,
-  USE_AGNOSTIC_LOGICS,
-  USE_AGNOSTIC_COMPONENTS,
   // currentFileEffectiveDirective,
   // importedFileEffectiveDirective,
   effectiveDirectiveMessage,
@@ -30,18 +25,28 @@ import {
   getDirectiveFromImportedModule,
   getEffectiveDirective,
   isImportBlocked,
-  makeMessageFromEffectiveDirective,
+  makeMessageFromCurrentFileEffectiveDirective,
   findSpecificViolationMessage,
 } from "./helpers.js";
 
+/**
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Context} Context
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').EffectiveDirective} EffectiveDirective
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').ImportDeclaration} ImportDeclaration
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').ExportNamedDeclaration} ExportNamedDeclaration
+ * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').ExportAllDeclaration} ExportAllDeclaration
+ */
+
 /* currentFileFlow */
 
 /**
  * The flow that begins the import rules enforcement rule, retrieving the valid directive of the current file before comparing it to upcoming valid directives of the files it imports.
- * @param {Readonly<import('@typescript-eslint/utils').TSESLint.RuleContext<typeof reExportNotSameMessageId | typeof importBreaksEffectiveImportRulesMessageId | typeof useServerJSXMessageId, []>>} context The ESLint rule's `context` object.
- * @returns {{skip: true; currentFileEffectiveDirective: undefined;} | {skip: undefined; currentFileEffectiveDirective: USE_SERVER_LOGICS | USE_SERVER_COMPONENTS | USE_SERVER_FUNCTIONS | USE_CLIENT_LOGICS | USE_CLIENT_COMPONENTS | USE_AGNOSTIC_LOGICS | USE_AGNOSTIC_COMPONENTS;}} Either an object with `skip: true` to disregard or one with the non-null `currentFileEffectiveDirective`.
+ * @param {Context} context The ESLint rule's `context` object.
+ * @returns Either an object with `skip: true` to disregard or one with the non-null `currentFileEffectiveDirective`.
  */
 export const currentFileFlow = (context) => {
+  const skipTrue = { ...skip, currentFileEffectiveDirective: undefined };
+
   // GETTING THE EXTENSION OF THE CURRENT FILE
   const currentFileExtension = path.extname(context.filename);
 
@@ -53,11 +58,12 @@ export const currentFileFlow = (context) => {
     console.error(
       "ERROR. Linted files for this rule should only be in JavaScript (TypeScript)."
     );
-    return { skip: true };
+    return skipTrue;
   }
 
-  /* GETTING THE DIRECTIVE (or lack thereof) OF THE CURRENT FILE */
-  const currentFileDirective = getDirectiveFromCurrentModule(context);
+  // GETTING THE DIRECTIVE (or lack thereof) OF THE CURRENT FILE
+  const currentFileDirective =
+    getDirectiveFromCurrentModule(context) ?? NO_DIRECTIVE;
 
   // reports if a file marked "use server" has a JSX extension
   if (
@@ -68,10 +74,10 @@ export const currentFileFlow = (context) => {
       loc: highlightFirstLineOfCode(context),
       messageId: useServerJSXMessageId,
     });
-    return { skip: true };
+    return skipTrue;
   }
 
-  // GETTING THE EFFECTIVE DIRECTIVE OF THE CURRENT FILE
+  // GETTING THE EFFECTIVE DIRECTIVE (no lack thereof) OF THE CURRENT FILE
   const currentFileEffectiveDirective = getEffectiveDirective(
     currentFileDirective,
     currentFileExtension
@@ -80,21 +86,23 @@ export const currentFileFlow = (context) => {
   // fails if one of the seven effective directives has not been obtained
   if (currentFileEffectiveDirective === null) {
     console.error("ERROR. Effective directive should never be null.");
-    return { skip: true };
+    return skipTrue;
   }
 
-  return { currentFileEffectiveDirective };
+  return { skip: undefined, currentFileEffectiveDirective };
 };
 
 /* importedFileFlow */
 
 /**
  * The flow that is shared between import and re-export traversals to obtain the import file's effective directive.
- * @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;} | {skip: undefined; importedFileEffectiveDirective: USE_SERVER_LOGICS | USE_SERVER_COMPONENTS | USE_SERVER_FUNCTIONS | USE_CLIENT_LOGICS | USE_CLIENT_COMPONENTS | USE_AGNOSTIC_LOGICS | USE_AGNOSTIC_COMPONENTS;}} Either an object with `skip: true` to disregard or one with the non-null `importedFileEffectiveDirective`.
+ * @param {Context} context The ESLint rule's `context` object.
+ * @param {ImportDeclaration} node The ESLint `node` of the rule's current traversal.
+ * @returns Either an object with `skip: true` to disregard or one with the non-null `importedFileEffectiveDirective`.
  */
 const importedFileFlow = (context, node) => {
+  const skipTrue = { ...skip, importedFileEffectiveDirective: undefined };
+
   // finds the full path of the import
   const resolvedImportPath = resolveImportPath(
     path.dirname(context.filename),
@@ -103,19 +111,21 @@ const importedFileFlow = (context, node) => {
   );
 
   // does not operate on paths it did not resolve
-  if (resolvedImportPath === null) return { skip: true };
+  if (resolvedImportPath === null) return skipTrue;
   // does not operate on non-JS files
   const isImportedFileJS = EXTENSIONS.some((ext) =>
     resolvedImportPath.endsWith(ext)
   );
-  if (!isImportedFileJS) return { skip: true };
+  if (!isImportedFileJS) return skipTrue;
 
-  /* GETTING THE DIRECTIVE (or lack thereof) OF THE IMPORTED FILE */
+  // GETTING THE DIRECTIVE (or lack thereof) OF THE IMPORTED FILE
   const importedFileDirective =
-    getDirectiveFromImportedModule(resolvedImportPath);
+    getDirectiveFromImportedModule(resolvedImportPath) ?? NO_DIRECTIVE;
+
   // GETTING THE EXTENSION OF THE IMPORTED FILE
   const importedFileFileExtension = path.extname(resolvedImportPath);
-  // GETTING THE EFFECTIVE DIRECTIVE OF THE IMPORTED FILE
+
+  // GETTING THE EFFECTIVE DIRECTIVE (no lack thereof) OF THE IMPORTED FILE
   const importedFileEffectiveDirective = getEffectiveDirective(
     importedFileDirective,
     importedFileFileExtension
@@ -124,20 +134,20 @@ const importedFileFlow = (context, node) => {
   // also fails if one of the seven effective directives has not been obtained
   if (importedFileEffectiveDirective === null) {
     console.error("ERROR. Effective directive should never be null.");
-    return { skip: true };
+    return skipTrue;
   }
 
-  // For now skipping on both "does not operate" (which should ignore) and "fails" albeit with console.error (which should crash).
+  // For now skipping on both "does not operate" (which should ignore) and "fails" (which should crash) albeit with console.error.
 
-  return { importedFileEffectiveDirective };
+  return { skip: undefined, importedFileEffectiveDirective };
 };
 
 /* importsFlow */
 
 /** The full flow for import traversals to enforce effective directives import rules.
- * @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.
- * @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 {Context} context The ESLint rule's `context` object.
+ * @param {ImportDeclaration} node The ESLint `node` of the rule's current traversal.
+ * @param {EffectiveDirective} currentFileEffectiveDirective The current file's effective directive.
  * @returns Early if the flow needs to be interrupted.
  */
 export const importsFlow = (context, node, currentFileEffectiveDirective) => {
@@ -159,9 +169,10 @@ export const importsFlow = (context, node, currentFileEffectiveDirective) => {
       node,
       messageId: importBreaksEffectiveImportRulesMessageId,
       data: {
-        [effectiveDirectiveMessage]: makeMessageFromEffectiveDirective(
-          currentFileEffectiveDirective
-        ),
+        [effectiveDirectiveMessage]:
+          makeMessageFromCurrentFileEffectiveDirective(
+            currentFileEffectiveDirective
+          ),
         [specificViolationMessage]: findSpecificViolationMessage(
           currentFileEffectiveDirective,
           importedFileEffectiveDirective
@@ -174,9 +185,9 @@ export const importsFlow = (context, node, currentFileEffectiveDirective) => {
 /* reExportsFlow */
 
 /** The full flow for export traversals, shared between `ExportNamedDeclaration` and `ExportAllDeclaration`, to ensure same effective directive re-exports.
- * @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.ExportNamedDeclaration | import('@typescript-eslint/types').TSESTree.ExportAllDeclaration} node The ESLint `node` of the rule's current traversal.
- * @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 {Context} context The ESLint rule's `context` object.
+ * @param {ExportNamedDeclaration | ExportAllDeclaration} node The ESLint `node` of the rule's current traversal.
+ * @param {EffectiveDirective} currentFileEffectiveDirective The current file's effective directive.
  * @returns Early if the flow needs to be interrupted.
  */
 export const reExportsFlow = (context, node, currentFileEffectiveDirective) => {