eslint-plugin-use-agnostic 0.1.0

package/README.md

@@ -0,0 +1 @@
+(In progress...)

package/library/_commons/constants/bases.js

@@ -0,0 +1,72 @@
+// plugin name
+export const useAgnosticPluginName = "use-agnostic";
+
+/* config names */
+// agnostic20
+export const agnostic20ConfigName = "agnostic20";
+// directive21
+export const directive21ConfigName = "directive21";
+
+/* rule names */
+// agnostic20
+export const enforceEffectiveDirectivesRuleName =
+  "enforce-effective-directives-import-rules";
+// directive21
+export const enforceCommentedDirectivesRuleName =
+  "enforce-commented-directives-import-rules";
+
+/* messageIds */
+export const reExportNotSameMessageId = "re-export-not-same-directive";
+// agnostic20
+export const importBreaksEffectiveImportRulesMessageId =
+  "import-breaks-effective-directive-import-rule";
+export const useServerJSXMessageId = "use-server-has-jsx-extension";
+// directive21
+export const importBreaksCommentedImportRulesMessageId =
+  "import-breaks-commented-directive-import-rule";
+export const noCommentedDirective = "no-commented-directive-detected";
+export const commentedDirectiveVerificationFailed =
+  "commented-directive-verification-failed";
+export const importNotStrategized =
+  "import-from-use-agnostic-strategies-not-strategized";
+export const exportNotStrategized =
+  "export-from-use-agnostic-strategies-not-strategized";
+
+// all "resolved" directives (from AIA/agnostic20 & DFA/directive21)
+export const USE_SERVER_LOGICS = "use server logics";
+export const USE_CLIENT_LOGICS = "use client logics";
+export const USE_AGNOSTIC_LOGICS = "use agnostic logics";
+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";
+
+// all "resolved" modules (from AIA/agnostic20 & DFA/directive21)
+export const SERVER_LOGICS_MODULE = "Server Logics Module";
+export const CLIENT_LOGICS_MODULE = "Client Logics Module";
+export const AGNOSTIC_LOGICS_MODULE = "Agnostic Logics Module";
+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";
+export const CLIENT_CONTEXTS_MODULE = "Client Contexts Module";
+export const AGNOSTIC_CONDITIONS_MODULE = "Agnostic Conditions Module";
+export const AGNOSTIC_STRATEGIES_MODULE = "Agnostic Strategies Module";
+
+/* from the resolveImportPath utility */
+
+export const TSX = ".tsx";
+export const TS = ".ts";
+export const JSX = ".jsx";
+export const JS = ".js";
+export const MJS = ".mjs";
+export const CJS = ".cjs";
+
+export const EXTENSIONS = [TSX, TS, JSX, JS, MJS, CJS]; // In priority order
+
+/* from the isImportBlocked utility */
+
+export const ARE_NOT_ALLOWED_TO_IMPORT = "are not allowed to import";

package/library/_commons/utilities/helpers.js

