@drskillissue/ganko 0.1.22 → 0.1.23

package/dist/eslint-plugin.cjs

@@ -11732,7 +11732,8 @@ var CONDITIONAL_MOUNT_TAGS = /* @__PURE__ */ new Set([
 ]);
 var messages16 = {
   loadingMismatch: "createResource '{{name}}' has no initialValue but uses manual loading checks ({{name}}.loading). Without initialValue, Suspense intercepts before your loading UI renders. Add initialValue to the options: createResource(fetcher, { initialValue: ... })",
-  conditionalSuspense: "createResource '{{name}}' has no initialValue and is rendered inside a conditional mount point ({{mountTag}}). This will trigger a distant Suspense boundary and unmount the entire subtree. Add initialValue to the options: createResource(fetcher, { initialValue: ... })"
+  conditionalSuspense: "createResource '{{name}}' is rendered inside a conditional mount point ({{mountTag}}) with a distant Suspense boundary. When the fetcher's Promise is pending, the SuspenseContext increment fires and unmounts the entire subtree. initialValue does NOT prevent this \u2014 it only prevents the accessor from returning undefined.",
+  missingErrorBoundary: "createResource '{{name}}' has no <ErrorBoundary> between its component and the nearest <Suspense>. When the fetcher throws (network error, 401/403/503, timeout), the error propagates to Suspense which absorbs it and stays in its fallback state permanently. Wrap the component in <ErrorBoundary fallback={...}> or catch errors inside the fetcher."
 };
 var options16 = {};
 function hasInitialValue(call) {
@@ -11775,35 +11776,92 @@ function hasLoadingRead(resourceVariable) {
   }
   return false;
 }
