npm - eslint-plugin-use-agnostic - Versions diffs - 1.1.0 → 1.2.0 - Mend

eslint-plugin-use-agnostic 1.1.0 → 1.2.0

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/comments.config.js +10 -2
package/jscomments/_commons/constants/bases.js +95 -0
package/jscomments/agnostic20/constants/modules-comments.js +28 -14
package/jscomments/directive21/constants/modules-comments.js +52 -25
package/library/agnostic20/_commons/constants/bases.js +49 -49
package/library/agnostic20/_commons/utilities/helpers.js +4 -4
package/library/directive21/_commons/constants/bases.js +81 -81
package/library/directive21/_commons/utilities/helpers.js +0 -3
package/package.json +1 -1

package/comments.config.js CHANGED Viewed

@@ -3,11 +3,18 @@ import {
   directive21ConfigName,
 } from "./library/_commons/constants/bases.js";
+import {
+  jSDocComments,
+  testsComments,
+} from "./jscomments/_commons/constants/bases.js";
 import { agnostic20Comments } from "./jscomments/agnostic20/constants/bases.js";
 import { directive21Comments } from "./jscomments/directive21/constants/bases.js";
 const config = Object.freeze({
-  comment: "comment", // $COMMENT#COMMENT in code, "comment" on hover when resolved by the VSCode extension JSComments
+  jsDoc: jSDocComments,
+  // ...jSDocComments,
+  tests: testsComments,
+  // ...testsComments,
   [agnostic20ConfigName]: agnostic20Comments,
   [directive21ConfigName]: directive21Comments,
 });
