npm - eslint-plugin-use-agnostic - Versions diffs - 0.10.2 → 0.10.4 - Mend

eslint-plugin-use-agnostic 0.10.2 → 0.10.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/library/_commons/constants/bases.js +6 -3
package/library/_commons/utilities/helpers.js +30 -23
package/library/agnostic20/_commons/constants/bases.js +161 -186
package/library/agnostic20/_commons/utilities/helpers.js +0 -2
package/library/directive21/_commons/constants/bases.js +195 -274
package/library/directive21/_commons/utilities/flows.js +3 -0
package/library/directive21/_commons/utilities/helpers.js +9 -11
package/library/directive21/config.js +1 -1
package/package.json +1 -1

package/library/_commons/constants/bases.js CHANGED Viewed

@@ -78,7 +78,7 @@ export const AGNOSTIC_STRATEGIES_MODULE = "Agnostic Strategies Module";
 // all mappings of "resolved" directives with "resolved" modules
 // agnostic20
-export const effectiveDirectives_effectiveModules = Object.freeze({
+const effectiveDirectives_effectiveModules = Object.freeze({
   [USE_SERVER_LOGICS]: SERVER_LOGICS_MODULE,
   [USE_SERVER_COMPONENTS]: SERVER_COMPONENTS_MODULE,
   [USE_SERVER_FUNCTIONS]: SERVER_FUNCTIONS_MODULE,
@@ -88,12 +88,15 @@ export const effectiveDirectives_effectiveModules = Object.freeze({
   [USE_AGNOSTIC_COMPONENTS]: AGNOSTIC_COMPONENTS_MODULE,
 });
 // and directive21
-export const commentedDirectives_commentedModules = Object.freeze({
+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,
 });
+// for commons uses
+export const resolvedDirectives_resolvedModules =
+  commentedDirectives_commentedModules;
 // JavaScript/TypeScript extensions
 export const TSX = ".tsx";
@@ -105,7 +108,7 @@ export const CJS = ".cjs";
 // JavaScript/TypeScript extensions array
 /** @type {Extensions} */
-export const EXTENSIONS = [TSX, TS, JSX, JS, MJS, CJS]; // In priority order
+export const EXTENSIONS = Object.freeze([TSX, TS, JSX, JS, MJS, CJS]); // In priority order
 // message strings
 export const ARE_NOT_ALLOWED_TO_IMPORT = "are not allowed to import";

package/library/_commons/utilities/helpers.js CHANGED Viewed

@@ -3,20 +3,26 @@ import path from "path";
 import { loadConfig, createMatchPath } from "tsconfig-paths";
-import { EXTENSIONS, ARE_NOT_ALLOWED_TO_IMPORT } from "../constants/bases.js";
+import {
+  EXTENSIONS,
+  ARE_NOT_ALLOWED_TO_IMPORT,
+  resolvedDirectives_resolvedModules,
+} from "../constants/bases.js";
+import jscommentsConfig from "../../../comments.config.js";
 /**
- * @typedef {import('../../../types/_commons/typedefs').ResolvedDirectives_ResolvedModules} ResolvedDirectives_ResolvedModules
- * @typedef {import('../../../types/_commons/typedefs').CurrentFileResolvedDirective} CurrentFileResolvedDirective
+ * @typedef {import('../../../types/_commons/typedefs').EffectiveDirective} EffectiveDirective
+ * @typedef {import('../../../types/_commons/typedefs').CommentedDirective} CommentedDirective
+ * @typedef {import('../../../types/_commons/typedefs').ResolvedDirectiveWithoutUseAgnosticStrategies} ResolvedDirectiveWithoutUseAgnosticStrategies
+ * @typedef {import('../../../types/_commons/typedefs').Agnostic20ConfigName} Agnostic20ConfigName
+ * @typedef {import('../../../types/_commons/typedefs').Directive21ConfigName} Directive21ConfigName
+ * @typedef {import('../../../types/_commons/typedefs').UseAgnosticConfigName} UseAgnosticConfigName
  * @typedef {import('../../../types/_commons/typedefs').Context<string, readonly unknown[]>} Context
  */
 /**
- * @template {CurrentFileResolvedDirective} T
- * @typedef {import('../../../types/_commons/typedefs').ImportedFileResolvedDirective<T>} ImportedFileResolvedDirective
- */
-/**
- * @template {CurrentFileResolvedDirective} T
+ * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} T
  * @typedef {import('../../../types/_commons/typedefs').ResolvedDirectives_BlockedImports<T>} ResolvedDirectives_BlockedImports
  */
@@ -114,10 +120,10 @@ export const highlightFirstLineOfCode = (context) => ({
 /**
  * Returns a boolean deciding if an imported file's "resolved" directive is incompatible with the current file's "resolved" directive.
- * @template {CurrentFileResolvedDirective} T
+ * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} 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.
+ * @param {T} importedFileResolvedDirective The imported file's "resolved" directive.
  * @returns `true` if the import is blocked, as established in respective `resolvedDirectives_blockedImports`.
  */
 export const isImportBlocked = (
@@ -134,31 +140,32 @@ export const isImportBlocked = (
 /**
  * Makes the intro for each specific import rule violation messages.
- * @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.
+ * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} T
+ * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} U
+ * @param {T} currentFileResolvedDirective The current file's "resolved" directive, excluding `"use agnostic strategies"`.
+ * @param {U} importedFileResolvedDirective The imported file's "resolved" directive, excluding `"use agnostic strategies"`.
  * @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.`;
+) => {
+  /** @type {`${typeof resolvedDirectives_resolvedModules[T]}s ${typeof ARE_NOT_ALLOWED_TO_IMPORT} ${typeof resolvedDirectives_resolvedModules[U]}s.`} */
+  const introForSpecificViolationMessage = `${resolvedDirectives_resolvedModules[currentFileResolvedDirective]}s ${ARE_NOT_ALLOWED_TO_IMPORT} ${resolvedDirectives_resolvedModules[importedFileResolvedDirective]}s.`;
+  return introForSpecificViolationMessage;
+};
 /* makeMessageFromCurrentFileResolvedDirective */
 /**
  * Lists in an message the "resolved" modules incompatible with a "resolved" module based on its "resolved" directive.
- * @template {CurrentFileResolvedDirective} T
- * @param {ResolvedDirectives_ResolvedModules} resolvedDirectives_resolvedModules The resolved modules object, either for agnostic20 or for directive21.
+ * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} T
  * @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 makeMessageFromCurrentFileResolvedDirective = (
-  resolvedDirectives_resolvedModules,
   resolvedDirectives_blockedImports,
   currentFileResolvedDirective
 ) => {
@@ -193,10 +200,10 @@ export const makeMessageFromCurrentFileResolvedDirective = (
 /**
  * Finds the `message` for the specific violation of "resolved" directives import rules based on `resolvedDirectives_blockedImports`.
- * @template {CurrentFileResolvedDirective} T
+ * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} 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.
+ * @param {T} currentFileResolvedDirective The current file's "resolved" directive, excluding `"use agnostic strategies"`.
+ * @param {T} importedFileResolvedDirective The imported file's "resolved" directive.
  * @returns The corresponding `message`.
  */
 export const findSpecificViolationMessage = (

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

@@ -1,4 +1,5 @@
 import {
+  agnostic20ConfigName,
   USE_SERVER_LOGICS as COMMONS_USE_SERVER_LOGICS,
   USE_SERVER_COMPONENTS as COMMONS_USE_SERVER_COMPONENTS,
   USE_SERVER_FUNCTIONS as COMMONS_USE_SERVER_FUNCTIONS,
@@ -6,10 +7,11 @@ 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,
-  effectiveDirectives_effectiveModules,
 } from "../../../_commons/constants/bases.js";
-import { makeIntroForSpecificViolationMessage as commonsMakeIntroForSpecificViolationMessage } from "../../../_commons/utilities/helpers.js";
+import { makeIntroForSpecificViolationMessage } from "../../../_commons/utilities/helpers.js";
+import jscommentsConfig from "../../../../comments.config.js";
 /**
  * @typedef {import('../../../../types/agnostic20/_commons/typedefs.js').Directive} Directive
@@ -26,7 +28,11 @@ export const USE_AGNOSTIC = "use agnostic";
 // directives array
 /** @type {Directives} */
-export const directivesArray = [USE_SERVER, USE_CLIENT, USE_AGNOSTIC];
+export const directivesArray = Object.freeze([
+  USE_SERVER,
+  USE_CLIENT,
+  USE_AGNOSTIC,
+]);
 // directives set
 /** @type {ReadonlySet<Directive>} */
@@ -48,7 +54,7 @@ export const FUNCTIONS = "functions";
 // mapping directives with effective directives
 /** @type {Directives_EffectiveDirectives} */
-export const directives_effectiveDirectives = Object.freeze({
+export const directives_effectiveDirectives = {
   [NO_DIRECTIVE]: {
     [LOGICS]: USE_SERVER_LOGICS,
     [COMPONENTS]: USE_SERVER_COMPONENTS,
@@ -69,7 +75,7 @@ export const directives_effectiveDirectives = Object.freeze({
     [COMPONENTS]: USE_AGNOSTIC_COMPONENTS,
     [FUNCTIONS]: null,
   },
-});
+};
 // message placeholders
 export const currentFileEffectiveDirective = "currentFileEffectiveDirective";
@@ -79,209 +85,178 @@ export const specificViolationMessage = "specificViolationMessage";
 /* effectiveDirectives_BlockedImports */
+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.";
+/**
+ * Makes a blockedImport object for the identified blocked import at hand.
+ * @template {EffectiveDirective} T
+ * @template {EffectiveDirective} U
+ * @param {T} currentFileEffectiveDirective The current file's effective directive.
+ * @param {U} importedFileEffectiveDirective The imported file's effective directive.
+ * @returns The blockedImport object for the identified blocked import at hand.
+ */
+export const makeBlockedImport = (
+  currentFileEffectiveDirective,
+  importedFileEffectiveDirective
+) => {
+  return Object.freeze({
+    blockedImport: importedFileEffectiveDirective,
+    message: `${makeIntroForSpecificViolationMessage(
+      currentFileEffectiveDirective,
+      importedFileEffectiveDirective
+    )} ${
+      jscommentsConfig[agnostic20ConfigName][currentFileEffectiveDirective][
+        importedFileEffectiveDirective
+      ]
+    }`,
+  });
+};
 /**
- * Makes the intro for each specific import rule violation messages.
- * @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]."
+ * Makes a blockedImport object for the identified blocked import at hand enhanced with the suggestion to use the `'use agnostic'` directive.
+ * @template {EffectiveDirective} T
+ * @template {EffectiveDirective} U
+ * @param {T} currentFileEffectiveDirective The current file's effective directive.
+ * @param {U} importedFileEffectiveDirective The imported file's effective directive.
+ * @returns The enhanced blockedImport object with the suggestion to use the `'use agnostic'` directive.
  */
-const makeIntroForSpecificViolationMessage = (
+const makeBlockedImportSuggestingUseAgnostic = (
   currentFileEffectiveDirective,
   importedFileEffectiveDirective
-) =>
-  commonsMakeIntroForSpecificViolationMessage(
-    effectiveDirectives_effectiveModules,
+) => {
+  const blockedImport = makeBlockedImport(
     currentFileEffectiveDirective,
     importedFileEffectiveDirective
   );
+  /** @type {`${typeof blockedImport.message} \n${SUGGEST_USE_AGNOSTIC}`} */
+  const blockedImportMessageSuggestingUseAgnostic = `${blockedImport.message} \n${SUGGEST_USE_AGNOSTIC}`;
-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.";
+  return Object.freeze({
+    ...blockedImport,
+    message: blockedImportMessageSuggestingUseAgnostic,
+  });
+};
 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 Server Functions, being able to import one another, can compose and do so via Server Logics, despite this method seeming superfluous at first glance. (Perhaps a preferrable use case for this has been found or could be found either today or in the future.)
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_LOGICS,
-        USE_CLIENT_LOGICS
-      )} Client Logics 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 Logics can run safely on the server just like they 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, as long at the Server Logics Module, by convention, does not export React components.
+    // USE_SERVER_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_LOGICS#USE_SERVER_LOGICS
+    // USE_SERVER_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_LOGICS#USE_SERVER_COMPONENTS
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_LOGICS#USE_SERVER_FUNCTIONS
+    makeBlockedImport(
+      USE_SERVER_LOGICS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_LOGICS#USE_CLIENT_LOGICS */,
+    makeBlockedImport(
+      USE_SERVER_LOGICS,
+      USE_CLIENT_COMPONENTS
+    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_LOGICS#USE_CLIENT_COMPONENTS */,
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_LOGICS#USE_AGNOSTIC_LOGICS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_LOGICS#USE_AGNOSTIC_COMPONENTS
   ],
   [USE_SERVER_COMPONENTS]: [
-    // USE_SERVER_LOGICS allowed, because Server Logics, being 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 Server Functions can be passed to imported Client Components within Server Components Modules, even though indeed Server Components Modules and Server Components can make their own Server Functions through inline 'use server' directives.
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_COMPONENTS,
-        USE_CLIENT_LOGICS
-      )} Client Logics 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 Logics can run safely on the server just like they 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_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_COMPONENTS#USE_SERVER_LOGICS
+    // USE_SERVER_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_COMPONENTS#USE_SERVER_COMPONENTS
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_COMPONENTS#USE_SERVER_FUNCTIONS
+    makeBlockedImport(
+      USE_SERVER_COMPONENTS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_COMPONENTS#USE_CLIENT_LOGICS */,
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_COMPONENTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_COMPONENTS#USE_AGNOSTIC_LOGICS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_COMPONENTS#USE_AGNOSTIC_COMPONENTS
   ],
   [USE_SERVER_FUNCTIONS]: [
-    // USE_SERVER_LOGICS allowed, because Server Logics, being logic from the server, can safely support Server Functions.
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_SERVER_COMPONENTS
-      )} Server Components aren't allowed because Server Functions have no business working with React Components.`,
-    },
-    // USE_SERVER_FUNCTIONS allowed, because Server Functions, even though they don't need to import one another and the same results can be generated via Server Logics for the outcome of a single Server Function, can still compose with one another. (Perhaps a preferrable use case for this has been found or could be found either today or in the future.)
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_CLIENT_LOGICS
-      )} Client Logics should never leak to the server.`,
-    },
-    {
-      blockedImport: USE_CLIENT_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_CLIENT_COMPONENTS
-      )} Client Components aren't allowed because Server Functions have no business working with React Components.`,
-    },
-    // USE_AGNOSTIC_LOGICS allowed, because Agnostic Logics can run safely on the server just like they can on the client.
-    {
-      blockedImport: USE_AGNOSTIC_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_AGNOSTIC_COMPONENTS
-      )} Agnostic Components aren't allowed because Server Functions have no business working with React Components.`,
-    },
+    // USE_SERVER_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_SERVER_LOGICS
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_SERVER_COMPONENTS */,
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_SERVER_FUNCTIONS
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_CLIENT_LOGICS */,
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_CLIENT_COMPONENTS
+    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_CLIENT_COMPONENTS */,
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_LOGICS
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_AGNOSTIC_COMPONENTS
+    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_COMPONENTS */,
   ],
   [USE_CLIENT_LOGICS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_LOGICS,
-        USE_SERVER_LOGICS
-      )} Server Logics should never leak to the client.
-${SUGGEST_USE_AGNOSTIC}`,
-    },
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_LOGICS,
-        USE_SERVER_COMPONENTS
-      )} Server Components cannot be thinkered with on the client.
-${SUGGEST_USE_AGNOSTIC}`,
-    },
-    // USE_SERVER_FUNCTIONS allowed, because Server Functions can technically be attached to Client Components that are being tinkered with within Client Logics Modules.
-    // 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 Logics can run safely on the client just like they 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, as long as the Client Logics Module, by convention, does not export React components.
+    makeBlockedImportSuggestingUseAgnostic(
+      USE_CLIENT_LOGICS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_SERVER_LOGICS */,
+    makeBlockedImportSuggestingUseAgnostic(
+      USE_CLIENT_LOGICS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_SERVER_COMPONENTS */,
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_CLIENT_LOGICS
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_AGNOSTIC_LOGICS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_AGNOSTIC_COMPONENTS
   ],
   [USE_CLIENT_COMPONENTS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_COMPONENTS,
-        USE_SERVER_LOGICS
-      )} Server Logics should never leak to the client.
-${SUGGEST_USE_AGNOSTIC}`,
-    },
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_COMPONENTS,
-        USE_SERVER_COMPONENTS
-      )} Server Components may only pass through Client Components via the children prop within Server Components Modules.
-${SUGGEST_USE_AGNOSTIC}`,
-    },
-    // USE_SERVER_FUNCTIONS allowed, because Server Functions are specifically triggered by Client Components.
-    // USE_CLIENT_LOGICS allowed, because Client Logics, being 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 Logics can run safely on the client just like they can on the server.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can render safely on the client just like they can on the server.
+    makeBlockedImportSuggestingUseAgnostic(
+      USE_CLIENT_LOGICS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_SERVER_LOGICS */,
+    makeBlockedImportSuggestingUseAgnostic(
+      USE_CLIENT_LOGICS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_SERVER_COMPONENTS */,
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_COMPONENTS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_COMPONENTS#USE_CLIENT_LOGICS
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_COMPONENTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_LOGICS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_COMPONENTS
   ],
   [USE_AGNOSTIC_LOGICS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_LOGICS,
-        USE_SERVER_LOGICS
-      )} Server Logics cannot run on both the server and the client.
-${SUGGEST_USE_AGNOSTIC}`,
-    },
-    {
-      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.
-${SUGGEST_USE_AGNOSTIC}`,
-    },
-    {
-      blockedImport: USE_SERVER_FUNCTIONS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_LOGICS,
-        USE_SERVER_FUNCTIONS
-      )} Server Functions can be modified on the server and on the client, but their use cases on both environments are not one-to-one compatible, since they're being addressed as they are on the server and addressed as references on the client.`,
-    },
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_LOGICS,
-        USE_CLIENT_LOGICS
-      )} Client Logics cannot run on 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.
+    makeBlockedImportSuggestingUseAgnostic(
+      USE_AGNOSTIC_LOGICS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_SERVER_LOGICS */,
+    makeBlockedImportSuggestingUseAgnostic(
+      USE_AGNOSTIC_LOGICS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_SERVER_COMPONENTS */,
+    makeBlockedImport(
+      USE_AGNOSTIC_LOGICS,
+      USE_SERVER_FUNCTIONS
+    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_SERVER_FUNCTIONS */,
+    makeBlockedImport(
+      USE_AGNOSTIC_LOGICS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_CLIENT_LOGICS */,
+    makeBlockedImport(
+      USE_AGNOSTIC_LOGICS,
+      USE_CLIENT_COMPONENTS
+    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_CLIENT_COMPONENTS */,
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_LOGICS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_COMPONENTS
   ],
   [USE_AGNOSTIC_COMPONENTS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_COMPONENTS,
-        USE_SERVER_LOGICS
-      )} Server Logics cannot run on both the server and the client.
-${SUGGEST_USE_AGNOSTIC}`,
-    },
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_COMPONENTS,
-        USE_SERVER_COMPONENTS
-      )} Server Components, unlike Client Components, cannot make silos of their own once on the opposing environment (the client in this case), and therefore cannot be executed from the client, making them unable to execute agnostically from both the server and the client.
-${SUGGEST_USE_AGNOSTIC}`,
-    },
-    // USE_SERVER_FUNCTIONS allowed, because Server Functions can be passed to Client Components as props when Client Components are also legally imported into Agnostic Components Modules.
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_COMPONENTS,
-        USE_CLIENT_LOGICS
-      )} Client Logics cannot run on 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 Agnostic Logics, being environment-agnostic logic, can safely support Agnostic Components.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can compose with one another.
+    makeBlockedImportSuggestingUseAgnostic(
+      USE_AGNOSTIC_COMPONENTS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_COMPONENTS#USE_SERVER_LOGICS */,
+    makeBlockedImportSuggestingUseAgnostic(
+      USE_AGNOSTIC_COMPONENTS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_COMPONENTS#USE_SERVER_COMPONENTS */,
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#AGNOSTIC20#USE_AGNOSTIC_COMPONENTS#USE_SERVER_FUNCTIONS
+    makeBlockedImport(
+      USE_AGNOSTIC_COMPONENTS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_COMPONENTS#USE_CLIENT_LOGICS */,
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_AGNOSTIC_COMPONENTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_LOGICS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#AGNOSTIC20#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_COMPONENTS
   ],
 });

