replace loading with _loading to avoid variable conflicts and restructure resource handling logic

Author: dennev

.changeset/happy-sites-count.md

@@ -0,0 +1,6 @@
+---
+"solid-js": patch
+---
+
+- Handle promise resolution in `createResource` with improved inspection and serialization logic
+- Fixed the issue with promise return value in Synchronous Functions in SSR.

.changeset/moody-clowns-vanish.md

@@ -0,0 +1,5 @@
+---
+"solid-js": patch
+---
+
+rename `loading` to `_loading`, refactor resource preparation logic and simplify promise handling

packages/solid/src/server/rendering.ts

@@ -367,13 +367,13 @@ export function ErrorBoundary(props: {
 export interface Resource<T> {
   (): T | undefined;
   state: "unresolved" | "pending" | "ready" | "refreshing" | "errored";
-  loading: boolean;
+  _loading: boolean;
   error: any;
   latest: T | undefined;
 }
 
 type SuspenseContextType = {
-  resources: Map<string, { loading: boolean; error: any }>;
+  resources: Map<string, { _loading: boolean; error: any }>;
   completed: () => void;
 };
 
@@ -435,7 +435,6 @@ export function createResource<T, S>(
     fetcher = source as ResourceFetcher<S, T>;
     source = true as ResourceSource<S>;
   }
-
   const contexts = new Set<SuspenseContextType>();
   const id = sharedConfig.getNextContextId();
   let resource: { ref?: any; data?: T } = {};
@@ -450,34 +449,48 @@ export function createResource<T, S>(
       return resource.ref;
     }
   }
-  const read = () => {
+  const prepareResource = () => {
     if (error) throw error;
     const resolved =
       options.ssrLoadFrom !== "initial" &&
       sharedConfig.context!.async &&
       "data" in sharedConfig.context!.resources[id];
     if (!resolved && resourceContext) resourceContext.push(id);
-    if (!resolved && read.loading) {
+    if (!resolved && read._loading) {
       const ctx = useContext(SuspenseContext);
       if (ctx) {
         ctx.resources.set(id, read);
         contexts.add(ctx);
       }
     }
-    return resolved ? sharedConfig.context!.resources[id].data : value;
+    return resolved;
+  };
+  const read = () => {
+    return prepareResource() ? sharedConfig.context!.resources[id].data : value;
   };
-  read.loading = false;
+  const loading = () => {
+    prepareResource();
+    return read._loading;
+  };
+  read._loading = false;
   read.error = undefined as any;
   read.state = "initialValue" in options ? "ready" : "unresolved";
-  Object.defineProperty(read, "latest", {
-    get() {
-      return read();
+  Object.defineProperties(read, {
+    latest: {
+      get() {
+        return read();
+      }
+    },
+    loading: {
+      get() {
+        return loading();
+      }
     }
   });
   function load() {
     const ctx = sharedConfig.context!;
     if (!ctx.async)
-      return (read.loading = !!(typeof source === "function" ? (source as () => S)() : source));
+      return (read._loading = !!(typeof source === "function" ? (source as () => S)() : source));
     if (ctx.resources && id in ctx.resources && "data" in ctx.resources[id]) {
       value = ctx.resources[id].data;
       return;
@@ -495,19 +508,19 @@ export function createResource<T, S>(
       p = (fetcher as ResourceFetcher<S, T>)(lookup, { value });
     }
     if (p != undefined && typeof p === "object" && "then" in p) {
-      read.loading = true;
+      read._loading = true;
       read.state = "pending";
       p = p
         .then(res => {
-          read.loading = false;
+          read._loading = false;
           read.state = "ready";
           ctx.resources[id].data = res;
           p = null;
           notifySuspense(contexts);
           return res;
         })
         .catch(err => {
-          read.loading = false;
+          read._loading = false;
           read.state = "errored";
           read.error = error = castError(err);
           p = null;
@@ -550,15 +563,15 @@ export function lazy<T extends Component<any>>(
     else load(id);
     if (p.resolved) return p.resolved(props);
     const ctx = useContext(SuspenseContext);
-    const track = { loading: true, error: undefined };
+    const track = { _loading: true, error: undefined };
     if (ctx) {
       ctx.resources.set(id, track);
       contexts.add(ctx);
     }
     if (sharedConfig.context!.async) {
       sharedConfig.context!.block(
         p.then(() => {
-          track.loading = false;
+          track._loading = false;
           notifySuspense(contexts);
         })
       );
@@ -571,7 +584,7 @@ export function lazy<T extends Component<any>>(
 
 function suspenseComplete(c: SuspenseContextType) {
   for (const r of c.resources.values()) {
-    if (r.loading) return false;
+    if (r._loading) return false;
   }
   return true;
 }
@@ -642,7 +655,7 @@ export function Suspense(props: { fallback?: string; children: string }) {
   const value: SuspenseContextType =
     ctx.suspense[id] ||
     (ctx.suspense[id] = {
-      resources: new Map<string, { loading: boolean; error: any }>(),
+      resources: new Map<string, { _loading: boolean; error: any }>(),
       completed: () => {
         const res = runSuspense();
         if (suspenseComplete(value)) {