@@ -15,11 +22,12 @@ const config = Object.freeze({
 export default config;
 /* Notes
+comment: "comment", // $COMMENT#COMMENT in code, "comment" on hover when resolved by the VSCode extension JSComments
 Aims of the VSCode extension JSComments:
 - automatically capitalizes keys, so here:
   - config.comment would return $COMMENT#COMMENT
 - automatically chain keys within keys, so here
   - config["agnostic20"] would return $COMMENT#AGNOSTIC20#*
   - config["directive21"] would return $COMMENT#DIRECTIVE21#*
-- this way, instead doing a find-replace on a big documentation comment, the comment stays within the config and only the config placeholder is found and replaced for the same results
+- this way, instead doing a find-replace on a big documentation comment, the comment stays within the config and only the config placeholder is found and replaced for the same results
 */

package/jscomments/_commons/constants/bases.js ADDED Viewed

@@ -0,0 +1,95 @@
+// comment variables for JSDoc definitions
+export const jSDocComments = Object.freeze({
+  // library/_commons/utilities/helpers.js
+  basePath: "The absolute import path with extension yet resolved.",
+  currentDir:
+    "The directory of the file containing the import (from `path.dirname(context.filename)`).",
+  importPath:
+    "The import specifier (e.g., `@/components/Button` or `./utils`), from the current node.",
+  cwd: "The project root (from `context.cwd`).",
+  fileResolvedPath: "The resolved path of the file.",
+  aContext: "An ESLint rule's `context` object.",
+  resolvedDirectives_blockedImports: `The blocked imports object, either for agnostic20 or for directive21.`,
+  currentFileResolvedDirective: `The current file's "resolved" directive.`,
+  importedFileResolvedDirective: `The imported file's "resolved" directive.`,
+  theCurrentFileResolvedDirective: `The "resolved" directive of the "resolved" module.`,
+  // library/ ... /config.js
+  plugin: "The use-agnostic ESLint plugin itself.",
+  // library/agnostic20/_commons/constants/bases.js
+  currentFileEffectiveDirective: "The current file's effective directive.",
+  importedFileEffectiveDirective: "The imported file's effective directive.",
+  // library/ ... /flows.js
+  context: "The ESLint rule's `context` object.",
+  node: "The ESLint `node` of the rule's current traversal.",
+  // library/ ... /helpers.js
+  extension: "The JavaScript (TypeScript) extension of the file.",
+  resolvedPath: "The resolved path of the imported module.",
+  // library/agnostic20/_commons/utilities/helpers.js
+  ast: "The module's AST (Abstract Syntax Tree).",
+  directiveA20: `The directive as written on top of the file (\`"no directive"\` if no valid directive).`,
+  effectiveDirective: "The effective directive of the effective module.",
+  serverByDefault: `\`null\` denotes a server-by-default module, ideally a Server Module.`,
+  useServer: `\`'use server'\` denotes a Server Functions Module.`,
+  useClient: `\`'use client'\` denotes a Client Module.`,
+  useAgnostic: `\`'use agnostic'\` denotes an Agnostic Module (formerly Shared Module).`,
+  useServerLogics20: `\`'use server logics'\` denotes a Server Logics Module.`,
+  useServerComponents20: `\`'use server components'\` denotes a Server Components Module.`,
+  useServerFunctions20: `\`'use server functions'\` denotes a Server Functions Module.`,
+  useClientLogics20: `\`'use client logics'\` denotes a Client Logics Module.`,
+  useClientComponents20: `\`'use client components'\` denotes a Client Components Module.`,
+  useAgnosticLogics20: `\`'use agnostic logics'\` denotes an Agnostic Logics Module.`,
+  useAgnosticComponents20: `\`'use agnostic components'\` denotes an Agnostic Components Module.`,
+  // library/directive21/_commons/constants/bases.js
+  currentFileCommentedDirective: "The current file's commented directive.",
+  importedFileCommentedDirective: "The imported file's commented directive.",
+  // library/directive21/_commons/utilities/helpers.js
+  string: "The original string.",
+  sourceCode: "The ESLint SourceCode object.",
+  directiveD21:
+    "The commented directive as written on top of the file (cannot be `null` at that stage).",
+  commentedDirective: "The commented directive of the commented module.",
+  useServerLogics21: `\`'use server logics'\`, \`"use server logics"\` denoting a Server Logics Module.`,
+  useClientLogics21: `\`'use client logics'\`, \`"use client logics"\` denoting a Client Logics Module.`,
+  useAgnosticLogics21: `\`'use agnostic logics'\`, \`"use agnostic logics"\` denoting an Agnostic Logics Module.`,
+  useServerComponents21: `\`'use server components'\`, \`"use server components"\` denoting a Server Components Module.`,
+  useClientComponents21: `\`'use client components'\`, \`"use client components"\` denoting a Client Components Module.`,
+  useAgnosticComponents21: `\`'use agnostic components'\`, \`"use agnostic components"\` denoting an Agnostic Components Module.`,
+  useServerFunctions21: `\`'use server functions'\`, \`"use server functions"\` denoting a Server Functions Module.`,
+  useClientContexts21: `\`'use client contexts'\`, \`"use client contexts"\` denoting a Client Contexts Module.`,
+  useAgnosticConditions21: `\`'use agnostic conditions'\`, \`"use agnostic conditions"\` denoting an Agnostic Conditions Module.`,
+  useAgnosticStrategies21: `\`'use agnostic strategies'\`, \`"use agnostic strategies"\` denoting an Agnostic Strategies Module.`,
+  useServerLogicsExtensionRule: `\`'use server logics'\`: Server Logics Modules do NOT export JSX.`,
+  useClientLogicsExtensionRule: `\`'use client logics'\`: Client Logics Modules do NOT export JSX.`,
+  useAgnosticLogicsExtensionRule: `\`'use agnostic logics'\`: Agnostic Logics Modules do NOT export JSX.`,
+  useServerComponentsExtensionRule: `\`'use server components'\`: Server Components Modules ONLY export JSX.`,
+  useClientComponentsExtensionRule: `\`'use client components'\`: Client Components Modules ONLY export JSX.`,
+  useAgnosticComponentsExtensionRule: `\`'use agnostic components'\`: Agnostic Components Modules ONLY export JSX.`,
+  useServerFunctionsExtensionRule: `\`'use server functions'\`: Server Functions Modules do NOT export JSX.`,
+  useClientContextsExtensionRule: `\`'use client contexts'\`: Client Contexts Modules ONLY export JSX.`,
+  useAgnosticConditionsExtensionRule: `\`'use agnostic conditions'\`: Agnostic Conditions Modules ONLY export JSX.`,
+  useAgnosticStrategiesExtensionRule: `\`'use agnostic strategies'\`: Agnostic Strategies Modules may export JSX.`,
+  // tests/_commons/utilities/helpers.js
+  folderPath: "The provided directory.",
+  allFiles:
+    "The accumulator array of file paths. Defaults to an empty array on the initial call, and is passed through each recursive call to be mutated and collect results.",
+  javaScriptErrorsLength: "The number of errors expected on JavaScript files.",
+  typeScriptErrorsLength: "The number of errors expected on TypeScript files.",
+  messageId: "The messageId of the errors expected.",
+});
+// comment variables for tests flavor texts
+export const testsComments = Object.freeze({
+  thatsA: "That's a",
+  thatsAn: "That's an",
+  importingA: "...Importing a",
+  withExtension: "with extension",
+  withExtensionParentheses: "(with extension).",
+  byFolder: "by a folder.",
+  importing: "...Importing",
+  viaStrategy: "via Special Agnostic Strategy",
+  viaStrategyPeriod: "via Special Agnostic Strategy.",
+  viaAlias: "Via alias.",
+  viaBaseUrl: "Via baseUrl.",
+  valid: "Valid.",
+  invalid: "Invalid.",
+});

package/jscomments/agnostic20/constants/modules-comments.js CHANGED Viewed

@@ -17,13 +17,15 @@ export const serverLogicsComments = Object.freeze({
   [USE_SERVER_FUNCTIONS]:
     /* valid */ "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.)",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Client Logics should never leak to the server.",
+    /* invalid */ "Client Logics should never leak to the server, such as would be the case here in a Server Logics Module.",
   [USE_CLIENT_COMPONENTS]:
     /* invalid */ "Client Components cannot be tinkered with on the server.",
   [USE_AGNOSTIC_LOGICS]:
-    /* valid */ "Agnostic Logics can run safely on the server just like they can on the client.",
+    /* valid */ "Agnostic Logics can run safely on the server just like they can on the client, such as is the case here in a Server Logics Module.",
   [USE_AGNOSTIC_COMPONENTS]:
     /* valid */ "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.",
+  module: "Server Logics Module",
+  modulePeriod: "Server Logics Module.",
 });
 export const serverComponentsComments = Object.freeze({
@@ -34,13 +36,15 @@ export const serverComponentsComments = Object.freeze({
   [USE_SERVER_FUNCTIONS]:
     /* valid */ "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.",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Client Logics should never leak to the server.",
+    /* invalid */ "Client Logics should never leak to the server, such as would be the case here in a Server Components Module.",
   [USE_CLIENT_COMPONENTS]:
     /* valid */ "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]:
-    /* valid */ "Agnostic Logics can run safely on the server just like they can on the client.",
+    /* valid */ "Agnostic Logics can run safely on the server just like they can on the client, such as is the case here in a Server Components Module.",
   [USE_AGNOSTIC_COMPONENTS]:
     /* valid */ "Agnostic Components can render safely on the server just like they can on the client.",
+  module: "Server Components Module",
+  modulePeriod: "Server Components Module.",
 });
 export const serverFunctionsComments = Object.freeze({
@@ -51,18 +55,20 @@ export const serverFunctionsComments = Object.freeze({
   [USE_SERVER_FUNCTIONS]:
     /* valid */ "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.)",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Client Logics should never leak to the server.",
+    /* invalid */ "Client Logics should never leak to the server, such as would be the case here in a Server Functions Module.",
   [USE_CLIENT_COMPONENTS]:
     /* invalid */ "Client Components aren't allowed because Server Functions have no business working with React Components.",
   [USE_AGNOSTIC_LOGICS]:
-    /* valid */ "Agnostic Logics can run safely on the server just like they can on the client.",
+    /* valid */ "Agnostic Logics can run safely on the server just like they can on the client, such as is the case here in a Server Functions Module.",
   [USE_AGNOSTIC_COMPONENTS]:
     /* invalid */ "Agnostic Components aren't allowed because Server Functions have no business working with React Components.",
+  module: "Server Functions Module",
+  modulePeriod: "Server Functions Module.",
 });
 export const clientLogicsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Server Logics should never leak to the client.",
+    /* invalid */ "Server Logics should never leak to the client, such as would be the case here in a Client Logics Module.",
   [USE_SERVER_COMPONENTS]:
     /* invalid */ "Server Components cannot be thinkered with on the client.",
   [USE_SERVER_FUNCTIONS]:
@@ -72,14 +78,16 @@ export const clientLogicsComments = Object.freeze({
   [USE_CLIENT_COMPONENTS]:
     /* valid */ "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]:
-    /* valid */ "Agnostic Logics can run safely on the client just like they can on the server.",
+    /* valid */ "Agnostic Logics can run safely on the client just like they can on the server, such as is the case here in a Client Logics Module.",
   [USE_AGNOSTIC_COMPONENTS]:
     /* valid */ "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.",
+  module: "Client Logics Module",
+  modulePeriod: "Client Logics Module.",
 });
 export const clientComponentsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Server Logics should never leak to the client.",
+    /* invalid */ "Server Logics should never leak to the client, such as would be the case here in a Client Components Module.",
   [USE_SERVER_COMPONENTS]:
     /* invalid */ "Server Components may only pass through Client Components via the children prop within Server Components Modules.",
   [USE_SERVER_FUNCTIONS]:
@@ -89,41 +97,47 @@ export const clientComponentsComments = Object.freeze({
   [USE_CLIENT_COMPONENTS]:
     /* valid */ "Client Components can compose with one another.",
   [USE_AGNOSTIC_LOGICS]:
-    /* valid */ "Agnostic Logics can run safely on the client just like they can on the server.",
+    /* valid */ "Agnostic Logics can run safely on the client just like they can on the server, such as is the case here in a Client Components Module.",
   [USE_AGNOSTIC_COMPONENTS]:
     /* valid */ "Agnostic Components can render safely on the client just like they can on the server.",
+  module: "Client Components Module",
+  modulePeriod: "Client Components Module.",
 });
 export const agnosticLogicsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Server Logics cannot run on both the server and the client.",
+    /* invalid */ "Server Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Logics Module.",
   [USE_SERVER_COMPONENTS]:
     /* invalid */ "Server Components cannot be tinkered with on both the server and the client.",
   [USE_SERVER_FUNCTIONS]:
     /* invalid */ "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.",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Client Logics cannot run on both the server and the client.",
+    /* invalid */ "Client Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Logics Module.",
   [USE_CLIENT_COMPONENTS]:
     /* invalid */ "Client Components cannot be tinkered with on both the server and the client.",
   [USE_AGNOSTIC_LOGICS]:
     /* valid */ "Agnostic Logics can compose with one another.",
   [USE_AGNOSTIC_COMPONENTS]:
     /* valid */ "Agnostic Components can be composed with Logics agnostically as long as the Agnostic Logics Module, by convention, does not export React components.",
+  module: "Agnostic Logics Module",
+  modulePeriod: "Agnostic Logics Module.",
 });
 export const agnosticComponentsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Server Logics cannot run on both the server and the client.",
+    /* invalid */ "Server Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Components Module.",
   [USE_SERVER_COMPONENTS]:
     /* invalid */ "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.",
   [USE_SERVER_FUNCTIONS]:
     /* valid */ "Server Functions can be passed to Client Components as props when Client Components are also legally imported into Agnostic Components Modules.",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Client Logics cannot run on both the server and the client.",
+    /* invalid */ "Client Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Components Module.",
   [USE_CLIENT_COMPONENTS]:
     /* valid */ "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]:
     /* valid */ "Agnostic Logics, being environment-agnostic logic, can safely support Agnostic Components.",
   [USE_AGNOSTIC_COMPONENTS]:
     /* valid */ "Agnostic Components can compose with one another.",
+  module: "Agnostic Components Module",
+  modulePeriod: "Agnostic Components Module.",
 });

package/jscomments/directive21/constants/modules-comments.js CHANGED Viewed

@@ -15,49 +15,55 @@ export const serverLogicsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
     /* valid */ "Prime Server Logics can compose with one another.",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Prime Client Logics should never leak to the server.",
+    /* invalid */ "Prime Client Logics should never leak to the server, such as would be the case here in a Prime Server Logics Module.",
   [USE_AGNOSTIC_LOGICS]:
-    /* valid */ "Prime Agnostic Logics can run safely on the server just like they can on the client.",
+    /* valid */ "Prime Agnostic Logics can run safely on the server just like they can on the client, such as is the case here in a Prime Server Logics Module.",
   [USE_SERVER_COMPONENTS]:
     /* valid */ "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.",
   [USE_CLIENT_COMPONENTS]:
     /* invalid */ "Lineal Client Components, like any Client Components, cannot be tinkered with on the server.",
   [USE_AGNOSTIC_COMPONENTS]:
-    /* valid */ "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.",
+    /* valid */ "Lineal Agnostic Components can be composed with any Prime Environment Logics agnostically, such as Prime Server Logics, as long as the Prime Environment Logics Module, by convention, does not export React components.",
   [USE_SERVER_FUNCTIONS]:
     /* valid */ "(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.)",
   [USE_CLIENT_CONTEXTS]:
     /* invalid */ "Client Contexts Components, like any Client Components, cannot be tinkered with on the server.",
   [USE_AGNOSTIC_CONDITIONS]:
     /* valid */ "(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.",
+  module: "Prime Server Logics Module",
+  modulePeriod: "Prime Server Logics Module.",
+  kinds: "Prime Server Logics",
 });
 export const clientLogicsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Prime Server Logics should never leak to the client.",