-function findConditionalMountAncestor(graph, componentName) {
+function resolveFetcherFunction(graph, call) {
+  const args = call.node.arguments;
+  if (args.length === 0) return null;
+  let fetcherNode;
+  if (args.length === 1) {
+    fetcherNode = args[0];
+  } else if (args.length === 2) {
+    const lastArg = args[1];
+    fetcherNode = lastArg && lastArg.type === "ObjectExpression" ? args[0] : args[1];
+  } else {
+    fetcherNode = args[1];
+  }
+  if (!fetcherNode) return null;
+  if (fetcherNode.type === "ArrowFunctionExpression" || fetcherNode.type === "FunctionExpression") {
+    return graph.functionsByNode.get(fetcherNode) ?? null;
+  }
+  if (fetcherNode.type === "Identifier") {
+    const fns = graph.functionsByName.get(fetcherNode.name);
+    if (fns && fns.length > 0) {
+      const fn = fns[0];
+      if (fn) return fn;
+    }
+  }
+  return null;
+}
+function fetcherCanThrow(graph, fn, visited) {
+  if (visited.has(fn.id)) return false;
+  visited.add(fn.id);
+  if (fn.async && fn.awaitRanges.length > 0) return true;
+  if (fn.hasThrowStatement) return true;
+  const callSites = fn.callSites;
+  for (let i = 0, len = callSites.length; i < len; i++) {
+    const callSite = callSites[i];
+    if (!callSite) continue;
+    if (!callSite.resolvedTarget) return true;
+    if (fetcherCanThrow(graph, callSite.resolvedTarget, visited)) return true;
+  }
+  return false;
+}
+function analyzeComponentBoundaries(graph, componentName) {
+  const result = {
+    conditionalMountTag: null,
+    suspenseDistance: 0,
+    lacksErrorBoundary: false
+  };
   const usages = graph.jsxByTag.get(componentName) ?? [];
+  if (usages.length === 0) return result;
   for (let i = 0, len = usages.length; i < len; i++) {
     const usage = usages[i];
     if (!usage) continue;
     let current = usage.parent;
     let conditionalTag = null;
     let componentLevels = 0;
+    let foundErrorBoundary = false;
+    let foundSuspense = false;
     while (current) {
       const tag = current.tag;
       if (tag && !current.isDomElement) {
         componentLevels++;
-        if (tag === "Suspense") {
+        if (tag === "ErrorBoundary") {
+          foundErrorBoundary = true;
+        } else if (tag === "Suspense") {
+          foundSuspense = true;
+          if (!foundErrorBoundary) {
+            result.lacksErrorBoundary = true;
+          }
           if (conditionalTag !== null && componentLevels > 1) {
-            return { tag: conditionalTag, suspenseDistance: componentLevels };
+            result.conditionalMountTag = conditionalTag;
+            result.suspenseDistance = componentLevels;
           }
-          return null;
-        }
-        if (conditionalTag === null && CONDITIONAL_MOUNT_TAGS.has(tag)) {
+          break;
+        } else if (conditionalTag === null && CONDITIONAL_MOUNT_TAGS.has(tag)) {
           conditionalTag = tag;
         }
       }
       current = current.parent;
     }
-    if (conditionalTag !== null) {
-      return { tag: conditionalTag, suspenseDistance: componentLevels };
+    if (!foundSuspense && !foundErrorBoundary) {
+      result.lacksErrorBoundary = true;
+      if (conditionalTag !== null) {
+        result.conditionalMountTag = conditionalTag;
+        result.suspenseDistance = componentLevels;
+      }
     }
   }
-  return null;
+  return result;
 }
 function getContainingComponentName(graph, call) {
   const selfComponent = graph.componentScopes.get(call.scope);
@@ -11825,7 +11883,7 @@ var resourceImplicitSuspense = defineSolidRule({
   severity: "warn",
   messages: messages16,
   meta: {
-    description: "Detect createResource without initialValue that implicitly triggers Suspense boundaries.",
+    description: "Detect createResource that implicitly triggers or permanently breaks Suspense boundaries.",
     fixable: false,
     category: "reactivity"
   },
@@ -11833,30 +11891,37 @@ var resourceImplicitSuspense = defineSolidRule({
   check(graph, emit) {
     const resourceCalls = getCallsByPrimitive(graph, "createResource");
     if (resourceCalls.length === 0) return;
+    const throwVisited = /* @__PURE__ */ new Set();
+    const boundaryCache = /* @__PURE__ */ new Map();
     for (let i = 0, len = resourceCalls.length; i < len; i++) {
       const call = resourceCalls[i];
       if (!call) continue;
-      if (hasInitialValue(call)) continue;
       const resourceName = getResourceVariableName(call);
       if (!resourceName) continue;
-      const resourceVariable = findResourceVariable(graph, resourceName);
-      if (resourceVariable && hasLoadingRead(resourceVariable)) {
-        emit(
-          createDiagnostic(
-            graph.file,
-            call.node,
-            "resource-implicit-suspense",
-            "loadingMismatch",
-            resolveMessage(messages16.loadingMismatch, { name: resourceName }),
-            "warn"
-          )
-        );
-        continue;
-      }
+      const hasInitial = hasInitialValue(call);
       const componentName = getContainingComponentName(graph, call);
+      if (!hasInitial) {
+        const resourceVariable = findResourceVariable(graph, resourceName);
+        if (resourceVariable && hasLoadingRead(resourceVariable)) {
+          emit(
+            createDiagnostic(
+              graph.file,
+              call.node,
+              "resource-implicit-suspense",
+              "loadingMismatch",
+              resolveMessage(messages16.loadingMismatch, { name: resourceName }),
+              "warn"
+            )
+          );
+        }
+      }
       if (!componentName) continue;
-      const conditional = findConditionalMountAncestor(graph, componentName);
-      if (conditional) {
+      let analysis = boundaryCache.get(componentName);
+      if (!analysis) {
+        analysis = analyzeComponentBoundaries(graph, componentName);
+        boundaryCache.set(componentName, analysis);
+      }
+      if (analysis.conditionalMountTag) {
         emit(
           createDiagnostic(
             graph.file,
@@ -11865,12 +11930,27 @@ var resourceImplicitSuspense = defineSolidRule({
             "conditionalSuspense",
             resolveMessage(messages16.conditionalSuspense, {
               name: resourceName,
-              mountTag: conditional.tag
+              mountTag: analysis.conditionalMountTag
             }),
             "error"
           )
         );
       }
+      if (analysis.lacksErrorBoundary) {
+        const fetcherFn = resolveFetcherFunction(graph, call);
+        if (fetcherFn && fetcherCanThrow(graph, fetcherFn, throwVisited)) {
+          emit(
+            createDiagnostic(
+              graph.file,
+              call.node,
+              "resource-implicit-suspense",
+              "missingErrorBoundary",
+              resolveMessage(messages16.missingErrorBoundary, { name: resourceName }),
+              "error"
+            )
+          );
+        }
+      }
     }
   }
 });