eslint-plugin-use-agnostic 1.7.9 → 1.8.1

package/library/directive21/_commons/rules/import-rules.js

@@ -4,8 +4,8 @@ import {
   noCommentedDirectiveMessageId,
   commentedDirectiveVerificationFailedMessageId,
   commentedDirectiveReactDirectiveFailedMessageId,
-  importNotStrategizedMessageId,
-  exportNotStrategizedMessageId,
+  // importNotStrategizedMessageId,
+  // exportNotStrategizedMessageId,
   cantChainImportAcrossEnvironmentsMessageId,
 } from "../../../_commons/constants/bases.js";
 import {
@@ -50,10 +50,10 @@ All targeted modules need to be marked with their respective directives (\`// "u
       [commentedDirectiveVerificationFailedMessageId]: `The commented directive could not pass verification due to an incompatible combination with its file extension.
 In this context, {{ ${specificFailure} }} `,
       [commentedDirectiveReactDirectiveFailedMessageId]: `Commented directive "{{ ${verifiedCommentedDirective} }}" requires {{ ${expectedReactDirectiveAsText} }} directive in order to communicate accordingly with the React architecture at hand. `,
-      [importNotStrategizedMessageId]: `Imports from Agnostic Strategies Modules must be strategized (\`/* @serverLogics */\`, etc.).  
-Please include a Strategy that corresponds to the kind of module this import would be mapped to. `,
-      [exportNotStrategizedMessageId]: `Exports from Agnostic Strategies Modules must be strategized (\`/* @serverLogics */\`, etc.).  
-Please include a Strategy that corresponds to the kind of module this export would be mapped to. `,
+      //       [importNotStrategizedMessageId]: `Imports from Agnostic Strategies Modules must be strategized (\`/* @serverLogics */\`, etc.).
+      // Please include a Strategy that corresponds to the kind of module this import would be mapped to. `,
+      //       [exportNotStrategizedMessageId]: `Exports from Agnostic Strategies Modules must be strategized (\`/* @serverLogics */\`, etc.).
+      // Please include a Strategy that corresponds to the kind of module this export would be mapped to. `,
       [cantChainImportAcrossEnvironmentsMessageId]: `Because imports are actually references instead of modules across environments, it is not possible to chain-import between the {{ ${currentFileEnvironment} }} environment and the {{ ${importedFileEnvironment} }} environment. In these cases, only direct imports apply. `,
     },
   },

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

@@ -10,7 +10,7 @@ import {
   noCommentedDirectiveMessageId,
   commentedDirectiveVerificationFailedMessageId,
   commentedDirectiveReactDirectiveFailedMessageId,
-  importNotStrategizedMessageId,
+  // importNotStrategizedMessageId,
   cantChainImportAcrossEnvironmentsMessageId,
   skip,
 } from "../../../_commons/constants/bases.js";
@@ -29,6 +29,7 @@ import {
   environments_allowedChainImportEnvironments,
   commentedDirectives_reactDirectives,
   reactDirectives_asTexts,
+  USE_AGNOSTIC_CONDITIONS,
 } from "../constants/bases.js";
 
 import { highlightFirstLineOfCode } from "../../../_commons/utilities/helpers.js";
@@ -40,7 +41,7 @@ import {
   isImportBlocked,
   makeMessageFromCurrentFileCommentedDirective,
   findSpecificViolationMessage,
-  getStrategizedDirective,
+  // getStrategizedDirective,
   addressDirectiveIfAgnosticStrategies,
 } from "./helpers.js";
 import { analyzeExportsForReExports } from "./analyze-exports-re.js";
@@ -192,13 +193,12 @@ export const currentFileFlow = (context) => {
     }
 
     // NEW
-    // do not report if the module is a non-Extra JavaScript Agnostic Strategies Module, in order to allow them the freedom of doing whatever they want so they can behave in any which way they need to as convention files
-    if (
-      !(
-        fileIsRegularJavaScript(context.filename) &&
-        verifiedCommentedDirective === USE_AGNOSTIC_STRATEGIES
-      )
-    )
+    const isRegularJavaScriptAgnosticStrategies =
+      fileIsRegularJavaScript(context.filename) &&
+      verifiedCommentedDirective === USE_AGNOSTIC_STRATEGIES;
+
+    // do not report if the module is a non-Extra JavaScript Agnostic Strategies Module, in order to allow them the freedom of doing whatever they want so they can behave in any which way they need to as convention files (JSX extension still required though)
+    if (!isRegularJavaScriptAgnosticStrategies)
       context.report({
         loc: highlightFirstLineOfCode(context),
         messageId: commentedDirectiveReactDirectiveFailedMessageId,
@@ -271,26 +271,29 @@ const importedFileFlow = (context, node) => {
   (Consequently, details below are currently at the stage of wishful thinking.)
   Strategy exports are planned to be linting in the future within their own Agnostic Strategies Modules to ensure they respect import rules within their own scopes. It may also become possible to check whether the export and import Strategies are the same in the future when identifiers are defined and the same, especially for components modules where a convention could be for all non-type exports to be named and PascalCase. */
 
-  if (importedFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
-    const importingFileCommentedDirective = getStrategizedDirective(
-      context,
-      node
-    );
-
-    if (
-      importingFileCommentedDirective === null &&
-      fileIsExtraJavaScript(context.filename)
-    ) {
-      context.report({
-        node,
-        messageId: importNotStrategizedMessageId,
-      });
-      return skipTrue;
-    }
-
-    // FOR NOW, we consider the importingFileCommentedDirective (which is strategized) and the importedFileCommentedDirective (which should be strategized on its own imported file) to be same, given the limitation highlighted above.
-    importedFileCommentedDirective = importingFileCommentedDirective;
-  }
+  // NEW!!
+  // No changes anymore. Agnostic Strategies Modules from now on are going to be considered regularly checked module that simply CANNOT be imported anywhere.
+
+  // if (importedFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
+  //   const importingFileCommentedDirective = getStrategizedDirective(
+  //     context,
+  //     node
+  //   );
+
+  //   if (
+  //     importingFileCommentedDirective === null &&
+  //     fileIsExtraJavaScript(context.filename)
+  //   ) {
+  //     context.report({
+  //       node,
+  //       messageId: importNotStrategizedMessageId,
+  //     });
+  //     return skipTrue;
+  //   }
+
+  //   // FOR NOW, we consider the importingFileCommentedDirective (which is strategized) and the importedFileCommentedDirective (which should be strategized on its own imported file) to be same, given the limitation highlighted above.
+  //   importedFileCommentedDirective = importingFileCommentedDirective;
+  // }
 
   // you never know
   if (!importedFileSourceCode) {
@@ -380,26 +383,26 @@ const importedFileFlowRequire = (context, node) => {
   (Consequently, details below are currently at the stage of wishful thinking.)
   Strategy exports are planned to be linting in the future within their own Agnostic Strategies Modules to ensure they respect import rules within their own scopes. It may also become possible to check whether the export and import Strategies are the same in the future when identifiers are defined and the same, especially for components modules where a convention could be for all non-type exports to be named and PascalCase. */
 
-    if (importedFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
-      const importingFileCommentedDirective = getStrategizedDirective(
-        context,
-        node
-      );
-
-      if (
-        importingFileCommentedDirective === null &&
-        fileIsExtraJavaScript(context.filename)
-      ) {
-        context.report({
-          node,
-          messageId: importNotStrategizedMessageId,
-        });
-        return skipTrue;
-      }
-
-      // FOR NOW, we consider the importingFileCommentedDirective (which is strategized) and the importedFileCommentedDirective (which should be strategized on its own imported file) to be same, given the limitation highlighted above.
-      importedFileCommentedDirective = importingFileCommentedDirective;
-    }
+    // if (importedFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) {
+    //   const importingFileCommentedDirective = getStrategizedDirective(
+    //     context,
+    //     node
+    //   );
+
+    //   if (
+    //     importingFileCommentedDirective === null &&
+    //     fileIsExtraJavaScript(context.filename)
+    //   ) {
+    //     context.report({
+    //       node,
+    //       messageId: importNotStrategizedMessageId,
+    //     });
+    //     return skipTrue;
+    //   }
+
+    //   // FOR NOW, we consider the importingFileCommentedDirective (which is strategized) and the importedFileCommentedDirective (which should be strategized on its own imported file) to be same, given the limitation highlighted above.
+    //   importedFileCommentedDirective = importingFileCommentedDirective;
+    // }
 
     // you never know
     if (!importedFileSourceCode) {
@@ -443,8 +446,8 @@ export const importsFlow = (context, node, currentFileCommentedDirective) => {
   if (result.skip) return;
   const { importedFileCommentedDirective } = result;
 
-  // returns early is the current file is an Agnostic Strategies Module
-  if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) return;
+  // returns early is the current file is an Agnostic Strategies Module // not anymore
+  // if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) return;
 
   if (
     isImportBlocked(
@@ -519,8 +522,8 @@ export const importsFlowRequire = (
   if (result.skip) return;
   const { importedFileCommentedDirective } = result;
 
-  // returns early is the current file is an Agnostic Strategies Module
-  if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) return;
+  // returns early is the current file is an Agnostic Strategies Module // not anymore
+  // if (currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES) return;
 
   if (
     isImportBlocked(
@@ -618,12 +621,42 @@ export const allExportsFlow = (
       currentFileCommentedDirective
     );
 
-    // returns early if an address has been made
-    if (!addressedDirective) return;
+    // // returns early if an address has been made
+    // if (!addressedDirective) return;
     // moves on to the re-export check otherwise
-    else currentFileCommentedDirective = addressedDirective;
+    // else
+    currentFileCommentedDirective = addressedDirective; // to still keep compatibility with strategies
 
-    if (currentFileCommentedDirective !== importedFileCommentedDirective) {
+    // Lints imports of Agnostic Strategies Modules beyond strategy resolution, such as to warn imports of Special Agnostic Modules. Does the same with Agnostic Conditions Modules, since they are the only other modules which cannot import themselves.
+    if (
+      currentFileCommentedDirective === USE_AGNOSTIC_STRATEGIES ||
+      currentFileCommentedDirective === USE_AGNOSTIC_CONDITIONS
+    ) {
+      // Basically, all modules need to do reexports that correspond to their own modules, but not Agnostic Strategies Modules and Agnostic Conditions Modules, the latter which are in fact NOT allowed to do re-exports.
+      if (
+        isImportBlocked(
+          currentFileCommentedDirective,
+          importedFileCommentedDirective
+        )
+      ) {
+        context.report({
+          node,
+          messageId: importBreaksCommentedImportRulesMessageId,
+          data: {
+            [commentedDirectiveMessage]:
+              makeMessageFromCurrentFileCommentedDirective(
+                currentFileCommentedDirective
+              ),
+            [specificViolationMessage]: findSpecificViolationMessage(
+              currentFileCommentedDirective,
+              importedFileCommentedDirective
+            ),
+          },
+        });
+      }
+    } else if (
+      currentFileCommentedDirective !== importedFileCommentedDirective
+    ) {
       context.report({
         node,
         messageId: reExportNotSameMessageId,

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

@@ -1,6 +1,6 @@
 import { getSourceCodeFromFilePath } from "get-sourcecode-from-file-path";
 
-import { exportNotStrategizedMessageId } from "../../../_commons/constants/bases.js";
+// import { exportNotStrategizedMessageId } from "../../../_commons/constants/bases.js";
 import {
   USE_AGNOSTIC_STRATEGIES,
   commentedDirectivesArray,
@@ -323,25 +323,30 @@ export const addressDirectiveIfAgnosticStrategies = (
 
   const exportStrategizedDirective = getStrategizedDirective(context, node);
 
-  if (
-    exportStrategizedDirective === null &&
-    fileIsExtraJavaScript(context.filename)
-  ) {
-    context.report({
-      node,
-      messageId: exportNotStrategizedMessageId,
-    });
-  }
-
-  return exportStrategizedDirective; // null indicates failure
+  // NEW!!
+  // Now entirely neutralized. Agnostic Strategies Modules are now going to be vetted module just like the others from now on.
+  // BUT!!
+  // Still acknowledges ongoing strategies since they are indeed still acknowledged, though in a unreliable way, by the eXtra JSX's TypeScript server plugin.
+
+  // if (
+  //   exportStrategizedDirective === null &&
+  //   fileIsExtraJavaScript(context.filename)
+  // ) {
+  //   context.report({
+  //     node,
+  //     messageId: exportNotStrategizedMessageId,
+  //   });
+  // }
+
+  return exportStrategizedDirective ?? currentFileCommentedDirective; // null indicates failure, but now that Agnostic Strategies Modules are regularly linted like any other modules, they need to surface
 };
 
 /* isImportBlocked */
 
 /**
  * Returns a boolean deciding if an imported file's commented directive is incompatible with the current file's commented directive.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} currentFileCommentedDirective The current file's commented directive.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} importedFileCommentedDirective The imported file's commented directive.
+ * @param {CommentedDirective} currentFileCommentedDirective The current file's commented directive.
+ * @param {CommentedDirective} importedFileCommentedDirective The imported file's commented directive.
  * @returns `true` if the import is blocked, as established in `commentedDirectives_BlockedImports`.
  */
 export const isImportBlocked = (
@@ -373,8 +378,8 @@ export const makeMessageFromCurrentFileCommentedDirective = (
 
 /**
  * Finds the `message` for the specific violation of commented directives import rules based on `commentedDirectives_BlockedImports`.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} currentFileCommentedDirective The current file's commented directive.
- * @param {CommentedDirectiveWithoutUseAgnosticStrategies} importedFileCommentedDirective The imported file's commented directive.
+ * @param {CommentedDirective} currentFileCommentedDirective The current file's commented directive.
+ * @param {CommentedDirective} importedFileCommentedDirective The imported file's commented directive.
  * @returns The corresponding `message`.
  */
 export const findSpecificViolationMessage = (

package/package.json

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