+    /* invalid */ "Prime Server Logics should never leak to the client, such as would be the case here in a Prime Client Logics Module.",
   [USE_CLIENT_LOGICS]:
     /* valid */ "Prime Client Logics can compose with one another.",
   [USE_AGNOSTIC_LOGICS]:
-    /* valid */ "Prime Agnostic Logics can run safely on the client just like they can on the server.",
+    /* valid */ "Prime Agnostic Logics can run safely on the client just like they can on the server, such as is the case here in a Prime Client Logics Module.",
   [USE_SERVER_COMPONENTS]:
     /* invalid */ "Lineal Server Components cannot be thinkered with on the client.",
   [USE_CLIENT_COMPONENTS]:
     /* valid */ "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]:
-    /* valid */ "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.",
+    /* valid */ "Lineal Agnostic Components can be composed with any Prime Environment Logics agnostically, such as Prime Client Logics, as long as the Prime Environment Logics Module, by convention, does not export React components.",
   [USE_SERVER_FUNCTIONS]:
     /* valid */ "(Special) Server Functions can technically be attached to Client Components that are being tinkered with within Client Logics Modules.",
   [USE_CLIENT_CONTEXTS]:
     /* valid */ "(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]:
     /* valid */ "(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.",
+  module: "Prime Client Logics Module",
+  modulePeriod: "Prime Client Logics Module.",
+  kinds: "Prime Client Logics",
 });
 export const agnosticLogicsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Prime Server Logics cannot run on both the server and the client.",
