eslint-plugin-use-agnostic 1.7.9 → 1.8.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 (10) hide show
  1. package/comments.config.json +108 -16
  2. package/comments.config.mjs +109 -17
  3. package/jscomments/directive21/modules-comments.js +62 -16
  4. package/library/_commons/constants/bases.js +4 -4
  5. package/library/_commons/utilities/helpers.js +11 -11
  6. package/library/directive21/_commons/constants/bases.js +128 -60
  7. package/library/directive21/_commons/rules/import-rules.js +6 -6
  8. package/library/directive21/_commons/utilities/flows.js +55 -53
  9. package/library/directive21/_commons/utilities/helpers.js +19 -14
  10. package/package.json +1 -1
package/jscomments/directive21/modules-comments.js CHANGED
@@ -16,7 +16,9 @@ export const serverLogicsComments = Object.freeze({
16
16
  "use client contexts":
17
17
  /* invalid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#LIKEANYCLIENTCOMPONENTSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANTTINKEREDSERVER" /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_CLIENT_CONTEXTS */,
18
18
  "use agnostic conditions":
19
- /* 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." /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_AGNOSTIC_CONDITIONS */,
19
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDONLYINCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_AGNOSTIC_CONDITIONS */,
20
+ "use agnostic strategies":
21
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#USE_AGNOSTIC_STRATEGIES */,
20
22
  kinds:
21
23
  "Prime Server Logics" /* $COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#KINDS */,
22
24
  kindsComma:
@@ -53,15 +55,17 @@ export const clientLogicsComments = Object.freeze({
53
55
  "use server components":
54
56
  /* invalid */ "$COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANTTINKEREDCLIENT" /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_SERVER_COMPONENTS */,
55
57
  "use client components":
56
- /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#KINDSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#LIKEANYCLIENTCOMPONENTSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#OKCLIENTLOGICS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#NOEXPORTCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_CLIENT_COMPONENTS */,
58
+ /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#KINDSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#LIKEANYCLIENTCOMPONENTSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#OKCLIENTLOGICS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#NOEXPORTCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_CLIENT_COMPONENTS */,
57
59
  "use agnostic components":
58
60
  /* valid */ "DIRECTIVE21#FORALIASVARIABLES#AGNOSTICCOMPONENTSCANANY" /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_AGNOSTIC_COMPONENTS */,
59
61
  "use server functions":
60
- /* valid */ "(Special) Server Functions can technically be attached to any Client Components that are being tinkered with within Client Logics Modules." /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_SERVER_FUNCTIONS */,
62
+ /* valid */ "(Special) Server Functions can technically be attached to any Client Components being tinkered with within Client Logics Modules." /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_SERVER_FUNCTIONS */,
61
63
  "use client contexts":
62
64
  /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#LIKEANYCLIENTCOMPONENTSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#OKCLIENTLOGICS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#NOEXPORTCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_CLIENT_CONTEXTS */,
63
65
  "use agnostic conditions":
64
- /* 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." /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_AGNOSTIC_CONDITIONS */,
66
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDONLYINCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_AGNOSTIC_CONDITIONS */,
67
+ "use agnostic strategies":
68
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#USE_AGNOSTIC_STRATEGIES */,
65
69
  kinds:
66
70
  "Prime Client Logics" /* $COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#KINDS */,
67
71
  kindsComma:
@@ -106,7 +110,9 @@ export const agnosticLogicsComments = Object.freeze({
106
110
  "use client contexts":
107
111
  /* invalid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#LIKEANYCLIENTCOMPONENTSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANTTINKEREDBOTH" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_CLIENT_CONTEXTS */,
108
112
  "use agnostic conditions":
109
- /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ASIFLINEALAGNOSTIC $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANANYPRIMELOGICS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#NOEXPORTCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_CONDITIONS */,
113
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDENVIRONMENT" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_CONDITIONS */,
114
+ "use agnostic strategies":
115
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#USE_AGNOSTIC_STRATEGIES */,
110
116
  kinds:
111
117
  "Prime Agnostic Logics" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#KINDS */,
112
118
  kindsComma:
@@ -152,6 +158,8 @@ export const serverComponentsComments = Object.freeze({
152
158
  /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANBENESTEDINSIDE $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#TOWRAPTREE $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#WHENROOTONSERVER" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_CLIENT_CONTEXTS */,
153
159
  "use agnostic conditions":
154
160
  /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ASIFLINEALAGNOSTIC $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERSERVERLIKECLIENT" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_CONDITIONS */,
161
+ "use agnostic strategies":
162
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#USE_AGNOSTIC_STRATEGIES */,
155
163
  kinds:
156
164
  "Lineal Server Components" /* $COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#KINDS */,
157
165
  kindsComma:
@@ -197,6 +205,8 @@ export const clientComponentsComments = Object.freeze({
197
205
  /* 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 grandchildren of an ancestor Lineal Client Component, enforcing them to render exclusively on the client." /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_CLIENT_CONTEXTS */,
198
206
  "use agnostic conditions":
199
207
  /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#SPECIALSCOMMA $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ASIFLINEALAGNOSTIC $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#RENDERCLIENTLIKESERVER" /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_CONDITIONS */,
208
+ "use agnostic strategies":
209
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_STRATEGIES */,
200
210
  kinds:
201
211
  "Lineal Client Components" /* $COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#KINDS */,
202
212
  kindsComma:
@@ -243,7 +253,9 @@ export const agnosticComponentsComments = Object.freeze({
243
253
  "use client contexts":
244
254
  /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANBENESTEDINSIDE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#TOWRAPTREE $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#IFSTILLONSERVERTREE $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#WHENROOTONSERVER" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_CLIENT_CONTEXTS */,
245
255
  "use agnostic conditions":
246
- /* 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 Lineal Server Components to be nested in any Agnostic Components." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_CONDITIONS */,
256
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDENVIRONMENT" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_CONDITIONS */,
257
+ "use agnostic strategies":
258
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#USE_AGNOSTIC_STRATEGIES */,
247
259
  kinds:
248
260
  "Lineal Agnostic Components" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#KINDS */,
249
261
  kindsComma:
@@ -289,6 +301,8 @@ export const serverFunctionsComments = Object.freeze({
289
301
  /* invalid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ARENTALLOWED $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERFUNCTIONSNOCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_CLIENT_CONTEXTS */,
290
302
  "use agnostic conditions":
291
303
  /* invalid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ARENTALLOWED $COMMENT#DIRECTIVE21#FORALIASVARIABLES#SERVERFUNCTIONSNOCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_CONDITIONS */,
304
+ "use agnostic strategies":
305
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#USE_AGNOSTIC_STRATEGIES */,
292
306
  kinds:
293
307
  "Special Server Functions" /* $COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#KINDS */,
294
308
  kindsComma:
@@ -339,7 +353,9 @@ export const clientContextsComments = Object.freeze({
339
353
  "use client contexts":
340
354
  /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#CANCOMPOSEONEANOTHER" /* $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_CLIENT_CONTEXTS */,
341
355
  "use agnostic conditions":
342
- /* 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 Client Contexts Components to safely and indirectly compose with child Server Components within Client Contexts Modules." /* $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_AGNOSTIC_CONDITIONS */,
356
+ /* valid */ "DIRECTIVE21#USE_CLIENT_COMPONENTS#USE_AGNOSTIC_CONDITIONS" /* $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_AGNOSTIC_CONDITIONS */,
357
+ "use agnostic strategies":
358
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#USE_AGNOSTIC_STRATEGIES */,
343
359
  kinds:
344
360
  "Special Client Contexts" /* $COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#KINDS */,
345
361
  kindsComma:
@@ -374,23 +390,31 @@ export const clientContextsComments = Object.freeze({
374
390
 
375
391
  export const agnosticConditionsComments = Object.freeze({
376
392
  "use server logics":
377
- /* invalid */ "DIRECTIVE21#FORALIASVARIABLES#SERVERLOGICSCANTBOTH" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_LOGICS */,
393
+ /* invalid */ "$COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ARENTALLOWED $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDONLYFROMCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_LOGICS */,
378
394
  "use client logics":
379
- /* invalid */ "DIRECTIVE21#FORALIASVARIABLES#CLIENTLOGICSCANTBOTH" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_LOGICS */,
395
+ /* invalid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ARENTALLOWED $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDONLYFROMCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_LOGICS */,
380
396
  "use agnostic logics":
381
- /* valid */ "Prime Agnostic Logics, being environment-agnostic logic, can safely support any 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.)" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_LOGICS */,
397
+ /* invalid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ARENTALLOWED $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDONLYFROMCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_LOGICS */,
382
398
  "use server components":
383
- /* valid */ "Lineal Server Components are to be paired as `ComponentForServer` components with `ComponentForClient` components to form (Special) Agnostic Conditions Components." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_COMPONENTS */,
399
+ /* valid */ "Lineal Server Components are to be paired as `ComponentForServer` components with `ComponentForClient` components to form (Special) Agnostic Conditions Components. The `ComponentForServer` is always the first assigned." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_COMPONENTS */,
384
400
  "use client components":
385
- /* valid */ "Lineal Client Components are to be paired as `ComponentForClient` components with `ComponentForServer` components to form (Special) Agnostic Conditions Components." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_COMPONENTS */,
401
+ /* valid */ "Lineal Client Components are to be paired as `ComponentForClient` components with `ComponentForServer` components to form (Special) Agnostic Conditions Components. The `ComponentForClient` is always the last assigned." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_COMPONENTS */,
386
402
  "use agnostic components":
387
403
  /* valid */ "Lineal Agnostic Components can take the place of `ComponentForServer` and/or `ComponentForClient` components to form (Special) Agnostic Conditions Components." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_COMPONENTS */,
388
404
  "use server functions":
389
- /* invalid */ "(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." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_FUNCTIONS */,
405
+ /* invalid */ "$COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ARENTALLOWED $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDONLYFROMCOMPONENTS" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_SERVER_FUNCTIONS */,
390
406
  "use client contexts":
391
- /* 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." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_CONTEXTS */,
407
+ /* valid */ "(Special) Client Contexts Components can actually be used as `ComponentForClient` arguments for (Special) Agnostic Conditions Components notably as counterparts to similar passthrough components selected as `ComponentForServer` arguments." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_CLIENT_CONTEXTS */,
392
408
  "use agnostic conditions":
393
- /* 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." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_CONDITIONS */,
409
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDENVIRONMENT" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_CONDITIONS */,
410
+ "use agnostic strategies":
411
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#USE_AGNOSTIC_STRATEGIES */,
412
+ invalidEnvironment:
413
+ "(Special) Agnostic Conditions Modules cannot be imported in the (Abstract) Agnostic Environment, only strictly on the server or strictly on the client." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDENVIRONMENT */,
414
+ invalidOnlyInComponents:
415
+ "(Special) Agnostic Conditions Modules can only be imported by Components Modules, given how the consuming of their conditioned mechanism is restricted to React Components." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDONLYINCOMPONENTS */,
416
+ invalidOnlyFromComponents:
417
+ "(Special) Agnostic Conditions Modules can only import directly from Components Modules, given how the making of their conditioned mechanism is restricted to React Components." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDONLYFROMCOMPONENTS */,
394
418
  kinds:
395
419
  "Special Agnostic Conditions" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#KINDS */,
396
420
  kindsComma:
@@ -424,8 +448,30 @@ export const agnosticConditionsComments = Object.freeze({
424
448
  });
425
449
 
426
450
  export const agnosticStrategiesComments = Object.freeze({
451
+ "use server logics":
452
+ /* valid */ "$COMMENT#DIRECTIVE21#USE_SERVER_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_SERVER_LOGICS */,
453
+ "use client logics":
454
+ /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_CLIENT_LOGICS */,
455
+ "use agnostic logics":
456
+ /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_LOGICS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_AGNOSTIC_LOGICS */,
457
+ "use server components":
458
+ /* valid */ "$COMMENT#DIRECTIVE21#USE_SERVER_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_SERVER_COMPONENTS */,
459
+ "use client components":
460
+ /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_CLIENT_COMPONENTS */,
461
+ "use agnostic components":
462
+ /* valid */ "$COMMENT#DIRECTIVE21#USE_AGNOSTIC_COMPONENTS#KINDS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_AGNOSTIC_COMPONENTS */,
463
+ "use server functions":
464
+ /* valid */ "$COMMENT#DIRECTIVE21#USE_SERVER_FUNCTIONS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_SERVER_FUNCTIONS */,
465
+ "use client contexts":
466
+ /* valid */ "$COMMENT#DIRECTIVE21#USE_CLIENT_CONTEXTS#SPECIALS $COMMENT#DIRECTIVE21#FORCOMPOSEDVARIABLES#ALLOWEDBECAUSE $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_CLIENT_CONTEXTS */,
467
+ "use agnostic conditions":
468
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_CONDITIONS#INVALIDENVIRONMENT" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_AGNOSTIC_CONDITIONS */,
469
+ "use agnostic strategies":
470
+ /* invalid */ "DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#USE_AGNOSTIC_STRATEGIES */,
427
471
  valid:
428
- "(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.)" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID */,
472
+ "(Special) Agnostic Strategies Modules can import all known modules except Special Agnostic Modules, meaning themselves as file generators that should not be imported directly and (Special) Agnostic Conditions Modules which cannot be imported in the (Abstract) Agnostic Environment." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#VALID */,
473
+ invalid:
474
+ "(Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead." /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#INVALID */,
429
475
  kinds:
430
476
  "Special Agnostic Strategies" /* $COMMENT#DIRECTIVE21#USE_AGNOSTIC_STRATEGIES#KINDS */,
431
477
  kindsComma:
package/library/_commons/constants/bases.js CHANGED
@@ -48,10 +48,10 @@ export const commentedDirectiveVerificationFailedMessageId =
48
48
  "commented-directive-verification-failed";
49
49
  export const commentedDirectiveReactDirectiveFailedMessageId =
50
50
  "commented-directive-correct-react-directive-failed";
51
- export const importNotStrategizedMessageId =
52
- "import-from-use-agnostic-strategies-not-strategized";
53
- export const exportNotStrategizedMessageId =
54
- "export-from-use-agnostic-strategies-not-strategized";
51
+ // export const importNotStrategizedMessageId =
52
+ // "import-from-use-agnostic-strategies-not-strategized";
53
+ // export const exportNotStrategizedMessageId =
54
+ // "export-from-use-agnostic-strategies-not-strategized";
55
55
  export const cantChainImportAcrossEnvironmentsMessageId =
56
56
  "cant-chain-import-across-environments";
57
57
 
package/library/_commons/utilities/helpers.js CHANGED
@@ -5,12 +5,12 @@ import {
5
5
 
6
6
  /**
7
7
  * @typedef {import('../../../types/_commons/typedefs').Context<string, readonly unknown[]>} Context
8
- * @typedef {import('../../../types/_commons/typedefs').ResolvedDirectiveWithoutUseAgnosticStrategies} ResolvedDirectiveWithoutUseAgnosticStrategies
8
+ * @typedef {import('../../../types/_commons/typedefs').ResolvedDirective} ResolvedDirective
9
9
  */
10
10
 
11
11
  /**
12
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} T
13
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} U
12
+ * @template {ResolvedDirective} T
13
+ * @template {ResolvedDirective} U
14
14
  * @typedef {import('../../../types/_commons/typedefs').ResolvedDirectives_BlockedImports<T, U>} ResolvedDirectives_BlockedImports
15
15
  */
16
16
 
@@ -30,8 +30,8 @@ export const highlightFirstLineOfCode = (context) => ({
30
30
 
31
31
  /**
32
32
  * Returns a boolean deciding if an imported file's "resolved" directive is incompatible with the current file's "resolved" directive.
33
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} T
34
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} U
33
+ * @template {ResolvedDirective} T
34
+ * @template {ResolvedDirective} U
35
35
  * @param {ResolvedDirectives_BlockedImports<T, U>} resolvedDirectives_blockedImports The blocked imports object, either for agnostic20 or for directive21.
36
36
  * @param {T} currentFileResolvedDirective The current file's "resolved" directive.
37
37
  * @param {U} importedFileResolvedDirective The imported file's "resolved" directive.
@@ -51,8 +51,8 @@ export const isImportBlocked = (
51
51
 
52
52
  /**
53
53
  * Makes the intro for each specific import rule violation messages.
54
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} T
55
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} U
54
+ * @template {ResolvedDirective} T
55
+ * @template {ResolvedDirective} U
56
56
  * @param {T} currentFileResolvedDirective The current file's "resolved" directive.
57
57
  * @param {U} importedFileResolvedDirective The imported file's "resolved" directive.
58
58
  * @returns "[Current file 'resolved' modules] are not allowed to import [imported file 'resolved' modules]."
@@ -71,8 +71,8 @@ export const makeIntroForSpecificViolationMessage = (
71
71
 
72
72
  /**
73
73
  * Lists in an message the "resolved" modules incompatible with a "resolved" module based on its "resolved" directive.
74
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} T
75
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} U
74
+ * @template {ResolvedDirective} T
75
+ * @template {ResolvedDirective} U
76
76
  * @param {ResolvedDirectives_BlockedImports<T, U>} resolvedDirectives_blockedImports The blocked imports object, either for agnostic20 or for directive21.
77
77
  * @param {T} currentFileResolvedDirective The "resolved" directive of the "resolved" module.
78
78
  * @returns The message listing the incompatible "resolved" modules.
@@ -112,8 +112,8 @@ export const makeMessageFromCurrentFileResolvedDirective = (
112
112
 
113
113
  /**
114
114
  * Finds the `message` for the specific violation of "resolved" directives import rules based on `resolvedDirectives_blockedImports`.
115
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} T
116
- * @template {ResolvedDirectiveWithoutUseAgnosticStrategies} U
115
+ * @template {ResolvedDirective} T
116
+ * @template {ResolvedDirective} U
117
117
  * @param {ResolvedDirectives_BlockedImports<T, U>} resolvedDirectives_blockedImports The blocked imports object, either for agnostic20 or for directive21.
118
118
  * @param {T} currentFileResolvedDirective The current file's "resolved" directive.
119
119
  * @param {U} importedFileResolvedDirective The imported file's "resolved" directive.
package/library/directive21/_commons/constants/bases.js CHANGED
@@ -157,7 +157,6 @@ export const commentedDirectives_verificationReports = Object.freeze({
157
157
  [USE_SERVER_FUNCTIONS]: `${MODULES_MARKED_WITH_THE_} "${USE_SERVER_FUNCTIONS}" ${_DIRECTIVE_MUST_HAVE_A_NON_JSX_FILE_EXTENSION}.`,
158
158
  [USE_CLIENT_CONTEXTS]: `${MODULES_MARKED_WITH_THE_} "${USE_CLIENT_CONTEXTS}" ${_DIRECTIVE_MUST_HAVE_A_JSX_FILE_EXTENSION}.`,
159
159
  [USE_AGNOSTIC_CONDITIONS]: `${MODULES_MARKED_WITH_THE_} "${USE_AGNOSTIC_CONDITIONS}" ${_DIRECTIVE_MUST_HAVE_A_JSX_FILE_EXTENSION}.`,
160
- // [USE_AGNOSTIC_STRATEGIES]: `${MODULES_MARKED_WITH_THE_} "${USE_AGNOSTIC_STRATEGIES}" directive are free to have the file extension of their choosing. (This is not a problem and should never surface.)`,
161
160
  [USE_AGNOSTIC_STRATEGIES]: `${MODULES_MARKED_WITH_THE_} "${USE_AGNOSTIC_STRATEGIES}" ${_DIRECTIVE_MUST_HAVE_A_JSX_FILE_EXTENSION}.`,
162
161
  });
163
162
 
@@ -165,8 +164,8 @@ export const commentedDirectives_verificationReports = Object.freeze({
165
164
 
166
165
  /**
167
166
  * Makes a blockedImport object for the identified blocked import at hand.
168
- * @template {CommentedDirectiveWithoutUseAgnosticStrategies} T
169
- * @template {CommentedDirectiveWithoutUseAgnosticStrategies} U
167
+ * @template {CommentedDirective} T
168
+ * @template {CommentedDirective} U
170
169
  * @param {T} currentFileCommentedDirective The current file's commented directive.
171
170
  * @param {U} importedFileCommentedDirective The imported file's commented directive.
172
171
  * @returns The blockedImport object for the identified blocked import at hand.
@@ -190,41 +189,55 @@ export const makeBlockedImport = (
190
189
 
191
190
  export const commentedDirectives_blockedImports = Object.freeze({
192
191
  [USE_SERVER_LOGICS]: Object.freeze([
193
- // USE_SERVER_LOGICS allowed, because Prime Server Logics can compose with one another.
192
+ // USE_SERVER_LOGICS Prime Server Logics can compose with one another.
194
193
  makeBlockedImport(
195
194
  USE_SERVER_LOGICS,
196
195
  USE_CLIENT_LOGICS
197
196
  ) /* Prime Client Logics should never leak to the server. */,
198
- // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client.
199
- // 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.
197
+ // USE_AGNOSTIC_LOGICS Prime Agnostic Logics can run safely on the server just like they can on the client.
198
+ // USE_SERVER_COMPONENTS 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.
200
199
  makeBlockedImport(
201
200
  USE_SERVER_LOGICS,
202
201
  USE_CLIENT_COMPONENTS
203
202
  ) /* Lineal Client Components, like any Client Components, cannot be tinkered with on the server. */,
204
- // 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.
205
- // 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.)
203
+ // USE_AGNOSTIC_COMPONENTS 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.
204
+ // USE_SERVER_FUNCTIONS (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.)
206
205
  makeBlockedImport(
207
206
  USE_SERVER_LOGICS,
208
207
  USE_CLIENT_CONTEXTS
209
208
  ) /* (Special) Client Contexts Components, like any Client Components, cannot be tinkered with on the server. */,
210
- // 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.
209
+ makeBlockedImport(
210
+ USE_SERVER_LOGICS,
211
+ USE_AGNOSTIC_CONDITIONS
212
+ ) /* (Special) Agnostic Conditions Modules can only be imported by Components Modules, given how the consuming of their conditioned mechanism is restricted to React Components. */,
213
+ makeBlockedImport(
214
+ USE_SERVER_LOGICS,
215
+ USE_AGNOSTIC_STRATEGIES
216
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
211
217
  ]),
212
218
  [USE_CLIENT_LOGICS]: Object.freeze([
213
219
  makeBlockedImport(
214
220
  USE_CLIENT_LOGICS,
215
221
  USE_SERVER_LOGICS
216
222
  ) /* Prime Server Logics should never leak to the client. */,
217
- // USE_CLIENT_LOGICS allowed, because Prime Client Logics can compose with one another.
218
- // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the client just like they can on the server.
223
+ // USE_CLIENT_LOGICS Prime Client Logics can compose with one another.
224
+ // USE_AGNOSTIC_LOGICS Prime Agnostic Logics can run safely on the client just like they can on the server.
219
225
  makeBlockedImport(
220
226
  USE_CLIENT_LOGICS,
221
227
  USE_SERVER_COMPONENTS
222
228
  ) /* Lineal Server Components cannot be tinkered with on the client. */,
223
- // USE_CLIENT_COMPONENTS allowed, because Prime Client Logics, 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.
224
- // 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.
225
- // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can technically be attached to any Client Components that are being tinkered with within Client Logics Modules.
226
- // 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.
227
- // 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.
229
+ // USE_CLIENT_COMPONENTS 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.
230
+ // USE_AGNOSTIC_COMPONENTS 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.
231
+ // USE_SERVER_FUNCTIONS (Special) Server Functions can technically be attached to any Client Components being tinkered with within Client Logics Modules.
232
+ // USE_CLIENT_CONTEXTS (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.
233
+ makeBlockedImport(
234
+ USE_CLIENT_LOGICS,
235
+ USE_AGNOSTIC_CONDITIONS
236
+ ) /* (Special) Agnostic Conditions Modules can only be imported by Components Modules, given how the consuming of their conditioned mechanism is restricted to React Components. */,
237
+ makeBlockedImport(
238
+ USE_CLIENT_LOGICS,
239
+ USE_AGNOSTIC_STRATEGIES
240
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
228
241
  ]),
229
242
  [USE_AGNOSTIC_LOGICS]: Object.freeze([
230
243
  makeBlockedImport(
@@ -235,7 +248,7 @@ export const commentedDirectives_blockedImports = Object.freeze({
235
248
  USE_AGNOSTIC_LOGICS,
236
249
  USE_CLIENT_LOGICS
237
250
  ) /* Prime Client Logics cannot run on both the server and the client. */,
238
- // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can compose with one another.
251
+ // USE_AGNOSTIC_LOGICS Prime Agnostic Logics can compose with one another.
239
252
  makeBlockedImport(
240
253
  USE_AGNOSTIC_LOGICS,
241
254
  USE_SERVER_COMPONENTS
@@ -244,7 +257,7 @@ export const commentedDirectives_blockedImports = Object.freeze({
244
257
  USE_AGNOSTIC_LOGICS,
245
258
  USE_CLIENT_COMPONENTS
246
259
  ) /* Lineal Client Components, like any Client Components, cannot be tinkered with on both the server and the client. */,
247
- // 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.
260
+ // USE_AGNOSTIC_COMPONENTS 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.
248
261
  makeBlockedImport(
249
262
  USE_AGNOSTIC_LOGICS,
250
263
  USE_SERVER_FUNCTIONS
@@ -253,38 +266,53 @@ export const commentedDirectives_blockedImports = Object.freeze({
253
266
  USE_AGNOSTIC_LOGICS,
254
267
  USE_CLIENT_CONTEXTS
255
268
  ) /* (Special) Client Contexts Components, like any Client Components, cannot be tinkered with on both the server and the client. */,
256
- // 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.
269
+ makeBlockedImport(
270
+ USE_AGNOSTIC_LOGICS,
271
+ USE_AGNOSTIC_CONDITIONS
272
+ ) /* (Special) Agnostic Conditions Modules cannot be imported in the (Abstract) Agnostic Environment, only strictly on the server or strictly on the client. */,
273
+ makeBlockedImport(
274
+ USE_AGNOSTIC_LOGICS,
275
+ USE_AGNOSTIC_STRATEGIES
276
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
257
277
  ]),
258
278
  [USE_SERVER_COMPONENTS]: Object.freeze([
259
- // USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support Lineal Server Components.
279
+ // USE_SERVER_LOGICS Prime Server Logics, being logic from the server, can safely support Lineal Server Components.
260
280
  makeBlockedImport(
261
281
  USE_SERVER_COMPONENTS,
262
282
  USE_CLIENT_LOGICS
263
283
  ) /* Prime Client Logics should never leak to the server. */,
264
- // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client.
265
- // 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.
266
- // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can be nested inside Lineal Server Components to create client boundaries when the root of the application is planted on the server.
267
- // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the server just like they can on the client.
268
- // 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.
269
- // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can be nested inside Lineal 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.
270
- // 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.
284
+ // USE_AGNOSTIC_LOGICS Prime Agnostic Logics can run safely on the server just like they can on the client.
285
+ // USE_SERVER_COMPONENTS Lineal Server Components can compose with one another, now that thanks to the inclusion of Agnostic Components they are actual Server Components.
286
+ // USE_CLIENT_COMPONENTS Lineal Client Components can be nested inside Lineal Server Components to create client boundaries when the root of the application is planted on the server.
287
+ // USE_AGNOSTIC_COMPONENTS Lineal Agnostic Components can render safely on the server just like they can on the client.
288
+ // USE_SERVER_FUNCTIONS (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.
289
+ // USE_CLIENT_CONTEXTS (Special) Client Contexts Components can be nested inside Lineal 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.
290
+ // USE_AGNOSTIC_CONDITIONS (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.
291
+ makeBlockedImport(
292
+ USE_SERVER_COMPONENTS,
293
+ USE_AGNOSTIC_STRATEGIES
294
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
271
295
  ]),
272
296
  [USE_CLIENT_COMPONENTS]: Object.freeze([
273
297
  makeBlockedImport(
274
298
  USE_CLIENT_COMPONENTS,
275
299
  USE_SERVER_LOGICS
276
300
  ) /* Prime Server Logics should never leak to the client. */,
277
- // USE_CLIENT_LOGICS allowed, because Prime Client Logics, being logic from the client, can safely support Lineal Client Components, like any Client Components.
278
- // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the client just like they can on the server.
301
+ // USE_CLIENT_LOGICS Prime Client Logics, being logic from the client, can safely support Lineal Client Components, like any Client Components.
302
+ // USE_AGNOSTIC_LOGICS Prime Agnostic Logics can run safely on the client just like they can on the server.
279
303
  makeBlockedImport(
280
304
  USE_CLIENT_COMPONENTS,
281
305
  USE_SERVER_COMPONENTS
282
306
  ) /* Lineal Server Components cannot be the children of Lineal Client Components. */,
283
- // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can compose with one another.
284
- // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the client just like they can on the server.
285
- // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can be specifically triggered by Client Components.
286
- // 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 grandchildren of an ancestor Lineal Client Component, enforcing them to render exclusively on the client.
287
- // 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.
307
+ // USE_CLIENT_COMPONENTS Lineal Client Components can compose with one another.
308
+ // USE_AGNOSTIC_COMPONENTS Lineal Agnostic Components can render safely on the client just like they can on the server.
309
+ // USE_SERVER_FUNCTIONS (Special) Server Functions can be specifically triggered by Client Components.
310
+ // USE_CLIENT_CONTEXTS (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 grandchildren of an ancestor Lineal Client Component, enforcing them to render exclusively on the client.
311
+ // USE_AGNOSTIC_CONDITIONS (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.
312
+ makeBlockedImport(
313
+ USE_CLIENT_COMPONENTS,
314
+ USE_AGNOSTIC_STRATEGIES
315
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
288
316
  ]),
289
317
  [USE_AGNOSTIC_COMPONENTS]: Object.freeze([
290
318
  makeBlockedImport(
@@ -295,24 +323,31 @@ export const commentedDirectives_blockedImports = Object.freeze({
295
323
  USE_AGNOSTIC_COMPONENTS,
296
324
  USE_CLIENT_LOGICS
297
325
  ) /* Prime Client Logics cannot run on both the server and the client. */,
298
- // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics, being environment-agnostic logic, can safely support any Agnostic Components.
326
+ // USE_AGNOSTIC_LOGICS Prime Agnostic Logics, being environment-agnostic logic, can safely support any Agnostic Components.
299
327
  makeBlockedImport(
300
328
  USE_AGNOSTIC_COMPONENTS,
301
329
  USE_SERVER_COMPONENTS
302
330
  ) /* 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. */,
303
- // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can be nested inside Lineal Agnostic Components to create client boundaries when the root of the application is planted on the server.
304
- // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can compose with one another.
305
- // 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.
306
- // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can be nested inside Lineal 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.
307
- // 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 Lineal Server Components to be nested in any Agnostic Components.
331
+ // USE_CLIENT_COMPONENTS Lineal Client Components can be nested inside Lineal Agnostic Components to create client boundaries when the root of the application is planted on the server.
332
+ // USE_AGNOSTIC_COMPONENTS Lineal Agnostic Components can compose with one another.
333
+ // USE_SERVER_FUNCTIONS (Special) Server Functions can be passed to Client Components as props when Client Components are also legally imported into Agnostic Components Modules.
334
+ // USE_CLIENT_CONTEXTS (Special) Client Contexts Components can be nested inside Lineal 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.
335
+ makeBlockedImport(
336
+ USE_AGNOSTIC_COMPONENTS,
337
+ USE_AGNOSTIC_CONDITIONS
338
+ ) /* (Special) Agnostic Conditions Modules cannot be imported in the (Abstract) Agnostic Environment, only strictly on the server or strictly on the client. */,
339
+ makeBlockedImport(
340
+ USE_AGNOSTIC_COMPONENTS,
341
+ USE_AGNOSTIC_STRATEGIES
342
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
308
343
  ]),
309
344
  [USE_SERVER_FUNCTIONS]: Object.freeze([
310
- // USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support (Special) Server Functions.
345
+ // USE_SERVER_LOGICS Prime Server Logics, being logic from the server, can safely support (Special) Server Functions.
311
346
  makeBlockedImport(
312
347
  USE_SERVER_FUNCTIONS,
313
348
  USE_CLIENT_LOGICS
314
349
  ) /* Prime Client Logics should never leak to the server. */,
315
- // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the server just like they can on the client.
350
+ // USE_AGNOSTIC_LOGICS Prime Agnostic Logics can run safely on the server just like they can on the client.
316
351
  makeBlockedImport(
317
352
  USE_SERVER_FUNCTIONS,
318
353
  USE_SERVER_COMPONENTS
@@ -325,7 +360,7 @@ export const commentedDirectives_blockedImports = Object.freeze({
325
360
  USE_SERVER_FUNCTIONS,
326
361
  USE_AGNOSTIC_COMPONENTS
327
362
  ) /* Lineal Agnostic Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
328
- // 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.)
363
+ // USE_SERVER_FUNCTIONS (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.)
329
364
  makeBlockedImport(
330
365
  USE_SERVER_FUNCTIONS,
331
366
  USE_CLIENT_CONTEXTS
@@ -334,46 +369,79 @@ export const commentedDirectives_blockedImports = Object.freeze({
334
369
  USE_SERVER_FUNCTIONS,
335
370
  USE_AGNOSTIC_CONDITIONS
336
371
  ) /* (Special) Agnostic Conditions Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
372
+ makeBlockedImport(
373
+ USE_SERVER_FUNCTIONS,
374
+ USE_AGNOSTIC_STRATEGIES
375
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
337
376
  ]),
338
377
  [USE_CLIENT_CONTEXTS]: Object.freeze([
339
378
  makeBlockedImport(
340
379
  USE_CLIENT_CONTEXTS,
341
380
  USE_SERVER_LOGICS
342
381
  ) /* Prime Server Logics should never leak to the client. */,
343
- // USE_CLIENT_LOGICS allowed, because Prime Client Logics, being logic from the client, can safely support (Special) Client Contexts Components, like any Client Components.
344
- // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can run safely on the client just like they can on the server.
382
+ // USE_CLIENT_LOGICS Prime Client Logics, being logic from the client, can safely support (Special) Client Contexts Components, like any Client Components.
383
+ // USE_AGNOSTIC_LOGICS Prime Agnostic Logics can run safely on the client just like they can on the server.
345
384
  makeBlockedImport(
346
385
  USE_CLIENT_CONTEXTS,
347
386
  USE_SERVER_COMPONENTS
348
387
  ) /* Lineal Server Components may only pass through (Special) Client Contexts Components via the children prop within Server Components Modules. */,
349
- // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can create client boundaries within (Special) Client Contexts Components.
350
- // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the client just like they can on the server.
351
- // USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can be specifically triggered by Client Components.
352
- // USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can compose with one another.
353
- // 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 Client Contexts Components to safely and indirectly compose with child Server Components within Client Contexts Modules.
388
+ // USE_CLIENT_COMPONENTS Lineal Client Components can create client boundaries within (Special) Client Contexts Components.
389
+ // USE_AGNOSTIC_COMPONENTS Lineal Agnostic Components can render safely on the client just like they can on the server.
390
+ // USE_SERVER_FUNCTIONS (Special) Server Functions can be specifically triggered by Client Components.
391
+ // USE_CLIENT_CONTEXTS (Special) Client Contexts Components can compose with one another.
392
+ // USE_AGNOSTIC_CONDITIONS (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.
393
+ makeBlockedImport(
394
+ USE_CLIENT_CONTEXTS,
395
+ USE_AGNOSTIC_STRATEGIES
396
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
354
397
  ]),
355
398
  [USE_AGNOSTIC_CONDITIONS]: Object.freeze([
356
399
  makeBlockedImport(
357
400
  USE_AGNOSTIC_CONDITIONS,
358
401
  USE_SERVER_LOGICS
359
- ) /* Prime Server Logics cannot run on both the server and the client. */,
402
+ ) /* Prime Server Logics aren't allowed because (Special) Agnostic Conditions Modules can only import directly from Components Modules, given how the making of their conditioned mechanism is restricted to React Components. */,
360
403
  makeBlockedImport(
361
404
  USE_AGNOSTIC_CONDITIONS,
362
405
  USE_CLIENT_LOGICS
363
- ) /* Prime Client Logics cannot run on both the server and the client. */,
364
- // USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics, being environment-agnostic logic, can safely support any 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.)
365
- // USE_SERVER_COMPONENTS allowed, because Lineal Server Components are to be paired as `ComponentForServer` components with `ComponentForClient` components to form (Special) Agnostic Conditions Components.
366
- // USE_CLIENT_COMPONENTS allowed, because Lineal Client Components are to be paired as `ComponentForClient` components with `ComponentForServer` components to form (Special) Agnostic Conditions Components.
367
- // USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can take the place of `ComponentForServer` and/or `ComponentForClient` components to form (Special) Agnostic Conditions Components.
406
+ ) /* Prime Client Logics aren't allowed because (Special) Agnostic Conditions Modules can only import directly from Components Modules, given how the making of their conditioned mechanism is restricted to React Components. */,
407
+ makeBlockedImport(
408
+ USE_AGNOSTIC_CONDITIONS,
409
+ USE_AGNOSTIC_LOGICS
410
+ ) /* Prime Agnostic Logics aren't allowed because (Special) Agnostic Conditions Modules can only import directly from Components Modules, given how the making of their conditioned mechanism is restricted to React Components. */,
411
+ // USE_SERVER_COMPONENTS Lineal Server Components are to be paired as `ComponentForServer` components with `ComponentForClient` components to form (Special) Agnostic Conditions Components. The `ComponentForServer` is always the first assigned.
412
+ // USE_CLIENT_COMPONENTS Lineal Client Components are to be paired as `ComponentForClient` components with `ComponentForServer` components to form (Special) Agnostic Conditions Components. The `ComponentForClient` is always the last assigned.
413
+ // USE_AGNOSTIC_COMPONENTS Lineal Agnostic Components can take the place of `ComponentForServer` and/or `ComponentForClient` components to form (Special) Agnostic Conditions Components.
368
414
  makeBlockedImport(
369
415
  USE_AGNOSTIC_CONDITIONS,
370
416
  USE_SERVER_FUNCTIONS
371
- ) /* (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. */,
417
+ ) /* (Special) Server Functions aren't allowed because (Special) Agnostic Conditions Modules can only import directly from Components Modules, given how the making of their conditioned mechanism is restricted to React Components. */,
418
+ // USE_CLIENT_CONTEXTS (Special) Client Contexts Components can actually be used as `ComponentForClient` arguments for (Special) Agnostic Conditions Components notably as counterparts to similar passthrough components selected as `ComponentForServer` arguments.
372
419
  makeBlockedImport(
373
420
  USE_AGNOSTIC_CONDITIONS,
374
- USE_CLIENT_CONTEXTS
375
- ) /* (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. */,
376
- // 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.
421
+ USE_AGNOSTIC_CONDITIONS
422
+ ) /* (Special) Agnostic Conditions Modules cannot be imported in the (Abstract) Agnostic Environment, only strictly on the server or strictly on the client. */,
423
+ makeBlockedImport(
424
+ USE_AGNOSTIC_CONDITIONS,
425
+ USE_AGNOSTIC_STRATEGIES
426
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
427
+ ]),
428
+ [USE_AGNOSTIC_STRATEGIES]: Object.freeze([
429
+ // USE_SERVER_LOGICS Prime Server Logics allowed, because (Special) Agnostic Strategies Modules can import all known modules except Special Agnostic Modules, meaning themselves as file generators that should not be imported directly and (Special) Agnostic Conditions Modules which cannot be imported in the (Abstract) Agnostic Environment.
430
+ // USE_CLIENT_LOGICS Prime Client Logics allowed, because (Special) Agnostic Strategies Modules can import all known modules except Special Agnostic Modules, meaning themselves as file generators that should not be imported directly and (Special) Agnostic Conditions Modules which cannot be imported in the (Abstract) Agnostic Environment.
431
+ // USE_AGNOSTIC_LOGICS Prime Agnostic Logics allowed, because (Special) Agnostic Strategies Modules can import all known modules except Special Agnostic Modules, meaning themselves as file generators that should not be imported directly and (Special) Agnostic Conditions Modules which cannot be imported in the (Abstract) Agnostic Environment.
432
+ // USE_SERVER_COMPONENTS Lineal Server Components allowed, because (Special) Agnostic Strategies Modules can import all known modules except Special Agnostic Modules, meaning themselves as file generators that should not be imported directly and (Special) Agnostic Conditions Modules which cannot be imported in the (Abstract) Agnostic Environment.
433
+ // USE_CLIENT_COMPONENTS Lineal Client Components allowed, because (Special) Agnostic Strategies Modules can import all known modules except Special Agnostic Modules, meaning themselves as file generators that should not be imported directly and (Special) Agnostic Conditions Modules which cannot be imported in the (Abstract) Agnostic Environment.
434
+ // USE_AGNOSTIC_COMPONENTS Lineal Agnostic Components allowed, because (Special) Agnostic Strategies Modules can import all known modules except Special Agnostic Modules, meaning themselves as file generators that should not be imported directly and (Special) Agnostic Conditions Modules which cannot be imported in the (Abstract) Agnostic Environment.
435
+ // USE_SERVER_FUNCTIONS (Special) Server Functions allowed, because (Special) Agnostic Strategies Modules can import all known modules except Special Agnostic Modules, meaning themselves as file generators that should not be imported directly and (Special) Agnostic Conditions Modules which cannot be imported in the (Abstract) Agnostic Environment.
436
+ // USE_CLIENT_CONTEXTS (Special) Client Contexts Components allowed, because (Special) Agnostic Strategies Modules can import all known modules except Special Agnostic Modules, meaning themselves as file generators that should not be imported directly and (Special) Agnostic Conditions Modules which cannot be imported in the (Abstract) Agnostic Environment.
437
+ makeBlockedImport(
438
+ USE_AGNOSTIC_STRATEGIES,
439
+ USE_AGNOSTIC_CONDITIONS
440
+ ) /* (Special) Agnostic Conditions Modules cannot be imported in the (Abstract) Agnostic Environment, only strictly on the server or strictly on the client. */,
441
+ makeBlockedImport(
442
+ USE_AGNOSTIC_STRATEGIES,
443
+ USE_AGNOSTIC_STRATEGIES
444
+ ) /* (Special) Agnostic Strategies Modules cannot be imported by any of the known modules, since given that Agnostic Strategies Modules generate strategized files, they need to be imported via their strategized files (like those ending in `.serverLogics.ts`) instead. */,
377
445
  ]),
378
446
  });
379
447