@@ -0,0 +1,191 @@
+import fs from "fs";
+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";
+
+/* resolveImportPath */
+
+/**
+ * Resolves an import path to a filesystem path, handling:
+ * - Aliases (via tsconfig.json `paths`)
+ * - Missing extensions (appends .ts, .tsx, etc.)
+ * - Directory imports (e.g., `./components` → `./components/index.ts`)
+ * @param {string} currentDir Directory of the file containing the import (from `path.dirname(context.filename)`).
+ * @param {string} importPath The import specifier (e.g., `@/components/Button` or `./utils`), from the current node.
+ * @param {string} cwd Project root (from `context.cwd`). Caveat: only as an assumption currently.
+ * @returns {string | null} Absolute resolved path or `null` if not found.
+ */
+export const resolveImportPath = (currentDir, importPath, cwd) => {
+  // --- Step 1: Resolve aliases (if tsconfig.json `paths` exists) ---
+  const config = loadConfig(cwd);
+
+  const resolveTSConfig =
+    config.resultType === "success"
+      ? createMatchPath(config.absoluteBaseUrl, config.paths)
+      : null;
+
+  const aliasedPath = resolveTSConfig
+    ? resolveTSConfig(importPath, undefined, undefined, EXTENSIONS)
+    : null;
+
+  // --- Step 2: Resolve relative/absolute paths ---
+  const basePath = aliasedPath || path.resolve(currentDir, importPath);
+
+  // does not resolve on node_modules
+  if (basePath.includes("node_modules")) return null;
+
+  // Case 1: File with extension exists
+  if (path.extname(importPath) && fs.existsSync(basePath)) return basePath;
+
+  // Case 2: Try appending extensions
+  for (const ext of EXTENSIONS) {
+    const fullPath = `${basePath}${ext}`;
+    if (fs.existsSync(fullPath)) return fullPath;
+  }
+
+  // Case 3: Directory import (e.g., `./components` → `./components/index.ts`)
+  const indexPath = path.join(basePath, "index");
+  for (const ext of EXTENSIONS) {
+    const fullPath = `${indexPath}${ext}`;
+    if (fs.existsSync(fullPath)) return fullPath;
+  }
+
+  return null; // Not found
+};
+
+/* getImportedFileFirstLine */
+
+/**
+ * Gets the first line of code of the imported module.
+ * @param {string} resolvedImportPath The resolved path of the imported module.
+ * @returns {string} Returns the first line of the imported module.
+ */
+export const getImportedFileFirstLine = (resolvedImportPath) => {
+  // gets the code of the import
+  const importedFileContent = fs.readFileSync(resolvedImportPath, "utf8");
+  // gets the first line of the code of the import
+  const importedFileFirstLine = importedFileContent
+    .trim()
+    .split("\n")[0]
+    .trim(); // the line itself needs to be trimmed too
+
+  return importedFileFirstLine;
+};
+
+/* isImportBlocked */
+
+/**
+ * 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 {boolean} 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.
+  resolvedDirectives_blockedImports,
+  currentFileResolvedDirective,
+  importedFileResolvedDirective,
+) =>
+  resolvedDirectives_blockedImports[currentFileResolvedDirective]
+    .map((e) => e.blockedImport)
+    .includes(importedFileResolvedDirective);
+
+/* makeIntroForSpecificViolationMessage */
+
+/**
+ * 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 {string} Returns "[Current file 'resolved' modules] are not allowed to import [imported file 'resolved' modules]".
+ */
+export const makeIntroForSpecificViolationMessage = (
+  resolvedDirectives_ResolvedModules,
+  currentFileResolvedDirective,
+  importedFileResolvedDirective,
+) =>
+  `${resolvedDirectives_ResolvedModules[currentFileResolvedDirective]}s ${ARE_NOT_ALLOWED_TO_IMPORT} ${resolvedDirectives_ResolvedModules[importedFileResolvedDirective]}s.`;
+
+/* makeMessageFromResolvedDirective */
+
+/**
+ * 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.
+ * @returns {string} The message listing the incompatible "resolved" modules.
+ */
+export const makeMessageFromResolvedDirective = (
+  resolvedDirectives_ResolvedModules,
+  resolvedDirectives_blockedImports,
+  resolvedDirective,
+) => {
+  const effectiveModule = resolvedDirectives_ResolvedModules[resolvedDirective];
+  const effectiveModulesString = effectiveModule + "s"; // plural
+
+  const blockedImports =
+    resolvedDirectives_blockedImports[resolvedDirective].map(
+      (e) => e.blockedImport,
+    ) || [];
+
+  if (blockedImports.length === 0) {
+    return `${effectiveModulesString} are not restricted from importing any modules.`;
+  }
+
+  const blockedEffectiveModules = blockedImports.map(
+    (e) => resolvedDirectives_ResolvedModules[e] + "s", // plural
+  );
+
+  const blockedEffectiveModulesString =
+    blockedEffectiveModules.length === 1
+      ? blockedEffectiveModules[0]
+      : blockedEffectiveModules.slice(0, -1).join(", ") +
+        ", or " +
+        blockedEffectiveModules.slice(-1);
+
+  return `${effectiveModulesString} ${ARE_NOT_ALLOWED_TO_IMPORT} ${blockedEffectiveModulesString}.`;
+};
+
+/* findSpecificViolationMessage */
+
+/**
+ * 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.
+ * @returns {string} The corresponding `message`.
+ */
+export const findSpecificViolationMessage = (
+  resolvedDirectives_blockedImports,
+  currentFileResolvedDirective,
+  importedFileResolvedDirective,
+) =>
+  resolvedDirectives_blockedImports[currentFileResolvedDirective].find(
+    (e) => e.blockedImport === importedFileResolvedDirective,
+  ).message;