+    /* invalid */ "Prime Server Logics cannot run on both the server and the client, such as would be the case here in a Prime Agnostic Logics Module.",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Prime Client Logics cannot run on both the server and the client.",
+    /* invalid */ "Prime Client Logics cannot run on both the server and the client, such as would be the case here in a Prime Agnostic Logics Module.",
   [USE_AGNOSTIC_LOGICS]:
     /* valid */ "Prime Agnostic Logics can compose with one another.",
   [USE_SERVER_COMPONENTS]:
@@ -65,22 +71,25 @@ export const agnosticLogicsComments = Object.freeze({
   [USE_CLIENT_COMPONENTS]:
     /* invalid */ "Lineal Client Components, like any Client Components, cannot be tinkered with on both the server and the client.",
   [USE_AGNOSTIC_COMPONENTS]:
-    /* valid */ "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.",
+    /* valid */ "Lineal Agnostic Components can be composed with any Prime Environment Logics agnostically, such as Prime Agnostic Logics, as long as the Prime Environment Logics Module, by convention, does not export React components.",
   [USE_SERVER_FUNCTIONS]:
     /* invalid */ "(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.",
   [USE_CLIENT_CONTEXTS]:
     /* invalid */ "(Special) Client Contexts Components, like any Client Components, cannot be tinkered with on both the server and the client.",
   [USE_AGNOSTIC_CONDITIONS]:
     /* valid */ "(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.",
+  module: "Prime Agnostic Logics Module",
+  modulePeriod: "Prime Agnostic Logics Module.",
+  kinds: "Prime Agnostic Logics",
 });
 export const serverComponentsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
     /* valid */ "Prime Server Logics, being logic from the server, can safely support Lineal Server Components.",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Prime Client Logics should never leak to the server.",
+    /* invalid */ "Prime Client Logics should never leak to the server, such as would be the case here in a Lineal Server Components Module.",
   [USE_AGNOSTIC_LOGICS]:
-    /* valid */ "Prime Agnostic Logics can run safely on the server just like they can on the client.",
+    /* valid */ "Prime Agnostic Logics can run safely on the server just like they can on the client, such as is the case here in a Lineal Server Components Module.",
   [USE_SERVER_COMPONENTS]:
     /* valid */ "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]:
@@ -93,34 +102,40 @@ export const serverComponentsComments = Object.freeze({
     /* valid */ "(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]:
     /* valid */ "(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.",
+  module: "Lineal Server Components Module",
+  modulePeriod: "Lineal Server Components Module.",
+  kinds: "Lineal Server Components",
 });
 export const clientComponentsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Prime Server Logics should never leak to the client.",
+    /* invalid */ "Prime Server Logics should never leak to the client, such as would be the case here in a Lineal Client Components Module.",
   [USE_CLIENT_LOGICS]:
     /* valid */ "Prime Client Logics, being logic from the client, can safely support Lineal Client Components, like any Client Components.",
   [USE_AGNOSTIC_LOGICS]:
-    /* valid */ "Prime Agnostic Logics can run safely on the client just like they can on the server.",
+    /* valid */ "Prime Agnostic Logics can run safely on the client just like they can on the server, such as is the case here in a Lineal Client Components Module.",
   [USE_SERVER_COMPONENTS]:
     /* invalid */ "Lineal Server Components cannot be the children of Lineal Client Components.",
   [USE_CLIENT_COMPONENTS]:
     /* valid */ "Lineal Client Components can compose with one another.",
   [USE_AGNOSTIC_COMPONENTS]:
-    /* valid */ "Lineal Agnostic Components can render safely on the client just like they can on the server.",
+    /* valid */ "Lineal Agnostic Components can render safely on the client just like they can on the server, such as is the case here in a Lineal Client Components Module.",
   [USE_SERVER_FUNCTIONS]:
-    /* valid */ "(Special) Server Functions are specifically triggered by Client Components.",
+    /* valid */ "(Special) Server Functions are specifically triggered by Client Components, such as is the case here in a Lineal Client Components Module.",
   [USE_CLIENT_CONTEXTS]:
     /* valid */ "(Special) Client Contexts Components can effectively become Lineal and only render their children on the client via this mechanism since, by a Client Contexts Component being the child of a Lineal Client Component, the Client Contexts Component's children become the grand-children of an ancestor Lineal Client Component, enforcing them to render exclusively on the client.",
   [USE_AGNOSTIC_CONDITIONS]:
     /* valid */ "(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.",
+  module: "Lineal Client Components Module",
+  modulePeriod: "Lineal Client Components Module.",
+  kinds: "Lineal Client Components",
 });
 export const agnosticComponentsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Prime Server Logics cannot run on both the server and the client.",
+    /* invalid */ "Prime Server Logics cannot run on both the server and the client, such as would be the case here in a Lineal Agnostic Components Module.",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Prime Client Logics cannot run on both the server and the client.",
+    /* invalid */ "Prime Client Logics cannot run on both the server and the client, such as would be the case here in a Lineal Agnostic Components Module.",
   [USE_AGNOSTIC_LOGICS]:
     /* valid */ "Prime Agnostic Logics, being environment-agnostic logic, can safely support Agnostic Components.",
   [USE_SERVER_COMPONENTS]:
@@ -135,15 +150,18 @@ export const agnosticComponentsComments = Object.freeze({
     /* valid */ "(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]:
     /* valid */ "(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.",
+  module: "Lineal Agnostic Components Module",
+  modulePeriod: "Lineal Agnostic Components Module.",
+  kinds: "Lineal Agnostic Components",
 });
 export const serverFunctionsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
     /* valid */ "Prime Server Logics, being logic from the server, can safely support (Special) Server Functions.",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Prime Client Logics should never leak to the server.",
+    /* invalid */ "Prime Client Logics should never leak to the server, such as would be the case here in a Special Server Functions Module.",
   [USE_AGNOSTIC_LOGICS]:
-    /* valid */ "Prime Agnostic Logics can run safely on the server just like they can on the client.",
+    /* valid */ "Prime Agnostic Logics can run safely on the server just like they can on the client, such as is the case here in a Special Server Functions Module.",
   [USE_SERVER_COMPONENTS]:
     /* invalid */ "Lineal Server Components aren't allowed because (Special) Server Functions have no business working with React Components.",
   [USE_CLIENT_COMPONENTS]:
@@ -156,34 +174,40 @@ export const serverFunctionsComments = Object.freeze({
     /* invalid */ "(Special) Client Contexts Components aren't allowed because (Special) Server Functions have no business working with React Components.",
   [USE_AGNOSTIC_CONDITIONS]:
     /* invalid */ "(Special) Agnostic Conditions Components aren't allowed because (Special) Server Functions have no business working with React Components.",
+  module: "Special Server Functions Module",
+  modulePeriod: "Special Server Functions Module.",
+  kinds: "Special Server Functions",
 });
 export const clientContextsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Prime Server Logics should never leak to the client.",
+    /* invalid */ "Prime Server Logics should never leak to the client, such as would be the case here in a Special Client Contexts Module.",
   [USE_CLIENT_LOGICS]:
     /* valid */ "Prime Client Logics, being logic from the client, can safely support (Special) Client Contexts Components, like any Client Components.",
   [USE_AGNOSTIC_LOGICS]:
-    /* valid */ "Prime Agnostic Logics can run safely on the client just like they can on the server.",
+    /* valid */ "Prime Agnostic Logics can run safely on the client just like they can on the server, such as is the case here in a Special Client Contexts Module.",
   [USE_SERVER_COMPONENTS]:
     /* invalid */ "Lineal Server Components may only pass through (Special) Client Contexts Components via the children prop within Server Components Modules.",
   [USE_CLIENT_COMPONENTS]:
     /* valid */ "Lineal Client Components can create client boundaries within (Special) Client Contexts Components.",
   [USE_AGNOSTIC_COMPONENTS]:
-    /* valid */ "Lineal Agnostic Components can render safely on the client just like they can on the server.",
+    /* valid */ "Lineal Agnostic Components can render safely on the client just like they can on the server, such as is the case here in a Special Client Contexts Module.",
   [USE_SERVER_FUNCTIONS]:
-    /* valid */ "(Special) Server Functions are specifically triggered by Client Components.",
+    /* valid */ "(Special) Server Functions are specifically triggered by Client Components, such as is the case here in a Special Client Contexts Module.",
   [USE_CLIENT_CONTEXTS]:
     /* valid */ "(Special) Client Contexts Components can compose with one another.",
   [USE_AGNOSTIC_CONDITIONS]:
     /* valid */ "(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.",
+  module: "Special Client Contexts Module",
+  modulePeriod: "Special Client Contexts Module.",
+  kinds: "Special Client Contexts",
 });
 export const agnosticConditionsComments = Object.freeze({
   [USE_SERVER_LOGICS]:
-    /* invalid */ "Prime Server Logics cannot run on both the server and the client.",
+    /* invalid */ "Prime Server Logics cannot run on both the server and the client, such as would be the case here in a Special Agnostic Conditions Module.",
   [USE_CLIENT_LOGICS]:
-    /* invalid */ "Prime Client Logics cannot run on both the server and the client.",
+    /* invalid */ "Prime Client Logics cannot run on both the server and the client, such as would be the case here in a Special Agnostic Conditions Module.",
   [USE_AGNOSTIC_LOGICS]:
     /* valid */ "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]:
@@ -198,4 +222,7 @@ export const agnosticConditionsComments = Object.freeze({
     /* invalid */ "(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]:
     /* valid */ "(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.",
+  module: "Special Agnostic Conditions Module",
+  modulePeriod: "Special Agnostic Conditions Module.",
+  kinds: "Special Agnostic Conditions",
 });

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

@@ -140,123 +140,123 @@ const makeBlockedImportSuggestingUseAgnostic = (
 export const effectiveDirectives_blockedImports = Object.freeze({
   [USE_SERVER_LOGICS]: Object.freeze([
-    // 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
+    // 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.)
     makeBlockedImport(
       USE_SERVER_LOGICS,
       USE_CLIENT_LOGICS
-    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_LOGICS#USE_CLIENT_LOGICS */,
+    ) /* Client Logics should never leak to the server, such as would be the case here in a Server Logics Module. */,
     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
+    ) /* 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, such as is the case here in a Server Logics Module.
+    // 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_COMPONENTS]: Object.freeze([
-    // 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
+    // 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.
     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
+    ) /* Client Logics should never leak to the server, such as would be the case here in a Server Components Module. */,
+    // 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, such as is the case here in a Server Components Module.
+    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can render safely on the server just like they can on the client.
   ]),
   [USE_SERVER_FUNCTIONS]: Object.freeze([
-    // USE_SERVER_LOGICS allowed, because $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_SERVER_LOGICS
+    // USE_SERVER_LOGICS allowed, because Server Logics, being logic from the server, can safely support Server Functions.
     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
+    ) /* 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.)
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_CLIENT_LOGICS
-    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_CLIENT_LOGICS */,
+    ) /* Client Logics should never leak to the server, such as would be the case here in a Server Functions Module. */,
     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
+    ) /* 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, such as is the case here in a Server Functions Module.
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_AGNOSTIC_COMPONENTS
-    ) /* $COMMENT#AGNOSTIC20#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_COMPONENTS */,
+    ) /* Agnostic Components aren't allowed because Server Functions have no business working with React Components. */,
   ]),
   [USE_CLIENT_LOGICS]: Object.freeze([
     makeBlockedImportSuggestingUseAgnostic(
       USE_CLIENT_LOGICS,
       USE_SERVER_LOGICS
-    ) /* $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_SERVER_LOGICS */,
+    ) /* Server Logics should never leak to the client, such as would be the case here in a Client Logics Module. */,
     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
+    ) /* Server Components cannot be thinkered with on the client. */,
+    // 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, such as is the case here in a Client Logics Module.
+    // 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.
   ]),
   [USE_CLIENT_COMPONENTS]: Object.freeze([
     makeBlockedImportSuggestingUseAgnostic(
       USE_CLIENT_LOGICS,
       USE_SERVER_LOGICS
-    ) /* $COMMENT#AGNOSTIC20#USE_CLIENT_LOGICS#USE_SERVER_LOGICS */,
+    ) /* Server Logics should never leak to the client, such as would be the case here in a Client Logics Module. */,
     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
+    ) /* Server Components cannot be thinkered with on the client. */,
+    // 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, such as is the case here in a Client Components Module.
+    // USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can render safely on the client just like they can on the server.
   ]),
   [USE_AGNOSTIC_LOGICS]: Object.freeze([
     makeBlockedImportSuggestingUseAgnostic(
       USE_AGNOSTIC_LOGICS,
       USE_SERVER_LOGICS
-    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_SERVER_LOGICS */,
+    ) /* Server Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Logics Module. */,
     makeBlockedImportSuggestingUseAgnostic(
       USE_AGNOSTIC_LOGICS,
       USE_SERVER_COMPONENTS
-    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_SERVER_COMPONENTS */,
+    ) /* Server Components cannot be tinkered with on both the server and the client. */,
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_SERVER_FUNCTIONS
-    ) /* $COMMENT#AGNOSTIC20#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. */,
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_CLIENT_LOGICS
-    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_LOGICS#USE_CLIENT_LOGICS */,
+    ) /* Client Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Logics Module. */,
     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