package/library/agnostic20/_commons/utilities/helpers.js CHANGED Viewed

@@ -1,4 +1,3 @@
-import { effectiveDirectives_effectiveModules } from "../../../_commons/constants/bases.js";
 import {
   USE_SERVER,
   LOGICS,
@@ -145,7 +144,6 @@ export const makeMessageFromCurrentFileEffectiveDirective = (
   effectiveDirective
 ) =>
   makeMessageFromCurrentFileResolvedDirective(
-    effectiveDirectives_effectiveModules,
     effectiveDirectives_blockedImports,
     effectiveDirective
   );

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

@@ -1,4 +1,5 @@
 import {
+  directive21ConfigName,
   USE_SERVER_LOGICS as COMMONS_USE_SERVER_LOGICS,
   USE_CLIENT_LOGICS as COMMONS_USE_CLIENT_LOGICS,
   USE_AGNOSTIC_LOGICS as COMMONS_USE_AGNOSTIC_LOGICS,
@@ -9,11 +10,12 @@ import {
   USE_CLIENT_CONTEXTS as COMMONS_USE_CLIENT_CONTEXTS,
   USE_AGNOSTIC_CONDITIONS as COMMONS_USE_AGNOSTIC_CONDITIONS,
   USE_AGNOSTIC_STRATEGIES as COMMONS_USE_AGNOSTIC_STRATEGIES,
-  commentedDirectives_commentedModules,
 } from "../../../_commons/constants/bases.js";
 import { makeIntroForSpecificViolationMessage as commonsMakeIntroForSpecificViolationMessage } from "../../../_commons/utilities/helpers.js";
+import jscommentsConfig from "../../../../comments.config.js";
 /**
  * @typedef {import('../../../../types/directive21/_commons/typedefs.js').CommentedDirective} CommentedDirective
  * @typedef {import('../../../../types/directive21/_commons/typedefs.js').CommentedDirectiveWithoutUseAgnosticStrategies} CommentedDirectiveWithoutUseAgnosticStrategies
@@ -36,7 +38,7 @@ export const USE_AGNOSTIC_STRATEGIES = COMMONS_USE_AGNOSTIC_STRATEGIES;
 // commented directives array
 /** @type {CommentedDirectives} */
-export const commentedDirectivesArray = [
+export const commentedDirectivesArray = Object.freeze([
   USE_SERVER_LOGICS,
   USE_CLIENT_LOGICS,
   USE_AGNOSTIC_LOGICS,
@@ -47,7 +49,7 @@ export const commentedDirectivesArray = [
   USE_CLIENT_CONTEXTS,
   USE_AGNOSTIC_CONDITIONS,
   USE_AGNOSTIC_STRATEGIES,
-];
+]);
 // commented directives set
 /** @type {ReadonlySet<CommentedDirective>} */
@@ -80,7 +82,7 @@ export const AT_AGNOSTIC_CONDITIONS = "@agnosticConditions";
 // commented strategies array
 /** @type {CommentedStrategies} */
-export const strategiesArray = [
+export const strategiesArray = Object.freeze([
   AT_SERVER_LOGICS,
   AT_CLIENT_LOGICS,
   AT_AGNOSTIC_LOGICS,
@@ -90,7 +92,7 @@ export const strategiesArray = [
   AT_SERVER_FUNCTIONS,
   AT_CLIENT_CONTEXTS,
   AT_AGNOSTIC_CONDITIONS,
-];
+]);
 // commented strategies set
 /** @type {ReadonlySet<CommentedStrategy>} */
@@ -174,296 +176,215 @@ export const commentedDirectives_verificationReports = Object.freeze({
 /* commentedDirectives_blockedImports */
 /**
- * Makes the intro for each specific import rule violation messages.
- * @param {CommentedDirective} currentFileCommentedDirective The current file's commented directive.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} importedFileCommentedDirective The imported file's commented directive.
- * @returns "[Current file commented modules] are not allowed to import [imported file commented modules]."
+ * Makes a blockedImport object for the identified blocked import at hand.
+ * @template {CommentedDirectiveWithoutUseAgnosticStrategies} T
+ * @template {CommentedDirectiveWithoutUseAgnosticStrategies} U
+ * @param {T} currentFileCommentedDirective The current file's commented directive.
+ * @param {U} importedFileCommentedDirective The imported file's commented directive.
+ * @returns The blockedImport object for the identified blocked import at hand.
  */
-const makeIntroForSpecificViolationMessage = (
+export const makeBlockedImport = (
   currentFileCommentedDirective,
   importedFileCommentedDirective
-) =>
-  commonsMakeIntroForSpecificViolationMessage(
-    commentedDirectives_commentedModules,
-    currentFileCommentedDirective,
-    importedFileCommentedDirective
-  );
+) => {
+  return Object.freeze({
+    blockedImport: importedFileCommentedDirective,
+    message: `${commonsMakeIntroForSpecificViolationMessage(
+      currentFileCommentedDirective,
+      importedFileCommentedDirective
+    )} ${
+      jscommentsConfig[directive21ConfigName][currentFileCommentedDirective][
+        importedFileCommentedDirective
+      ]
+    }`,
+  });
+};
 export const commentedDirectives_blockedImports = Object.freeze({
   [USE_SERVER_LOGICS]: [
-    // USE_SERVER_LOGICS allowed, because Prime Server Logics can compose with one another.
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_LOGICS,
-        USE_CLIENT_LOGICS
-      )} Prime Client Logics should never leak to the server.`,
-    },
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client.
-    // USE_SERVER_COMPONENTS allowed, because Lineal Server Components are OK to be composed with Prime Server Logics as long as the Prime Server Logics Module, by convention, does not export React components.
-    {
-      blockedImport: USE_CLIENT_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_LOGICS,
-        USE_CLIENT_COMPONENTS
-      )} Lineal Client Components, like any Client Components, cannot be tinkered with on the server.`,
-    },
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can be composed with any Prime Environment Logics agnostically as long as the Prime Environment Logics Module, by convention, does not export React components.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions, being able to import one another, can compose and do so via Prime Server Logics, despite this method seeming superfluous at first glance. (Perhaps a preferrable use case for this has been found or could be found either today or in the future.)
-    {
-      blockedImport: USE_CLIENT_CONTEXTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_LOGICS,
-        USE_CLIENT_CONTEXTS
-      )} (Special) Client Contexts Components, like any Client Components, cannot be tinkered with on the server.`,
-    },
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components are able to safely render on the server, guaranteeing that only their `ComponentForServer` will be effectively involved in Prime Server Logics Modules.
+    // USE_SERVER_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_SERVER_LOGICS
+    makeBlockedImport(
+      USE_SERVER_LOGICS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_CLIENT_LOGICS */,
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_AGNOSTIC_LOGICS
+    // USE_SERVER_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_SERVER_COMPONENTS
+    makeBlockedImport(
+      USE_SERVER_LOGICS,
+      USE_CLIENT_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_CLIENT_COMPONENTS */,
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_AGNOSTIC_COMPONENTS
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_SERVER_FUNCTIONS
+    makeBlockedImport(
+      USE_SERVER_LOGICS,
+      USE_CLIENT_CONTEXTS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_CLIENT_CONTEXTS */,
+    // USE_AGNOSTIC_CONDITIONS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_AGNOSTIC_CONDITIONS
   ],
   [USE_CLIENT_LOGICS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_LOGICS,
-        USE_SERVER_LOGICS
-      )} Prime Server Logics should never leak to the client.`,
-    },
-    // USE_CLIENT_LOGICS allowed, because Prime Client Logics can compose with one another.
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the client just like they can on the server.
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_LOGICS,
-        USE_SERVER_COMPONENTS
-      )} Lineal Server Components cannot be thinkered with on the client.`,
-    },
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components, like any Client Components, are OK to be composed with Prime Client Logics as long as the Prime Client Logics Module, by convention, does not export React components.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can be composed with any Prime Environment Logics agnostically as long as the Prime Environment Logics Module, by convention, does not export React components.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can technically be attached to Client Components that are being tinkered with within Client Logics Modules.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components, like any Client Components, are OK to be composed with Prime Client Logics as long as the Prime Client Logics Module, by convention, does not export React components.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components are able to safely render on the client, guaranteeing that only their `ComponentForClient` will be effectively involved in Prime Client Logics Modules.
+    makeBlockedImport(
+      USE_CLIENT_LOGICS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_SERVER_LOGICS */,
+    // USE_CLIENT_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_CLIENT_LOGICS
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_AGNOSTIC_LOGICS
+    makeBlockedImport(
+      USE_CLIENT_LOGICS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_SERVER_COMPONENTS */,
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_AGNOSTIC_COMPONENTS
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_CONTEXTS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_AGNOSTIC_CONDITIONS
   ],
   [USE_AGNOSTIC_LOGICS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_LOGICS,
-        USE_SERVER_LOGICS
-      )} Prime Server Logics cannot run on both the server and the client.`,
-    },
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_LOGICS,
-        USE_CLIENT_LOGICS
-      )} Prime Client Logics cannot run on both the server and the client.`,
-    },
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can compose with one another.
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_LOGICS,
-        USE_SERVER_COMPONENTS
-      )} Lineal Server Components cannot be tinkered with on both the server and the client.`,
-    },
-    {
-      blockedImport: USE_CLIENT_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_LOGICS,
-        USE_CLIENT_COMPONENTS
-      )} Lineal Client Components, like any Client Components, cannot be tinkered with on both the server and the client.`,
-    },
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can be composed with any Prime Environment Logics agnostically as long as the Prime Environment Logics Module, by convention, does not export React components.
-    {
-      blockedImport: USE_SERVER_FUNCTIONS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_LOGICS,
-        USE_SERVER_FUNCTIONS
-      )} (Special) Server Functions can be modified on the server and on the client, but their use cases on both environments are not one-to-one compatible, since they're being addressed as they are on the server and addressed as references on the client.`,
-    },
-    {
-      blockedImport: USE_CLIENT_CONTEXTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_LOGICS,
-        USE_CLIENT_CONTEXTS
-      )} (Special) Client Contexts Components, like any Client Components, cannot be tinkered with on both the server and the client.`,
-    },
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, as if they were Lineal Agnostic Components themselves, can be composed with any Prime Environment Logics agnostically as long as the Prime Environment Logics Module, by convention, does not export React components.
+    makeBlockedImport(
+      USE_AGNOSTIC_LOGICS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_SERVER_LOGICS */,
+    makeBlockedImport(
+      USE_AGNOSTIC_LOGICS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_CLIENT_LOGICS */,
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_LOGICS
+    makeBlockedImport(
+      USE_AGNOSTIC_LOGICS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_SERVER_COMPONENTS */,
+    makeBlockedImport(
+      USE_AGNOSTIC_LOGICS,
+      USE_CLIENT_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_CLIENT_COMPONENTS */,
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_COMPONENTS
+    makeBlockedImport(
+      USE_AGNOSTIC_LOGICS,
+      USE_SERVER_FUNCTIONS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_SERVER_FUNCTIONS */,
+    makeBlockedImport(
+      USE_AGNOSTIC_LOGICS,
+      USE_CLIENT_CONTEXTS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_CLIENT_CONTEXTS */,
+    // USE_AGNOSTIC_CONDITIONS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_CONDITIONS
   ],
   [USE_SERVER_COMPONENTS]: [
-    // USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support Lineal Server Components.
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_COMPONENTS,
-        USE_CLIENT_LOGICS
-      )} Prime Client Logics should never leak to the server.`,
-    },
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client.
-    // USE_SERVER_COMPONENTS allowed, because Lineal Server Components can compose with one another, now that thanks to the inclusion of Agnostic Components they are actual Server Components.
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can be nested inside Server Components to create client boundaries when the root of the application is planted on the server.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the server just like they can on the client.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can be passed to imported Client Components within Lineal Server Components Modules, even though indeed Lineal Server Components Modules and Lineal Server Components can make their own Server Functions through inline 'use server' directives.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can be nested inside Server Components to wrap some of the tree with client state accessible through child Client Components, and to pass through Server Components when the root of the application is planted on the server.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, as if they were Lineal Agnostic Components themselves, can render safely on the server just like they can on the client.
+    // USE_SERVER_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_SERVER_LOGICS
+    makeBlockedImport(
+      USE_SERVER_COMPONENTS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_CLIENT_LOGICS */,
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_LOGICS
+    // USE_SERVER_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_SERVER_COMPONENTS
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_COMPONENTS
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_CONTEXTS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_CONDITIONS
   ],
   [USE_CLIENT_COMPONENTS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_COMPONENTS,
-        USE_SERVER_LOGICS
-      )} Prime Server Logics should never leak to the client.`,
-    },
-    // USE_CLIENT_LOGICS allowed, because Prime Client Logics, being logic from the client, can safely support Lineal Client Components, like any Client Components.
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the client just like they can on the server.
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_COMPONENTS,
-        USE_SERVER_COMPONENTS
-      )} Lineal Server Components cannot be the children of Lineal Client Components.`,
-    },
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can compose with one another.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the client just like they can on the server.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions are specifically triggered by Client Components.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can effectively become Lineal and only render their children on the client via this mechanism since, by a Client Contexts Component being the child of a Lineal Client Component, the Client Contexts Component's children become the grand-children of an ancestor Lineal Client Component, enforcing them to render exclusively on the client.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, as if they were Lineal Agnostic Components themselves, can render safely on the client just like they can on the server.
+    makeBlockedImport(
+      USE_CLIENT_COMPONENTS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_SERVER_LOGICS */,
+    // USE_CLIENT_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_CLIENT_LOGICS
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_LOGICS
+    makeBlockedImport(
+      USE_CLIENT_COMPONENTS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_SERVER_COMPONENTS */,
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_COMPONENTS
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_CONTEXTS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_CONDITIONS
   ],
   [USE_AGNOSTIC_COMPONENTS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_COMPONENTS,
-        USE_SERVER_LOGICS
-      )} Prime Server Logics cannot run on both the server and the client.`,
-    },
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_COMPONENTS,
-        USE_CLIENT_LOGICS
-      )} Prime Client Logics cannot run on both the server and the client.`,
-    },
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics, being environment-agnostic logic, can safely support Agnostic Components.
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_COMPONENTS,
-        USE_SERVER_COMPONENTS
-      )} Lineal Server Components, unlike Lineal Client Components, cannot make silos of their own once on the opposing environment (the client in this case), and therefore cannot be executed from the client, making them unable to execute agnostically from both the server and the client.`,
-    },
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can be nested inside Agnostic Components to create client boundaries when the root of the application is planted on the server.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components, can compose with one another.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can be passed to Client Components as props when Client Components are also legally imported into Agnostic Components Modules.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can be nested inside Agnostic Components to wrap some of the tree with client state accessible through child Client Components, and to pass through Server Components (if still on the Server Tree) when the root of the application is planted on the server.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components can compose with Lineal Agnostic Components as if they were Lineal Agnostic Components themselves, making them a necessary mechanism for Server Components to be nested in Agnostic Components.
+    makeBlockedImport(
+      USE_AGNOSTIC_COMPONENTS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_SERVER_LOGICS */,
+    makeBlockedImport(
+      USE_AGNOSTIC_COMPONENTS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_CLIENT_LOGICS */,
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_LOGICS
+    makeBlockedImport(
+      USE_AGNOSTIC_COMPONENTS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_SERVER_COMPONENTS */,
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_COMPONENTS
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_CONTEXTS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_CONDITIONS
   ],
   [USE_SERVER_FUNCTIONS]: [
-    // USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support (Special) Server Functions.
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_CLIENT_LOGICS
-      )} Prime Client Logics should never leak to the server.`,
-    },
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client.
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_SERVER_COMPONENTS
-      )} Lineal Server Components aren't allowed because (Special) Server Functions have no business working with React Components.`,
-    },
-    {
-      blockedImport: USE_CLIENT_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_CLIENT_COMPONENTS
-      )} Lineal Client Components aren't allowed because (Special) Server Functions have no business working with React Components.`,
-    },
-    {
-      blockedImport: USE_AGNOSTIC_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_AGNOSTIC_COMPONENTS
-      )} Lineal Agnostic Components aren't allowed because (Special) Server Functions have no business working with React Components.`,
-    },
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions, even though they don't need to import one another and the same results can be generated via Prime Server Logics for the outcome of a single Server Function, can still compose with one another. (Perhaps a preferrable use case for this has been found or could be found either today or in the future.)
-    {
-      blockedImport: USE_CLIENT_CONTEXTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_CLIENT_CONTEXTS
-      )} (Special) Client Contexts Components aren't allowed because (Special) Server Functions have no business working with React Components.`,
-    },
-    {
-      blockedImport: USE_AGNOSTIC_CONDITIONS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_SERVER_FUNCTIONS,
-        USE_AGNOSTIC_CONDITIONS
-      )} (Special) Agnostic Conditions Components aren't allowed because (Special) Server Functions have no business working with React Components.`,
-    },
+    // USE_SERVER_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_SERVER_LOGICS
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_CLIENT_LOGICS */,
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_LOGICS
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_SERVER_COMPONENTS */,
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_CLIENT_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_CLIENT_COMPONENTS */,
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_AGNOSTIC_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_COMPONENTS */,
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_SERVER_FUNCTIONS
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_CLIENT_CONTEXTS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_CLIENT_CONTEXTS */,
+    makeBlockedImport(
+      USE_SERVER_FUNCTIONS,
+      USE_AGNOSTIC_CONDITIONS
+    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_CONDITIONS */,
   ],
   [USE_CLIENT_CONTEXTS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_CONTEXTS,
-        USE_SERVER_LOGICS
-      )} Prime Server Logics should never leak to the client.`,
-    },
-    // USE_CLIENT_LOGICS allowed, because Prime Client Logics, being logic from the client, can safely support (Special) Client Contexts Components, like any Client Components.
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the client just like they can on the server.
-    {
-      blockedImport: USE_SERVER_COMPONENTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_CLIENT_CONTEXTS,
-        USE_SERVER_COMPONENTS
-      )} Lineal Server Components may only pass through (Special) Client Contexts Components via the children prop within Server Components Modules.`,
-    },
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can create client boundaries within (Special) Client Contexts Components.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the client just like they can on the server.
-    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions are specifically triggered by Client Components.
-    // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can compose with one another.
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, as if they were Lineal Agnostic Components themselves, can render safely on the client just like they can on the server, in a mechanism that allows (Special) Client Contexts Components to safely and indirectly compose with child Server Components within Client Contexts Modules.
+    makeBlockedImport(
+      USE_CLIENT_CONTEXTS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_SERVER_LOGICS */,
+    // USE_CLIENT_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_CLIENT_LOGICS
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_AGNOSTIC_LOGICS
+    makeBlockedImport(
+      USE_CLIENT_CONTEXTS,
+      USE_SERVER_COMPONENTS
+    ) /* $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_SERVER_COMPONENTS */,
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_AGNOSTIC_COMPONENTS
+    // USE_SERVER_FUNCTIONS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_SERVER_FUNCTIONS
+    // USE_CLIENT_CONTEXTS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_CLIENT_CONTEXTS
+    // USE_AGNOSTIC_CONDITIONS allowed, because $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_AGNOSTIC_CONDITIONS
   ],
   [USE_AGNOSTIC_CONDITIONS]: [
-    {
-      blockedImport: USE_SERVER_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_CONDITIONS,
-        USE_SERVER_LOGICS
-      )} Prime Server Logics cannot run on both the server and the client.`,
-    },
-    {
-      blockedImport: USE_CLIENT_LOGICS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_CONDITIONS,
-        USE_CLIENT_LOGICS
-      )} Prime Client Logics cannot run on both the server and the client.`,
-    },
-    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics, being environment-agnostic logic, can safely support Agnostic Components, including (Special) Agnostic Conditions Components. (In this case this is necessary for the import of the `conditionAgnosticComponent` function needed to make Agnostic Conditions Components.)
-    // USE_SERVER_COMPONENTS allowed, because Lineal Server Components are to be paired as `ComponentForServer` components with `ComponentForClient` components to form (Special) Agnostic Conditions Components.
-    // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components are to be paired as `ComponentForClient` components with `ComponentForServer` components to form (Special) Agnostic Conditions Components.
-    // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can take the place of `ComponentForServer` and/or `ComponentForClient` components to form (Special) Agnostic Conditions Components.
-    {
-      blockedImport: USE_SERVER_FUNCTIONS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_CONDITIONS,
-        USE_SERVER_FUNCTIONS
-      )} (Special) Server Functions are not accepted because (Special) Agnostic Conditions Components only take finite, imported components as arguments in their making. As such, assigning props to these components, including Server Functions, is not made within Agnostic Conditions Modules.`,
-    },
-    {
-      blockedImport: USE_CLIENT_CONTEXTS,
-      message: `${makeIntroForSpecificViolationMessage(
-        USE_AGNOSTIC_CONDITIONS,
-        USE_CLIENT_CONTEXTS
-      )} (Special) Client Contexts Components cannot be used as component arguments for (Special) Agnostic Conditions Components since they only take Lineal Components as arguments in their making.`,
-    },
-    // USE_AGNOSTIC_CONDITIONS allowed, because (Special) Agnostic Conditions Components, despite not being Lineal Components themselves, output components that can only be Lineal and compatible with their attributed rendering environments, making them acceptable arguments in the making of Agnostic Conditions Components.
-  ],
-  [USE_AGNOSTIC_STRATEGIES]: [
-    // (Special) Agnostic Strategies Modules can import all known modules, except themselves since they cannot be imported as they are, only as and via Strategies. (Since Agnostic Strategies Modules cannot be imported as they are, there is no such things as a 'use agnostic strategies' importFileCommentedDirective.)
+    makeBlockedImport(
+      USE_AGNOSTIC_CONDITIONS,
+      USE_SERVER_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_LOGICS */,
+    makeBlockedImport(
+      USE_AGNOSTIC_CONDITIONS,
+      USE_CLIENT_LOGICS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_LOGICS */,
+    // USE_AGNOSTIC_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_LOGICS
+    // USE_SERVER_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_COMPONENTS
+    // USE_CLIENT_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_COMPONENTS
+    // USE_AGNOSTIC_COMPONENTS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_COMPONENTS
+    makeBlockedImport(
+      USE_AGNOSTIC_CONDITIONS,
+      USE_SERVER_FUNCTIONS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_FUNCTIONS */,
+    makeBlockedImport(
+      USE_AGNOSTIC_CONDITIONS,
+      USE_CLIENT_CONTEXTS
+    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_CONTEXTS */,
+    // USE_AGNOSTIC_CONDITIONS allowed, because $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_CONDITIONS
   ],
 });

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

@@ -186,6 +186,9 @@ export const importsFlow = (context, node, currentFileCommentedDirective) => {
   if (result.skip) return;
   const { importedFileCommentedDirective } = result;
+  // returns early is the current file is an Agnostic Strategies Module
+  if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) return;
   if (
     isImportBlocked(
       currentFileCommentedDirective,

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

@@ -1,7 +1,4 @@
-import {
-  exportNotStrategized,
-  commentedDirectives_commentedModules,
-} from "../../../_commons/constants/bases.js";
+import { exportNotStrategized } from "../../../_commons/constants/bases.js";
 import {
   USE_AGNOSTIC_LOGICS,
   USE_AGNOSTIC_STRATEGIES,
@@ -138,7 +135,7 @@ export const getCommentedDirectiveFromCurrentModule = (context) => {
  * - `'use agnostic strategies'`: Agnostic Strategies Modules may export JSX.
  * @param {CommentedDirective} directive The commented directive as written on top of the file (cannot be `null` at that stage).
  * @param {Extension} extension The JavaScript (TypeScript) extension of the file.
- * @returns {CommentedDirective | null} 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.
+ * @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, extension) => {
   const rule = commentedDirectives_extensionRules[directive];
@@ -226,8 +223,9 @@ export const getStrategizedDirective = (context, node) => {
 /**
  * Returns a boolean deciding if an imported file's commented directive is incompatible with the current file's commented directive.
- * @param {CommentedDirective} currentFileCommentedDirective The current file's commented directive.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} importedFileCommentedDirective The imported file's commented directive.
+ * @template {CommentedDirectiveWithoutUseAgnosticStrategies} T
+ * @param {T} currentFileCommentedDirective The current file's commented directive.
+ * @param {T} importedFileCommentedDirective The imported file's commented directive.
  * @returns `true` if the import is blocked, as established in `commentedDirectives_BlockedImports`.
  */
 export const isImportBlocked = (
@@ -244,14 +242,13 @@ export const isImportBlocked = (
 /**
  * Lists in an message the commented modules incompatible with a commented module based on its commented directive.
- * @param {CommentedDirective} commentedDirective The commented directive of the commented module.
+ * @param {CommentedDirectiveWithoutUseAgnosticStrategies} commentedDirective The commented directive of the commented module.
  * @returns The message listing the incompatible commented modules.
  */
 export const makeMessageFromCurrentFileCommentedDirective = (
   commentedDirective
 ) =>
   makeMessageFromCurrentFileResolvedDirective(
-    commentedDirectives_commentedModules,
     commentedDirectives_blockedImports,
     commentedDirective
   );
@@ -260,8 +257,9 @@ export const makeMessageFromCurrentFileCommentedDirective = (
 /**
  * Finds the `message` for the specific violation of commented directives import rules based on `commentedDirectives_BlockedImports`.
- * @param {CommentedDirective} currentFileCommentedDirective The current file's commented directive.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} importedFileCommentedDirective The imported file's commented directive.
+ * @template {CommentedDirectiveWithoutUseAgnosticStrategies} T
+ * @param {T} currentFileCommentedDirective The current file's commented directive.
+ * @param {T} importedFileCommentedDirective The imported file's commented directive.
  * @returns The corresponding `message`.
  */
 export const findSpecificViolationMessage = (

package/library/directive21/config.js CHANGED Viewed

@@ -8,7 +8,7 @@ import {
 } from "../_commons/constants/bases.js";
 /**
- * @typedef {import('../../types/agnostic20/_commons/typedefs.js').Plugin} Plugin
+ * @typedef {import('../../types/directive21/_commons/typedefs.js').Plugin} Plugin
  */
 /**

package/package.json CHANGED Viewed

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