package/library/agnostic20/config.js

@@ -0,0 +1,24 @@
+import { defineConfig } from "eslint/config";
+
+import {
+  agnostic20ConfigName,
+  useAgnosticPluginName,
+  enforceEffectiveDirectivesRuleName,
+} from "../_commons/constants/bases.js";
+
+/**
+ * Makes the agnostic20 config for the use-agnostic ESLint plugin.
+ */
+export const makeAgnostic20Config = (plugin) => ({
+  [agnostic20ConfigName]: defineConfig([
+    {
+      plugins: {
+        [useAgnosticPluginName]: plugin,
+      },
+      rules: {
+        [`${useAgnosticPluginName}/${enforceEffectiveDirectivesRuleName}`]:
+          "warn",
+      },
+    },
+  ]),
+});

package/library/agnostic20/constants/bases.js

@@ -0,0 +1,268 @@
+import {
+  USE_SERVER_LOGICS as COMMONS_USE_SERVER_LOGICS,
+  USE_SERVER_COMPONENTS as COMMONS_USE_SERVER_COMPONENTS,
+  USE_SERVER_FUNCTIONS as COMMONS_USE_SERVER_FUNCTIONS,
+  USE_CLIENT_LOGICS as COMMONS_USE_CLIENT_LOGICS,
+  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,
+} from "../../_commons/constants/bases.js";
+
+import { makeIntroForSpecificViolationMessage as commonsMakeIntroForSpecificViolationMessage } from "../../_commons/utilities/helpers.js";
+
+// directives
+export const NO_DIRECTIVE = null;
+export const USE_SERVER = "use server";
+export const USE_CLIENT = "use client";
+export const USE_AGNOSTIC = "use agnostic";
+
+// effective directives
+export const USE_SERVER_LOGICS = COMMONS_USE_SERVER_LOGICS;
+export const USE_SERVER_COMPONENTS = COMMONS_USE_SERVER_COMPONENTS;
+export const USE_SERVER_FUNCTIONS = COMMONS_USE_SERVER_FUNCTIONS;
+export const USE_CLIENT_LOGICS = COMMONS_USE_CLIENT_LOGICS;
+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;
+
+// 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,
+});
+
+// message placeholders
+
+export const currentFileEffectiveDirective = "currentFileEffectiveDirective";
+export const importedFileEffectiveDirective = "importedFileEffectiveDirective";
+export const effectiveDirectiveMessage = "effectiveDirectiveMessage";
+export const specificViolationMessage = "specificViolationMessage";
+
+/* from the getDirectiveFromCurrentModule utility */
+
+export const directivesSet = new Set([USE_SERVER, USE_CLIENT, USE_AGNOSTIC]);
+
+/* from the getDirectiveFromImportedModule utility */
+
+export const directivesArray = Array.from(directivesSet);
+
+/* from the isImportBlocked utility */
+
+/* effectiveDirectives_BlockedImports */
+
+/**
+ * Makes the intro for each specific import rule violation messages.
+ * @param {USE_SERVER_LOGICS | USE_SERVER_COMPONENTS | USE_SERVER_FUNCTIONS | USE_CLIENT_LOGICS | USE_CLIENT_COMPONENTS | USE_AGNOSTIC_LOGICS | USE_AGNOSTIC_COMPONENTS} currentFileEffectiveDirective The current file's effective directive.
+ * @param {USE_SERVER_LOGICS | USE_SERVER_COMPONENTS | USE_SERVER_FUNCTIONS | USE_CLIENT_LOGICS | USE_CLIENT_COMPONENTS | USE_AGNOSTIC_LOGICS | USE_AGNOSTIC_COMPONENTS} importedFileEffectiveDirective The imported file's effective directive.
+ * @returns {string} Returns "[Current file effective modules] are not allowed to import [imported file effective modules]".
+ */
+const makeIntroForSpecificViolationMessage = (
+  currentFileEffectiveDirective,
+  importedFileEffectiveDirective
+) =>
+  commonsMakeIntroForSpecificViolationMessage(
+    effectiveDirectives_EffectiveModules,
+    currentFileEffectiveDirective,
+    importedFileEffectiveDirective
+  );
+
+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.
+    // USE_SERVER_FUNCTIONS allowed, because as Server Functions can import one another, it is only natural that they could compose through Server Logics.
+    {
+      blockedImport: USE_CLIENT_LOGICS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_SERVER_LOGICS,
+        USE_CLIENT_LOGICS
+      )} Client logic should never leak to the server.`,
+    },
+    {
+      blockedImport: USE_CLIENT_COMPONENTS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_SERVER_LOGICS,
+        USE_CLIENT_COMPONENTS
+      )} Client Components cannot be tinkered with on the server.`,
+    },
+    // USE_AGNOSTIC_LOGICS allowed, because Agnostic Logic can run safely on the server just like it can on the client.
+    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can be composed with Logics on the server just like they can on the client, again, as long at the Server Logics Module, by convention, does not export React components.
+  ],
+  [USE_SERVER_COMPONENTS]: [
+    // USE_SERVER_LOGICS allowed, because logic from the server can safely support Server Components.
+    // USE_SERVER_COMPONENTS allowed, because Server Components can compose with one another, assuming thanks to the inclusion of the 'use agnostic' directive that they are actual Server Components.
+    // USE_SERVER_FUNCTIONS allowed, because as Server Components Modules can import Client Components, they are able to pass them Server Functions as props as well, even though indeed Server Components Modules can make their own Server Functions through inline 'use server' directives.
+    {
+      blockedImport: USE_CLIENT_LOGICS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_SERVER_COMPONENTS,
+        USE_CLIENT_LOGICS
+      )} Client logic should never leak to the server.`,
+    },
+    // USE_CLIENT_COMPONENTS allowed, because Client Components can be nested inside Server Components either to wrap some of the tree with client state accessible through child Client Components and pass through Server Components, or to create client boundaries when the root of the application is planted on the server.
+    // USE_AGNOSTIC_LOGICS allowed, because Agnostic Logic can run safely on the server just like it can on the client.
+    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can render safely on the server just like they can on the client.
+  ],
+  [USE_SERVER_FUNCTIONS]: [
+    // USE_SERVER_LOGICS allowed, because logic from the server can safely support Server Functions.
+    {
+      blockedImport: USE_SERVER_COMPONENTS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_SERVER_FUNCTIONS,
+        USE_SERVER_COMPONENTS
+      )} Server Functions have no business working with React Components.`,
+    },
+    // USE_SERVER_FUNCTIONS allowed, because even though Server Functions don't need to import one another and the same results can be generated via Server Logic alone for the outcome of a single Server Function, a rational use case could be found for composing Server Functions with one another either today or in the future.
+    {
+      blockedImport: USE_CLIENT_LOGICS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_SERVER_FUNCTIONS,
+        USE_CLIENT_LOGICS
+      )} Client logic should never leak to the server.`,
+    },
+    {
+      blockedImport: USE_CLIENT_COMPONENTS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_SERVER_FUNCTIONS,
+        USE_CLIENT_COMPONENTS
+      )} Server Functions have no business working with React Components.`,
+    },
+    // USE_AGNOSTIC_LOGICS allowed, because Agnostic Logic can run safely on the server just like it can on the client.
+    {
+      blockedImport: USE_AGNOSTIC_COMPONENTS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_SERVER_FUNCTIONS,
+        USE_AGNOSTIC_COMPONENTS
+      )} Server Functions have no business working with React Components.`,
+    },
+  ],
+  [USE_CLIENT_LOGICS]: [
+    {
+      blockedImport: USE_SERVER_LOGICS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_CLIENT_LOGICS,
+        USE_SERVER_LOGICS
+      )} Server logic should never leak to the client.`,
+    },
+    {
+      blockedImport: USE_SERVER_COMPONENTS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_CLIENT_LOGICS,
+        USE_SERVER_COMPONENTS
+      )} Server Components cannot be thinkered with on the client.`,
+    },
+    // USE_SERVER_FUNCTIONS allowed, because it is technically feasible to tinker with a Client Component within a Client Logics Module and attach to said Client Component a Server Function to be triggered on the client.
+    // USE_CLIENT_LOGICS allowed, because Client Logics can compose with one another.
+    // USE_CLIENT_COMPONENTS allowed, because Client Components are OK to be composed with Client Logics as long as the Client Logics Module, by convention, does not export React components.
+    // USE_AGNOSTIC_LOGICS allowed, because Agnostic Logic can run safely on the client just like it can on the server.
+    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can be composed with Logics on the client just like they can on the server, again, as long at the Client Logics Module, by convention, does not export React components.
+  ],
+  [USE_CLIENT_COMPONENTS]: [
+    {
+      blockedImport: USE_SERVER_LOGICS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_CLIENT_COMPONENTS,
+        USE_SERVER_LOGICS
+      )} Server logic should never leak to the client.`,
+    },
+    {
+      blockedImport: USE_SERVER_COMPONENTS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_CLIENT_COMPONENTS,
+        USE_SERVER_COMPONENTS
+      )} Server Components may only pass through Client Components through the children prop within Server Components Modules.`,
+    },
+    // USE_SERVER_FUNCTIONS allowed, because Server Functions are specifically triggered by Client Components.
+    // USE_CLIENT_LOGICS allowed, because logic from the client can safely support Client Components.
+    // USE_CLIENT_COMPONENTS allowed, because Client Components can compose with one another.
+    // USE_AGNOSTIC_LOGICS allowed, because Agnostic Logic can run safely on the client just like it can on the server.
+    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can render safely on the client just like they can on the server.
+  ],
+  [USE_AGNOSTIC_LOGICS]: [
+    {
+      blockedImport: USE_SERVER_LOGICS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_AGNOSTIC_LOGICS,
+        USE_SERVER_LOGICS
+      )} Server Logic cannot run in both the server and the client.`,
+    },
+    {
+      blockedImport: USE_SERVER_COMPONENTS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_AGNOSTIC_LOGICS,
+        USE_SERVER_COMPONENTS
+      )} Server Components cannot be tinkered with on both the server and the client.`,
+    },
+    {
+      blockedImport: USE_SERVER_FUNCTIONS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_AGNOSTIC_LOGICS,
+        USE_SERVER_FUNCTIONS
+      )} Though Server Functions can be tinkered with on the server and on the client, use cases on both environments are not compatible.`,
+    },
+    {
+      blockedImport: USE_CLIENT_LOGICS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_AGNOSTIC_LOGICS,
+        USE_CLIENT_LOGICS
+      )} Client Logic cannot run in both the server and the client.`,
+    },
+    {
+      blockedImport: USE_CLIENT_COMPONENTS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_AGNOSTIC_LOGICS,
+        USE_CLIENT_COMPONENTS
+      )} Client Components cannot be tinkered with on both the server and the client.`,
+    },
+    // USE_AGNOSTIC_LOGICS allowed, because Agnostic Logics can compose with one another.
+    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can be composed with Logics agnostically as long as the Agnostic Logics Module, by convention, does not export React components.
+  ],
+  [USE_AGNOSTIC_COMPONENTS]: [
+    {
+      blockedImport: USE_SERVER_LOGICS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_AGNOSTIC_COMPONENTS,
+        USE_SERVER_LOGICS
+      )} Server Logic cannot run in both the server and the client.`,
+    },
+    {
+      blockedImport: USE_SERVER_COMPONENTS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_AGNOSTIC_COMPONENTS,
+        USE_SERVER_COMPONENTS
+      )} Unlike Client Components, Server Components cannot make silos of their own once on the client, and can therefore not be executed from the client.`,
+    },
+    // USE_SERVER_FUNCTIONS allowed, because as Agnostic Components Modules can import Client Components, they are able to pass them Server Functions as props as well.
+    {
+      blockedImport: USE_CLIENT_LOGICS,
+      message: `${makeIntroForSpecificViolationMessage(
+        USE_AGNOSTIC_COMPONENTS,
+        USE_CLIENT_LOGICS
+      )} Client Logic cannot run in both the server and the client.`,
+    },
+    // USE_CLIENT_COMPONENTS allowed, because Client Components can be nested inside Agnostic Components either to wrap some of the tree with client state accessible through child Client Components and pass through Server Components (if still on the Server Tree), or to create client boundaries when the root of the application is planted on the server.
+    // USE_AGNOSTIC_LOGICS allowed, because environment-agnostic logic can safely support Agnostic Components.
+    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can compose with one another.
+  ],
+});

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