+    ) /* 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]: Object.freeze([
     makeBlockedImportSuggestingUseAgnostic(
       USE_AGNOSTIC_COMPONENTS,
       USE_SERVER_LOGICS
-    ) /* $COMMENT#AGNOSTIC20#USE_AGNOSTIC_COMPONENTS#USE_SERVER_LOGICS */,
+    ) /* Server Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Components Module. */,
     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
+    ) /* 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. */,
+    // 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.
     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
+    ) /* Client Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Components Module. */,
+    // 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.
   ]),
 });

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

@@ -29,8 +29,8 @@ import {
 /**
  * Gets the directive of a module from its Abstract Syntax Tree.
  * - `null` denotes a server-by-default module, ideally a Server Module.
- * - `'use client'` denotes a Client Module.
  * - `'use server'` denotes a Server Functions Module.
+ * - `'use client'` denotes a Client Module.
  * - `'use agnostic'` denotes an Agnostic Module (formerly Shared Module).
  * @param {AST} ast The module's AST (Abstract Syntax Tree).
  * @returns The directive, or lack thereof via `null`. The lack of a directive is considered server-by-default.
@@ -64,8 +64,8 @@ export const getDirectiveFromModule = (ast) => {
 /**
  * Gets the directive of the current module.
  * - `null` denotes a server-by-default module, ideally a Server Module.
- * - `'use client'` denotes a Client Module.
  * - `'use server'` denotes a Server Functions Module.
+ * - `'use client'` denotes a Client Module.
  * - `'use agnostic'` denotes an Agnostic Module (formerly Shared Module).
  * @param {Context} context The ESLint rule's `context` object.
  * @returns The directive, or lack thereof via `null`. The lack of a directive is considered server-by-default.
@@ -81,10 +81,10 @@ export const getDirectiveFromCurrentModule = (context) => {
 /**
  * Gets the directive of the imported module.
- * - `'use client'` denotes a Client Module.
+ * - `null` denotes a server-by-default module, ideally a Server Module.
  * - `'use server'` denotes a Server Functions Module.
+ * - `'use client'` denotes a Client Module.
  * - `'use agnostic'` denotes an Agnostic Module (formerly Shared Module).
- * - `null` denotes a server-by-default module, ideally a Server Module.
  * @param {string} resolvedPath The resolved path of the imported module.
  * @returns The directive, or lack thereof via `null`. The lack of a directive is considered server-by-default.
  */

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

@@ -169,189 +169,189 @@ export const makeBlockedImport = (
 export const commentedDirectives_blockedImports = Object.freeze({
   [USE_SERVER_LOGICS]: Object.freeze([
-    // USE_SERVER_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_SERVER_LOGICS
+    // USE_SERVER_LOGICS allowed, because Prime Server Logics can compose with one another.
     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
+    ) /* Prime Client Logics should never leak to the server, such as would be the case here in a Prime Server Logics Module. */,
+    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client, such as is the case here in a Prime Server Logics Module.
+    // 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.
     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
+    ) /* 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, such as Prime Server Logics, 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.)
     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
+    ) /* 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_CLIENT_LOGICS]: Object.freeze([
     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
+    ) /* Prime Server Logics should never leak to the client, such as would be the case here in a Prime Client Logics Module. */,
+    // 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, such as is the case here in a Prime Client Logics Module.
     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
+    ) /* 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, such as Prime Client Logics, 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.
   ]),
   [USE_AGNOSTIC_LOGICS]: Object.freeze([
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_SERVER_LOGICS
-    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_SERVER_LOGICS */,
+    ) /* Prime Server Logics cannot run on both the server and the client, such as would be the case here in a Prime Agnostic Logics Module. */,
     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
+    ) /* Prime Client Logics cannot run on both the server and the client, such as would be the case here in a Prime Agnostic Logics Module. */,
+    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can compose with one another.
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_SERVER_COMPONENTS
-    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_SERVER_COMPONENTS */,
+    ) /* Lineal Server Components cannot be tinkered with on both the server and the client. */,
     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
+    ) /* 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, such as Prime Agnostic Logics, as long as the Prime Environment Logics Module, by convention, does not export React components.
     makeBlockedImport(
       USE_AGNOSTIC_LOGICS,
       USE_SERVER_FUNCTIONS
-    ) /* $COMMENT#DIRECTIVE21#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. */,
     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
+    ) /* (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.
   ]),
   [USE_SERVER_COMPONENTS]: Object.freeze([
-    // USE_SERVER_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_SERVER_LOGICS
+    // USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support Lineal Server Components.
     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
+    ) /* Prime Client Logics should never leak to the server, such as would be the case here in a Lineal Server Components Module. */,
+    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client, such as is the case here in a Lineal Server Components Module.
+    // 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_CLIENT_COMPONENTS]: Object.freeze([
     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
+    ) /* Prime Server Logics should never leak to the client, such as would be the case here in a Lineal Client Components Module. */,
+    // 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, such as is the case here in a Lineal Client Components Module.
     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
