formate code

Author: oanlit

packages/solid/src/reactive/signal.ts

@@ -158,17 +158,17 @@ export function createRoot<T>(fn: RootFunction<T>, detachedOwner?: typeof Owner)
         ? { owned: null, cleanups: null, context: null, owner: null }
         : UNOWNED
       : {
-        owned: null,
-        cleanups: null,
-        context: current ? current.context : null,
-        owner: current
-      },
+          owned: null,
+          cleanups: null,
+          context: current ? current.context : null,
+          owner: current
+        },
     updateFn = unowned
       ? IS_DEV
         ? () =>
-          fn(() => {
-            throw new Error("Dispose method must be an explicit argument to createRoot function");
-          })
+            fn(() => {
+              throw new Error("Dispose method must be an explicit argument to createRoot function");
+            })
         : fn
       : () => fn(() => untrack(() => cleanNode(root)));
 
@@ -274,7 +274,7 @@ export interface BaseOptions {
 // TypeScript Discord conversation: https://discord.com/channels/508357248330760243/508357248330760249/911266491024949328
 export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
 
-export interface EffectOptions extends BaseOptions { }
+export interface EffectOptions extends BaseOptions {}
 
 // Also similar to OnEffectFunction
 export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
@@ -391,15 +391,15 @@ export function createEffect<Next, Init>(
 export function createReaction(onInvalidate: () => void, options?: EffectOptions) {
   let fn: (() => void) | undefined;
   const c = createComputation(
-    () => {
-      fn ? fn() : untrack(onInvalidate);
-      fn = undefined;
-    },
-    undefined,
-    false,
-    0,
-    IS_DEV ? options : undefined
-  ),
+      () => {
+        fn ? fn() : untrack(onInvalidate);
+        fn = undefined;
+      },
+      undefined,
+      false,
+      0,
+      IS_DEV ? options : undefined
+    ),
     s = SuspenseContext && useContext(SuspenseContext);
   if (s) c.suspense = s;
   c.user = true;
@@ -705,15 +705,15 @@ export function createResource<T, S, R>(
       initP !== NO_INIT
         ? (initP as T | Promise<T>)
         : untrack(() => {
-          try {
-            return fetcher(lookup, {
-              value: value(),
-              refetching
-            });
-          } catch (fetcherError) {
-            error = fetcherError;
-          }
-        });
+            try {
+              return fetcher(lookup, {
+                value: value(),
+                refetching
+              });
+            } catch (fetcherError) {
+              error = fetcherError;
+            }
+          });
     if (error !== undefined) {
       loadEnd(pr, undefined, castError(error), lookup);
       return;
@@ -914,8 +914,8 @@ export function untrack<T>(fn: Accessor<T>): T {
 export type ReturnTypes<T> = T extends readonly Accessor<unknown>[]
   ? { [K in keyof T]: T[K] extends Accessor<infer I> ? I : never }
   : T extends Accessor<infer I>
-  ? I
-  : never;
+    ? I
+    : never;
 
 // transforms a tuple to a tuple of accessors in a way that allows generics to be inferred
 export type AccessorArray<T> = [...Extract<{ [K in keyof T]: Accessor<T[K]> }, readonly unknown[]>];
@@ -1778,10 +1778,10 @@ function createProvider(id: symbol, options?: EffectOptions) {
     let res;
     createRenderEffect(
       () =>
-      (res = untrack(() => {
-        Owner!.context = { ...Owner!.context, [id]: props.value };
-        return children(() => props.children);
-      })),
+        (res = untrack(() => {
+          Owner!.context = { ...Owner!.context, [id]: props.value };
+          return children(() => props.children);
+        })),
       undefined,
       options
     );

packages/solid/test/signals.spec.ts

@@ -606,23 +606,23 @@ describe("catchError", () => {
   });
 
   describe("Repeatedly read the signal", () => {
-  test("Signal repeated read in for loop", () => {
-    const a = createSignal(0);
-    const dispose = createRoot(dispose => {
-      createEffect(() => {
-        for (let i = 0; i < 1000; i++) {
-          a[0]();
-        }
+    test("Signal repeated read in for loop", () => {
+      const a = createSignal(0);
+      const dispose = createRoot(dispose => {
+        createEffect(() => {
+          for (let i = 0; i < 1000; i++) {
+            a[0]();
+          }
+        });
+        return dispose;
       });
-      return dispose;
+      expect((a as any).state.observers.length).toBe(1);
+      expect((a as any).state.observerSlots.length).toBe(1);
+      expect((a as any).state.observers[0].sources.length).toBe(1);
+      expect((a as any).state.observers[0].sourceSlots.length).toBe(1);
+      dispose();
     });
-    expect((a as any).state.observers.length).toBe(1);
-    expect((a as any).state.observerSlots.length).toBe(1);
-    expect((a as any).state.observers[0].sources.length).toBe(1);
-    expect((a as any).state.observers[0].sourceSlots.length).toBe(1);
-    dispose();
   });
-});
 
   test("In nested memo", () => {
     let errored = false;