eslint-plugin-use-agnostic 1.0.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.
- package/README.md +1 -1
- 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/_commons/utilities/helpers.js +6 -29
- package/library/agnostic20/_commons/constants/bases.js +49 -49
- package/library/agnostic20/_commons/utilities/helpers.js +8 -8
- package/library/directive21/_commons/constants/bases.js +81 -123
- package/library/directive21/_commons/rules/import-rules.js +1 -1
- package/library/directive21/_commons/utilities/helpers.js +69 -52
- package/package.json +1 -1
|
@@ -140,123 +140,123 @@ const makeBlockedImportSuggestingUseAgnostic = (
|
|
|
140
140
|
|
|
141
141
|
export const effectiveDirectives_blockedImports = Object.freeze({
|
|
142
142
|
[USE_SERVER_LOGICS]: Object.freeze([
|
|
143
|
-
// USE_SERVER_LOGICS allowed, because
|
|
144
|
-
// USE_SERVER_COMPONENTS allowed, because
|
|
145
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
143
|
+
// USE_SERVER_LOGICS allowed, because Server Logics can compose with one another.
|
|
144
|
+
// 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.
|
|
145
|
+
// 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.)
|
|
146
146
|
makeBlockedImport(
|
|
147
147
|
USE_SERVER_LOGICS,
|
|
148
148
|
USE_CLIENT_LOGICS
|
|
149
|
-
) /*
|
|
149
|
+
) /* Client Logics should never leak to the server, such as would be the case here in a Server Logics Module. */,
|
|
150
150
|
makeBlockedImport(
|
|
151
151
|
USE_SERVER_LOGICS,
|
|
152
152
|
USE_CLIENT_COMPONENTS
|
|
153
|
-
) /*
|
|
154
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
155
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
153
|
+
) /* Client Components cannot be tinkered with on the server. */,
|
|
154
|
+
// 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.
|
|
155
|
+
// 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.
|
|
156
156
|
]),
|
|
157
157
|
[USE_SERVER_COMPONENTS]: Object.freeze([
|
|
158
|
-
// USE_SERVER_LOGICS allowed, because
|
|
159
|
-
// USE_SERVER_COMPONENTS allowed, because
|
|
160
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
158
|
+
// USE_SERVER_LOGICS allowed, because Server Logics, being logic from the server, can safely support Server Components.
|
|
159
|
+
// 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.
|
|
160
|
+
// 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.
|
|
161
161
|
makeBlockedImport(
|
|
162
162
|
USE_SERVER_COMPONENTS,
|
|
163
163
|
USE_CLIENT_LOGICS
|
|
164
|
-
) /*
|
|
165
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
166
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
167
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
164
|
+
) /* Client Logics should never leak to the server, such as would be the case here in a Server Components Module. */,
|
|
165
|
+
// 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.
|
|
166
|
+
// 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.
|
|
167
|
+
// USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can render safely on the server just like they can on the client.
|
|
168
168
|
]),
|
|
169
169
|
[USE_SERVER_FUNCTIONS]: Object.freeze([
|
|
170
|
-
// USE_SERVER_LOGICS allowed, because
|
|
170
|
+
// USE_SERVER_LOGICS allowed, because Server Logics, being logic from the server, can safely support Server Functions.
|
|
171
171
|
makeBlockedImport(
|
|
172
172
|
USE_SERVER_FUNCTIONS,
|
|
173
173
|
USE_SERVER_COMPONENTS
|
|
174
|
-
) /*
|
|
175
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
174
|
+
) /* Server Components aren't allowed because Server Functions have no business working with React Components. */,
|
|
175
|
+
// 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.)
|
|
176
176
|
makeBlockedImport(
|
|
177
177
|
USE_SERVER_FUNCTIONS,
|
|
178
178
|
USE_CLIENT_LOGICS
|
|
179
|
-
) /*
|
|
179
|
+
) /* Client Logics should never leak to the server, such as would be the case here in a Server Functions Module. */,
|
|
180
180
|
makeBlockedImport(
|
|
181
181
|
USE_SERVER_FUNCTIONS,
|
|
182
182
|
USE_CLIENT_COMPONENTS
|
|
183
|
-
) /*
|
|
184
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
183
|
+
) /* Client Components aren't allowed because Server Functions have no business working with React Components. */,
|
|
184
|
+
// 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.
|
|
185
185
|
makeBlockedImport(
|
|
186
186
|
USE_SERVER_FUNCTIONS,
|
|
187
187
|
USE_AGNOSTIC_COMPONENTS
|
|
188
|
-
) /*
|
|
188
|
+
) /* Agnostic Components aren't allowed because Server Functions have no business working with React Components. */,
|
|
189
189
|
]),
|
|
190
190
|
[USE_CLIENT_LOGICS]: Object.freeze([
|
|
191
191
|
makeBlockedImportSuggestingUseAgnostic(
|
|
192
192
|
USE_CLIENT_LOGICS,
|
|
193
193
|
USE_SERVER_LOGICS
|
|
194
|
-
) /*
|
|
194
|
+
) /* Server Logics should never leak to the client, such as would be the case here in a Client Logics Module. */,
|
|
195
195
|
makeBlockedImportSuggestingUseAgnostic(
|
|
196
196
|
USE_CLIENT_LOGICS,
|
|
197
197
|
USE_SERVER_COMPONENTS
|
|
198
|
-
) /*
|
|
199
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
200
|
-
// USE_CLIENT_LOGICS allowed, because
|
|
201
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
202
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
203
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
198
|
+
) /* Server Components cannot be thinkered with on the client. */,
|
|
199
|
+
// USE_SERVER_FUNCTIONS allowed, because Server Functions can technically be attached to Client Components that are being tinkered with within Client Logics Modules.
|
|
200
|
+
// USE_CLIENT_LOGICS allowed, because Client Logics can compose with one another.
|
|
201
|
+
// 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.
|
|
202
|
+
// 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.
|
|
203
|
+
// 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.
|
|
204
204
|
]),
|
|
205
205
|
[USE_CLIENT_COMPONENTS]: Object.freeze([
|
|
206
206
|
makeBlockedImportSuggestingUseAgnostic(
|
|
207
207
|
USE_CLIENT_LOGICS,
|
|
208
208
|
USE_SERVER_LOGICS
|
|
209
|
-
) /*
|
|
209
|
+
) /* Server Logics should never leak to the client, such as would be the case here in a Client Logics Module. */,
|
|
210
210
|
makeBlockedImportSuggestingUseAgnostic(
|
|
211
211
|
USE_CLIENT_LOGICS,
|
|
212
212
|
USE_SERVER_COMPONENTS
|
|
213
|
-
) /*
|
|
214
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
215
|
-
// USE_CLIENT_LOGICS allowed, because
|
|
216
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
217
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
218
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
213
|
+
) /* Server Components cannot be thinkered with on the client. */,
|
|
214
|
+
// USE_SERVER_FUNCTIONS allowed, because Server Functions are specifically triggered by Client Components.
|
|
215
|
+
// USE_CLIENT_LOGICS allowed, because Client Logics, being logic from the client, can safely support Client Components.
|
|
216
|
+
// USE_CLIENT_COMPONENTS allowed, because Client Components can compose with one another.
|
|
217
|
+
// 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.
|
|
218
|
+
// USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can render safely on the client just like they can on the server.
|
|
219
219
|
]),
|
|
220
220
|
[USE_AGNOSTIC_LOGICS]: Object.freeze([
|
|
221
221
|
makeBlockedImportSuggestingUseAgnostic(
|
|
222
222
|
USE_AGNOSTIC_LOGICS,
|
|
223
223
|
USE_SERVER_LOGICS
|
|
224
|
-
) /*
|
|
224
|
+
) /* Server Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Logics Module. */,
|
|
225
225
|
makeBlockedImportSuggestingUseAgnostic(
|
|
226
226
|
USE_AGNOSTIC_LOGICS,
|
|
227
227
|
USE_SERVER_COMPONENTS
|
|
228
|
-
) /*
|
|
228
|
+
) /* Server Components cannot be tinkered with on both the server and the client. */,
|
|
229
229
|
makeBlockedImport(
|
|
230
230
|
USE_AGNOSTIC_LOGICS,
|
|
231
231
|
USE_SERVER_FUNCTIONS
|
|
232
|
-
) /*
|
|
232
|
+
) /* 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. */,
|
|
233
233
|
makeBlockedImport(
|
|
234
234
|
USE_AGNOSTIC_LOGICS,
|
|
235
235
|
USE_CLIENT_LOGICS
|
|
236
|
-
) /*
|
|
236
|
+
) /* Client Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Logics Module. */,
|
|
237
237
|
makeBlockedImport(
|
|
238
238
|
USE_AGNOSTIC_LOGICS,
|
|
239
239
|
USE_CLIENT_COMPONENTS
|
|
240
|
-
) /*
|
|
241
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
242
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
240
|
+
) /* Client Components cannot be tinkered with on both the server and the client. */,
|
|
241
|
+
// USE_AGNOSTIC_LOGICS allowed, because Agnostic Logics can compose with one another.
|
|
242
|
+
// 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.
|
|
243
243
|
]),
|
|
244
244
|
[USE_AGNOSTIC_COMPONENTS]: Object.freeze([
|
|
245
245
|
makeBlockedImportSuggestingUseAgnostic(
|
|
246
246
|
USE_AGNOSTIC_COMPONENTS,
|
|
247
247
|
USE_SERVER_LOGICS
|
|
248
|
-
) /*
|
|
248
|
+
) /* Server Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Components Module. */,
|
|
249
249
|
makeBlockedImportSuggestingUseAgnostic(
|
|
250
250
|
USE_AGNOSTIC_COMPONENTS,
|
|
251
251
|
USE_SERVER_COMPONENTS
|
|
252
|
-
) /*
|
|
253
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
252
|
+
) /* 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. */,
|
|
253
|
+
// 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.
|
|
254
254
|
makeBlockedImport(
|
|
255
255
|
USE_AGNOSTIC_COMPONENTS,
|
|
256
256
|
USE_CLIENT_LOGICS
|
|
257
|
-
) /*
|
|
258
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
259
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
260
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
257
|
+
) /* Client Logics cannot run on both the server and the client, such as would be the case here in an Agnostic Components Module. */,
|
|
258
|
+
// 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.
|
|
259
|
+
// USE_AGNOSTIC_LOGICS allowed, because Agnostic Logics, being environment-agnostic logic, can safely support Agnostic Components.
|
|
260
|
+
// USE_AGNOSTIC_COMPONENTS allowed, because Agnostic Components can compose with one another.
|
|
261
261
|
]),
|
|
262
262
|
});
|
|
@@ -12,7 +12,7 @@ import {
|
|
|
12
12
|
isImportBlocked as commonsIsImportBlocked,
|
|
13
13
|
makeMessageFromCurrentFileResolvedDirective,
|
|
14
14
|
findSpecificViolationMessage as commonsFindSpecificViolationMessage,
|
|
15
|
-
|
|
15
|
+
getSourceCodeFromFilePath,
|
|
16
16
|
} from "../../../_commons/utilities/helpers.js";
|
|
17
17
|
|
|
18
18
|
/**
|
|
@@ -29,8 +29,8 @@ import {
|
|
|
29
29
|
/**
|
|
30
30
|
* Gets the directive of a module from its Abstract Syntax Tree.
|
|
31
31
|
* - `null` denotes a server-by-default module, ideally a Server Module.
|
|
32
|
-
* - `'use client'` denotes a Client Module.
|
|
33
32
|
* - `'use server'` denotes a Server Functions Module.
|
|
33
|
+
* - `'use client'` denotes a Client Module.
|
|
34
34
|
* - `'use agnostic'` denotes an Agnostic Module (formerly Shared Module).
|
|
35
35
|
* @param {AST} ast The module's AST (Abstract Syntax Tree).
|
|
36
36
|
* @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) => {
|
|
|
64
64
|
/**
|
|
65
65
|
* Gets the directive of the current module.
|
|
66
66
|
* - `null` denotes a server-by-default module, ideally a Server Module.
|
|
67
|
-
* - `'use client'` denotes a Client Module.
|
|
68
67
|
* - `'use server'` denotes a Server Functions Module.
|
|
68
|
+
* - `'use client'` denotes a Client Module.
|
|
69
69
|
* - `'use agnostic'` denotes an Agnostic Module (formerly Shared Module).
|
|
70
70
|
* @param {Context} context The ESLint rule's `context` object.
|
|
71
71
|
* @returns The directive, or lack thereof via `null`. The lack of a directive is considered server-by-default.
|
|
@@ -81,16 +81,16 @@ export const getDirectiveFromCurrentModule = (context) => {
|
|
|
81
81
|
|
|
82
82
|
/**
|
|
83
83
|
* Gets the directive of the imported module.
|
|
84
|
-
* - `
|
|
84
|
+
* - `null` denotes a server-by-default module, ideally a Server Module.
|
|
85
85
|
* - `'use server'` denotes a Server Functions Module.
|
|
86
|
+
* - `'use client'` denotes a Client Module.
|
|
86
87
|
* - `'use agnostic'` denotes an Agnostic Module (formerly Shared Module).
|
|
87
|
-
*
|
|
88
|
-
* @param {string} resolvedImportPath The resolved path of the import.
|
|
88
|
+
* @param {string} resolvedPath The resolved path of the imported module.
|
|
89
89
|
* @returns The directive, or lack thereof via `null`. The lack of a directive is considered server-by-default.
|
|
90
90
|
*/
|
|
91
|
-
export const getDirectiveFromImportedModule = (
|
|
91
|
+
export const getDirectiveFromImportedModule = (resolvedPath) => {
|
|
92
92
|
// the AST of the imported module
|
|
93
|
-
const ast =
|
|
93
|
+
const ast = getSourceCodeFromFilePath(resolvedPath).ast;
|
|
94
94
|
|
|
95
95
|
return getDirectiveFromModule(ast);
|
|
96
96
|
};
|
|
@@ -119,48 +119,6 @@ export const commentedDirectiveMessage = "commentedDirectiveMessage";
|
|
|
119
119
|
export const specificViolationMessage = "specificViolationMessage";
|
|
120
120
|
export const specificFailure = "specificFailure";
|
|
121
121
|
|
|
122
|
-
/* commentedDirectives_4RawImplementations */
|
|
123
|
-
|
|
124
|
-
// all formatting styles as an array of [prefix, quote, suffix]
|
|
125
|
-
/** @type {CommentStyles} */
|
|
126
|
-
const commentStyles = Object.freeze([
|
|
127
|
-
Object.freeze([`// `, `'`, ``]), // V1: `// 'directive'`
|
|
128
|
-
Object.freeze([`// `, `"`, ``]), // V2: `// "directive"`
|
|
129
|
-
Object.freeze([`\/\* `, `'`, ` \*\/`]), // V3: `/* 'directive' */`
|
|
130
|
-
Object.freeze([`\/\* `, `"`, ` \*\/`]), // V4: `/* "directive" */`
|
|
131
|
-
]);
|
|
132
|
-
|
|
133
|
-
/**
|
|
134
|
-
* Makes the array of all four accepted commented directive implementations on a directive basis.
|
|
135
|
-
* @template {CommentedDirective} T
|
|
136
|
-
* @param {T} directive The commented directive.
|
|
137
|
-
* @returns The array of formatted commented directives.
|
|
138
|
-
*/
|
|
139
|
-
const make4RawImplementations = (directive) => {
|
|
140
|
-
/** @type {readonly [`// '${T}'`, `// "${T}""`, `\/\* '${T}' \*\/`, `\/\* "${T}"" \*\/`]} */
|
|
141
|
-
const rawImplementations = Object.freeze(
|
|
142
|
-
commentStyles.map(
|
|
143
|
-
([prefix, quote, suffix]) =>
|
|
144
|
-
`${prefix}${quote}${directive}${quote}${suffix}`
|
|
145
|
-
)
|
|
146
|
-
);
|
|
147
|
-
|
|
148
|
-
return rawImplementations;
|
|
149
|
-
};
|
|
150
|
-
|
|
151
|
-
export const commentedDirectives_4RawImplementations = Object.freeze({
|
|
152
|
-
[USE_SERVER_LOGICS]: make4RawImplementations(USE_SERVER_LOGICS),
|
|
153
|
-
[USE_CLIENT_LOGICS]: make4RawImplementations(USE_CLIENT_LOGICS),
|
|
154
|
-
[USE_AGNOSTIC_LOGICS]: make4RawImplementations(USE_AGNOSTIC_LOGICS),
|
|
155
|
-
[USE_SERVER_COMPONENTS]: make4RawImplementations(USE_SERVER_COMPONENTS),
|
|
156
|
-
[USE_CLIENT_COMPONENTS]: make4RawImplementations(USE_CLIENT_COMPONENTS),
|
|
157
|
-
[USE_AGNOSTIC_COMPONENTS]: make4RawImplementations(USE_AGNOSTIC_COMPONENTS),
|
|
158
|
-
[USE_SERVER_FUNCTIONS]: make4RawImplementations(USE_SERVER_FUNCTIONS),
|
|
159
|
-
[USE_CLIENT_CONTEXTS]: make4RawImplementations(USE_CLIENT_CONTEXTS),
|
|
160
|
-
[USE_AGNOSTIC_CONDITIONS]: make4RawImplementations(USE_AGNOSTIC_CONDITIONS),
|
|
161
|
-
[USE_AGNOSTIC_STRATEGIES]: make4RawImplementations(USE_AGNOSTIC_STRATEGIES),
|
|
162
|
-
});
|
|
163
|
-
|
|
164
122
|
/* commentedDirectives_verificationReports */
|
|
165
123
|
|
|
166
124
|
const MODULES_MARKED_WITH_THE_ = "modules marked with the";
|
|
@@ -211,189 +169,189 @@ export const makeBlockedImport = (
|
|
|
211
169
|
|
|
212
170
|
export const commentedDirectives_blockedImports = Object.freeze({
|
|
213
171
|
[USE_SERVER_LOGICS]: Object.freeze([
|
|
214
|
-
// USE_SERVER_LOGICS allowed, because
|
|
172
|
+
// USE_SERVER_LOGICS allowed, because Prime Server Logics can compose with one another.
|
|
215
173
|
makeBlockedImport(
|
|
216
174
|
USE_SERVER_LOGICS,
|
|
217
175
|
USE_CLIENT_LOGICS
|
|
218
|
-
) /*
|
|
219
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
220
|
-
// USE_SERVER_COMPONENTS allowed, because
|
|
176
|
+
) /* Prime Client Logics should never leak to the server, such as would be the case here in a Prime Server Logics Module. */,
|
|
177
|
+
// 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.
|
|
178
|
+
// 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.
|
|
221
179
|
makeBlockedImport(
|
|
222
180
|
USE_SERVER_LOGICS,
|
|
223
181
|
USE_CLIENT_COMPONENTS
|
|
224
|
-
) /*
|
|
225
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
226
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
182
|
+
) /* Lineal Client Components, like any Client Components, cannot be tinkered with on the server. */,
|
|
183
|
+
// 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.
|
|
184
|
+
// 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.)
|
|
227
185
|
makeBlockedImport(
|
|
228
186
|
USE_SERVER_LOGICS,
|
|
229
187
|
USE_CLIENT_CONTEXTS
|
|
230
|
-
) /*
|
|
231
|
-
// USE_AGNOSTIC_CONDITIONS allowed, because
|
|
188
|
+
) /* Client Contexts Components, like any Client Components, cannot be tinkered with on the server. */,
|
|
189
|
+
// 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.
|
|
232
190
|
]),
|
|
233
191
|
[USE_CLIENT_LOGICS]: Object.freeze([
|
|
234
192
|
makeBlockedImport(
|
|
235
193
|
USE_CLIENT_LOGICS,
|
|
236
194
|
USE_SERVER_LOGICS
|
|
237
|
-
) /*
|
|
238
|
-
// USE_CLIENT_LOGICS allowed, because
|
|
239
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
195
|
+
) /* Prime Server Logics should never leak to the client, such as would be the case here in a Prime Client Logics Module. */,
|
|
196
|
+
// USE_CLIENT_LOGICS allowed, because Prime Client Logics can compose with one another.
|
|
197
|
+
// 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.
|
|
240
198
|
makeBlockedImport(
|
|
241
199
|
USE_CLIENT_LOGICS,
|
|
242
200
|
USE_SERVER_COMPONENTS
|
|
243
|
-
) /*
|
|
244
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
245
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
246
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
247
|
-
// USE_CLIENT_CONTEXTS allowed, because
|
|
248
|
-
// USE_AGNOSTIC_CONDITIONS allowed, because
|
|
201
|
+
) /* Lineal Server Components cannot be thinkered with on the client. */,
|
|
202
|
+
// 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.
|
|
203
|
+
// 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.
|
|
204
|
+
// USE_SERVER_FUNCTIONS allowed, because (Special) Server Functions can technically be attached to Client Components that are being tinkered with within Client Logics Modules.
|
|
205
|
+
// 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.
|
|
206
|
+
// 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.
|
|
249
207
|
]),
|
|
250
208
|
[USE_AGNOSTIC_LOGICS]: Object.freeze([
|
|
251
209
|
makeBlockedImport(
|
|
252
210
|
USE_AGNOSTIC_LOGICS,
|
|
253
211
|
USE_SERVER_LOGICS
|
|
254
|
-
) /*
|
|
212
|
+
) /* 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. */,
|
|
255
213
|
makeBlockedImport(
|
|
256
214
|
USE_AGNOSTIC_LOGICS,
|
|
257
215
|
USE_CLIENT_LOGICS
|
|
258
|
-
) /*
|
|
259
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
216
|
+
) /* 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. */,
|
|
217
|
+
// USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics can compose with one another.
|
|
260
218
|
makeBlockedImport(
|
|
261
219
|
USE_AGNOSTIC_LOGICS,
|
|
262
220
|
USE_SERVER_COMPONENTS
|
|
263
|
-
) /*
|
|
221
|
+
) /* Lineal Server Components cannot be tinkered with on both the server and the client. */,
|
|
264
222
|
makeBlockedImport(
|
|
265
223
|
USE_AGNOSTIC_LOGICS,
|
|
266
224
|
USE_CLIENT_COMPONENTS
|
|
267
|
-
) /*
|
|
268
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
225
|
+
) /* Lineal Client Components, like any Client Components, cannot be tinkered with on both the server and the client. */,
|
|
226
|
+
// 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.
|
|
269
227
|
makeBlockedImport(
|
|
270
228
|
USE_AGNOSTIC_LOGICS,
|
|
271
229
|
USE_SERVER_FUNCTIONS
|
|
272
|
-
) /*
|
|
230
|
+
) /* (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. */,
|
|
273
231
|
makeBlockedImport(
|
|
274
232
|
USE_AGNOSTIC_LOGICS,
|
|
275
233
|
USE_CLIENT_CONTEXTS
|
|
276
|
-
) /*
|
|
277
|
-
// USE_AGNOSTIC_CONDITIONS allowed, because
|
|
234
|
+
) /* (Special) Client Contexts Components, like any Client Components, cannot be tinkered with on both the server and the client. */,
|
|
235
|
+
// 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.
|
|
278
236
|
]),
|
|
279
237
|
[USE_SERVER_COMPONENTS]: Object.freeze([
|
|
280
|
-
// USE_SERVER_LOGICS allowed, because
|
|
238
|
+
// USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support Lineal Server Components.
|
|
281
239
|
makeBlockedImport(
|
|
282
240
|
USE_SERVER_COMPONENTS,
|
|
283
241
|
USE_CLIENT_LOGICS
|
|
284
|
-
) /*
|
|
285
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
286
|
-
// USE_SERVER_COMPONENTS allowed, because
|
|
287
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
288
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
289
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
290
|
-
// USE_CLIENT_CONTEXTS allowed, because
|
|
291
|
-
// USE_AGNOSTIC_CONDITIONS allowed, because
|
|
242
|
+
) /* Prime Client Logics should never leak to the server, such as would be the case here in a Lineal Server Components Module. */,
|
|
243
|
+
// 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.
|
|
244
|
+
// 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.
|
|
245
|
+
// 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.
|
|
246
|
+
// USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can render safely on the server just like they can on the client.
|
|
247
|
+
// 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.
|
|
248
|
+
// 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.
|
|
249
|
+
// 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.
|
|
292
250
|
]),
|
|
293
251
|
[USE_CLIENT_COMPONENTS]: Object.freeze([
|
|
294
252
|
makeBlockedImport(
|
|
295
253
|
USE_CLIENT_COMPONENTS,
|
|
296
254
|
USE_SERVER_LOGICS
|
|
297
|
-
) /*
|
|
298
|
-
// USE_CLIENT_LOGICS allowed, because
|
|
299
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
255
|
+
) /* Prime Server Logics should never leak to the client, such as would be the case here in a Lineal Client Components Module. */,
|
|
256
|
+
// USE_CLIENT_LOGICS allowed, because Prime Client Logics, being logic from the client, can safely support Lineal Client Components, like any Client Components.
|
|
257
|
+
// 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.
|
|
300
258
|
makeBlockedImport(
|
|
301
259
|
USE_CLIENT_COMPONENTS,
|
|
302
260
|
USE_SERVER_COMPONENTS
|
|
303
|
-
) /*
|
|
304
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
305
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
306
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
307
|
-
// USE_CLIENT_CONTEXTS allowed, because
|
|
308
|
-
// USE_AGNOSTIC_CONDITIONS allowed, because
|
|
261
|
+
) /* Lineal Server Components cannot be the children of Lineal Client Components. */,
|
|
262
|
+
// USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can compose with one another.
|
|
263
|
+
// 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.
|
|
264
|
+
// 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.
|
|
265
|
+
// 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.
|
|
266
|
+
// 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.
|
|
309
267
|
]),
|
|
310
268
|
[USE_AGNOSTIC_COMPONENTS]: Object.freeze([
|
|
311
269
|
makeBlockedImport(
|
|
312
270
|
USE_AGNOSTIC_COMPONENTS,
|
|
313
271
|
USE_SERVER_LOGICS
|
|
314
|
-
) /*
|
|
272
|
+
) /* 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. */,
|
|
315
273
|
makeBlockedImport(
|
|
316
274
|
USE_AGNOSTIC_COMPONENTS,
|
|
317
275
|
USE_CLIENT_LOGICS
|
|
318
|
-
) /*
|
|
319
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
276
|
+
) /* 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. */,
|
|
277
|
+
// USE_AGNOSTIC_LOGICS allowed, because Prime Agnostic Logics, being environment-agnostic logic, can safely support Agnostic Components.
|
|
320
278
|
makeBlockedImport(
|
|
321
279
|
USE_AGNOSTIC_COMPONENTS,
|
|
322
280
|
USE_SERVER_COMPONENTS
|
|
323
|
-
) /*
|
|
324
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
325
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
326
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
327
|
-
// USE_CLIENT_CONTEXTS allowed, because
|
|
328
|
-
// USE_AGNOSTIC_CONDITIONS allowed, because
|
|
281
|
+
) /* 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. */,
|
|
282
|
+
// 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.
|
|
283
|
+
// USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components, can compose with one another.
|
|
284
|
+
// 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.
|
|
285
|
+
// 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.
|
|
286
|
+
// 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.
|
|
329
287
|
]),
|
|
330
288
|
[USE_SERVER_FUNCTIONS]: Object.freeze([
|
|
331
|
-
// USE_SERVER_LOGICS allowed, because
|
|
289
|
+
// USE_SERVER_LOGICS allowed, because Prime Server Logics, being logic from the server, can safely support (Special) Server Functions.
|
|
332
290
|
makeBlockedImport(
|
|
333
291
|
USE_SERVER_FUNCTIONS,
|
|
334
292
|
USE_CLIENT_LOGICS
|
|
335
|
-
) /*
|
|
336
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
293
|
+
) /* Prime Client Logics should never leak to the server, such as would be the case here in a Special Server Functions Module. */,
|
|
294
|
+
// 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.
|
|
337
295
|
makeBlockedImport(
|
|
338
296
|
USE_SERVER_FUNCTIONS,
|
|
339
297
|
USE_SERVER_COMPONENTS
|
|
340
|
-
) /*
|
|
298
|
+
) /* Lineal Server Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
|
|
341
299
|
makeBlockedImport(
|
|
342
300
|
USE_SERVER_FUNCTIONS,
|
|
343
301
|
USE_CLIENT_COMPONENTS
|
|
344
|
-
) /*
|
|
302
|
+
) /* Lineal Client Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
|
|
345
303
|
makeBlockedImport(
|
|
346
304
|
USE_SERVER_FUNCTIONS,
|
|
347
305
|
USE_AGNOSTIC_COMPONENTS
|
|
348
|
-
) /*
|
|
349
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
306
|
+
) /* Lineal Agnostic Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
|
|
307
|
+
// 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.)
|
|
350
308
|
makeBlockedImport(
|
|
351
309
|
USE_SERVER_FUNCTIONS,
|
|
352
310
|
USE_CLIENT_CONTEXTS
|
|
353
|
-
) /*
|
|
311
|
+
) /* (Special) Client Contexts Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
|
|
354
312
|
makeBlockedImport(
|
|
355
313
|
USE_SERVER_FUNCTIONS,
|
|
356
314
|
USE_AGNOSTIC_CONDITIONS
|
|
357
|
-
) /*
|
|
315
|
+
) /* (Special) Agnostic Conditions Components aren't allowed because (Special) Server Functions have no business working with React Components. */,
|
|
358
316
|
]),
|
|
359
317
|
[USE_CLIENT_CONTEXTS]: Object.freeze([
|
|
360
318
|
makeBlockedImport(
|
|
361
319
|
USE_CLIENT_CONTEXTS,
|
|
362
320
|
USE_SERVER_LOGICS
|
|
363
|
-
) /*
|
|
364
|
-
// USE_CLIENT_LOGICS allowed, because
|
|
365
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
321
|
+
) /* Prime Server Logics should never leak to the client, such as would be the case here in a Special Client Contexts Module. */,
|
|
322
|
+
// USE_CLIENT_LOGICS allowed, because Prime Client Logics, being logic from the client, can safely support (Special) Client Contexts Components, like any Client Components.
|
|
323
|
+
// 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.
|
|
366
324
|
makeBlockedImport(
|
|
367
325
|
USE_CLIENT_CONTEXTS,
|
|
368
326
|
USE_SERVER_COMPONENTS
|
|
369
|
-
) /*
|
|
370
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
371
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
372
|
-
// USE_SERVER_FUNCTIONS allowed, because
|
|
373
|
-
// USE_CLIENT_CONTEXTS allowed, because
|
|
374
|
-
// USE_AGNOSTIC_CONDITIONS allowed, because
|
|
327
|
+
) /* Lineal Server Components may only pass through (Special) Client Contexts Components via the children prop within Server Components Modules. */,
|
|
328
|
+
// USE_CLIENT_COMPONENTS allowed, because Lineal Client Components can create client boundaries within (Special) Client Contexts Components.
|
|
329
|
+
// 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.
|
|
330
|
+
// 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.
|
|
331
|
+
// USE_CLIENT_CONTEXTS allowed, because (Special) Client Contexts Components can compose with one another.
|
|
332
|
+
// 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.
|
|
375
333
|
]),
|
|
376
334
|
[USE_AGNOSTIC_CONDITIONS]: Object.freeze([
|
|
377
335
|
makeBlockedImport(
|
|
378
336
|
USE_AGNOSTIC_CONDITIONS,
|
|
379
337
|
USE_SERVER_LOGICS
|
|
380
|
-
) /*
|
|
338
|
+
) /* 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. */,
|
|
381
339
|
makeBlockedImport(
|
|
382
340
|
USE_AGNOSTIC_CONDITIONS,
|
|
383
341
|
USE_CLIENT_LOGICS
|
|
384
|
-
) /*
|
|
385
|
-
// USE_AGNOSTIC_LOGICS allowed, because
|
|
386
|
-
// USE_SERVER_COMPONENTS allowed, because
|
|
387
|
-
// USE_CLIENT_COMPONENTS allowed, because
|
|
388
|
-
// USE_AGNOSTIC_COMPONENTS allowed, because
|
|
342
|
+
) /* 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. */,
|
|
343
|
+
// 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.)
|
|
344
|
+
// USE_SERVER_COMPONENTS allowed, because Lineal Server Components are to be paired as `ComponentForServer` components with `ComponentForClient` components to form (Special) Agnostic Conditions Components.
|
|
345
|
+
// USE_CLIENT_COMPONENTS allowed, because Lineal Client Components are to be paired as `ComponentForClient` components with `ComponentForServer` components to form (Special) Agnostic Conditions Components.
|
|
346
|
+
// USE_AGNOSTIC_COMPONENTS allowed, because Lineal Agnostic Components can take the place of `ComponentForServer` and/or `ComponentForClient` components to form (Special) Agnostic Conditions Components.
|
|
389
347
|
makeBlockedImport(
|
|
390
348
|
USE_AGNOSTIC_CONDITIONS,
|
|
391
349
|
USE_SERVER_FUNCTIONS
|
|
392
|
-
) /*
|
|
350
|
+
) /* (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. */,
|
|
393
351
|
makeBlockedImport(
|
|
394
352
|
USE_AGNOSTIC_CONDITIONS,
|
|
395
353
|
USE_CLIENT_CONTEXTS
|
|
396
|
-
) /*
|
|
397
|
-
// USE_AGNOSTIC_CONDITIONS allowed, because
|
|
354
|
+
) /* (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. */,
|
|
355
|
+
// 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.
|
|
398
356
|
]),
|
|
399
357
|
});
|
|
@@ -39,7 +39,7 @@ Here, "{{ ${currentFileCommentedDirective} }}" and "{{ ${importedFileCommentedDi
|
|
|
39
39
|
[importBreaksCommentedImportRulesMessageId]: `{{ ${commentedDirectiveMessage} }}
|
|
40
40
|
In this case, {{ ${specificViolationMessage} }} `,
|
|
41
41
|
[noCommentedDirective]: `No commented directive detected.
|
|
42
|
-
All targeted modules need to be marked with their respective directives (\`// "use server logics"\`, etc.) for the purpose of this linting rule. `,
|
|
42
|
+
All targeted modules need to be marked with their respective directives (\`// "use server logics"\`, etc.) for the purpose of this linting rule, evaluated from the first JavaScript comment starting on the first column within the first three lines of a module. `,
|
|
43
43
|
[commentedDirectiveVerificationFailed]: `The commented directive could not pass verification due to an incompatible combination with its file extension.
|
|
44
44
|
In this context, {{ ${specificFailure} }} `,
|
|
45
45
|
[importNotStrategized]: `Imports from Agnostic Strategies Modules must be strategized (\`/* @serverLogics */\`, etc.).
|