+    ) /* 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, such as is the case here in a Lineal Client Components Module.
+    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions are specifically triggered by Client Components, such as is the case here in a Lineal Client Components Module.
+    // 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.
   ]),
   [USE_AGNOSTIC_COMPONENTS]: Object.freeze([
     makeBlockedImport(
       USE_AGNOSTIC_COMPONENTS,
       USE_SERVER_LOGICS
-    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_SERVER_LOGICS */,
+    ) /* Prime Server Logics cannot run on both the server and the client, such as would be the case here in a Lineal Agnostic Components Module. */,
     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
+    ) /* Prime Client Logics cannot run on both the server and the client, such as would be the case here in a Lineal Agnostic Components Module. */,
+    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics, being environment-agnostic logic, can safely support Agnostic Components.
     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
+    ) /* 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.
   ]),
   [USE_SERVER_FUNCTIONS]: Object.freeze([
-    // USE_SERVER_LOGICS allowed, because $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_SERVER_LOGICS
+    // USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support (Special) Server Functions.
     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
+    ) /* Prime Client Logics should never leak to the server, such as would be the case here in a Special Server Functions Module. */,
+    // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client, such as is the case here in a Special Server Functions Module.
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_SERVER_COMPONENTS
-    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_SERVER_COMPONENTS */,
+    ) /* Lineal Server Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_CLIENT_COMPONENTS
-    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_CLIENT_COMPONENTS */,
+    ) /* Lineal Client Components aren't allowed because (Special) Server Functions have no business working with React 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
+    ) /* 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.)
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_CLIENT_CONTEXTS
-    ) /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_CLIENT_CONTEXTS */,
+    ) /* (Special) Client Contexts Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
     makeBlockedImport(
       USE_SERVER_FUNCTIONS,
       USE_AGNOSTIC_CONDITIONS
-    ) /* $COMMENT#DIRECTIVE21#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_CLIENT_CONTEXTS]: Object.freeze([
     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
+    ) /* Prime Server Logics should never leak to the client, such as would be the case here in a Special Client Contexts Module. */,
+    // 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, such as is the case here in a Special Client Contexts Module.
     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
+    ) /* 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, such as is the case here in a Special Client Contexts Module.
+    // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions are specifically triggered by Client Components, such as is the case here in a Special Client Contexts Module.
+    // 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.
   ]),
   [USE_AGNOSTIC_CONDITIONS]: Object.freeze([
     makeBlockedImport(
       USE_AGNOSTIC_CONDITIONS,
       USE_SERVER_LOGICS
-    ) /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_LOGICS */,
+    ) /* Prime Server Logics cannot run on both the server and the client, such as would be the case here in a Special Agnostic Conditions Module. */,
     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
+    ) /* Prime Client Logics cannot run on both the server and the client, such as would be the case here in a Special Agnostic Conditions Module. */,
+    // 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.
     makeBlockedImport(
       USE_AGNOSTIC_CONDITIONS,
       USE_SERVER_FUNCTIONS
-    ) /* $COMMENT#DIRECTIVE21#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. */,
     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
+    ) /* (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.
   ]),
 });

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

@@ -78,7 +78,6 @@ const stripDoubleQuotes = (string) => {
  * - `'use server components'`, `"use server components"` denoting a Server Components Module.
  * - `'use client components'`, `"use client components"` denoting a Client Components Module.
  * - `'use agnostic components'`, `"use agnostic components"` denoting an Agnostic Components Module.
- * - `'use agnostic logics'`, `"use agnostic logics"` denoting an Agnostic Logics Module.
  * - `'use server functions'`, `"use server functions"` denoting a Server Functions Module.
  * - `'use client contexts'`, `"use client contexts"` denoting a Client Contexts Module.
  * - `'use agnostic conditions'`, `"use agnostic conditions"` denoting an Agnostic Conditions Module.
@@ -137,7 +136,6 @@ export const getCommentedDirectiveFromSourceCode = (sourceCode) => {
  * - `'use server components'`, `"use server components"` denoting a Server Components Module.
  * - `'use client components'`, `"use client components"` denoting a Client Components Module.
  * - `'use agnostic components'`, `"use agnostic components"` denoting an Agnostic Components Module.
- * - `'use agnostic logics'`, `"use agnostic logics"` denoting an Agnostic Logics Module.
  * - `'use server functions'`, `"use server functions"` denoting a Server Functions Module.
  * - `'use client contexts'`, `"use client contexts"` denoting a Client Contexts Module.
  * - `'use agnostic conditions'`, `"use agnostic conditions"` denoting an Agnostic Conditions Module.
@@ -164,7 +162,6 @@ export const getCommentedDirectiveFromCurrentModule = (context) => {
  * - `'use server components'`, `"use server components"` denoting a Server Components Module.
  * - `'use client components'`, `"use client components"` denoting a Client Components Module.
  * - `'use agnostic components'`, `"use agnostic components"` denoting an Agnostic Components Module.
- * - `'use agnostic logics'`, `"use agnostic logics"` denoting an Agnostic Logics Module.
  * - `'use server functions'`, `"use server functions"` denoting a Server Functions Module.
  * - `'use client contexts'`, `"use client contexts"` denoting a Client Contexts Module.
  * - `'use agnostic conditions'`, `"use agnostic conditions"` denoting an Agnostic Conditions Module.

package/package.json CHANGED Viewed

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