@@ -0,0 +1,55 @@
+import {
+  reExportNotSameMessageId,
+  importBreaksEffectiveImportRulesMessageId,
+  useServerJSXMessageId,
+} from "../../_commons/constants/bases.js";
+import {
+  currentFileEffectiveDirective,
+  importedFileEffectiveDirective,
+  effectiveDirectiveMessage,
+  specificViolationMessage,
+} from "../constants/bases.js";
+
+import {
+  currentFileFlow,
+  importsFlow,
+  reExportsFlow,
+} from "../utilities/flows.js";
+
+/** @type {import('@typescript-eslint/utils').TSESLint.RuleModule<typeof reExportNotSameMessageId | typeof importBreaksEffectiveImportRulesMessageId | typeof useServerJSXMessageId, []>} */
+const rule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Enforces import rules based on the file's effective directive. ",
+    },
+    schema: [],
+    // currentFileEffectiveDirective, importedFileEffectiveDirective, effectiveDirectiveMessage, specificViolationMessage
+    messages: {
+      [reExportNotSameMessageId]: `The effective directives of this file and this re-export are dissimilar.
+Here, "{{ ${currentFileEffectiveDirective} }}" and "{{ ${importedFileEffectiveDirective} }}" are not the same. Please re-export only from modules that have the same effective directive as the current module. `,
+      [importBreaksEffectiveImportRulesMessageId]: `{{ ${effectiveDirectiveMessage} }} 
+In this case, {{ ${specificViolationMessage} }} `,
+      [useServerJSXMessageId]: `Modules marked with the 'use server' directive are not allowed to have JSX file extensions.  
+Indeed, Server Functions Modules have no business exporting JSX. `,
+    },
+  },
+  create: (context) => {
+    const result = currentFileFlow(context);
+
+    if (result.skip) return {};
+    const { currentFileEffectiveDirective } = result;
+
+    return {
+      ImportDeclaration: (node) =>
+        importsFlow(context, node, currentFileEffectiveDirective),
+      ExportNamedDeclaration: (node) =>
+        reExportsFlow(context, node, currentFileEffectiveDirective),
+      ExportAllDeclaration: (node) =>
+        reExportsFlow(context, node, currentFileEffectiveDirective),
+    };
+  },
+};
+
+export default rule; // enforce-effective-directives-import-rules