refactor: extract flushUnused

Author: divdavem

src/index.spec.ts

@@ -32,7 +32,7 @@ import {
 } from './index';
 import { rawStoreSymbol } from './internal/exposeRawStores';
 import { RawStoreFlags } from './internal/store';
-import { flushUnused } from './internal/storeTrackingUsage';
+import { flushUnused } from './internal/asyncFlush';
 import type { RawStoreWritable } from './internal/storeWritable';
 
 const expectCorrectlyCleanedUp = <T>(store: StoreInput<T>) => {

src/internal/asyncFlush.ts

@@ -0,0 +1,43 @@
+import { RawStoreFlags } from './store';
+
+export interface Flushable {
+  flags: RawStoreFlags;
+  checkUnused(): void;
+}
+
+let flushUnusedQueue: Flushable[] | null = null;
+export let inFlushUnused = false;
+
+export const planFlush = (object: Flushable): void => {
+  if (!(object.flags & RawStoreFlags.FLUSH_PLANNED)) {
+    object.flags |= RawStoreFlags.FLUSH_PLANNED;
+    if (!flushUnusedQueue) {
+      flushUnusedQueue = [];
+      queueMicrotask(flushUnused);
+    }
+    flushUnusedQueue.push(object);
+  }
+};
+
+export const flushUnused = (): void => {
+  // Ignoring coverage for the following lines because, unless there is a bug in tansu (which would have to be fixed!)
+  // there should be no way to trigger this error.
+  /* v8 ignore next 3 */
+  if (inFlushUnused) {
+    throw new Error('assert failed: recursive flushUnused call');
+  }
+  inFlushUnused = true;
+  try {
+    const queue = flushUnusedQueue;
+    if (queue) {
+      flushUnusedQueue = null;
+      for (let i = 0, l = queue.length; i < l; i++) {
+        const producer = queue[i];
+        producer.flags &= ~RawStoreFlags.FLUSH_PLANNED;
+        producer.checkUnused();
+      }
+    }
+  } finally {
+    inFlushUnused = false;
+  }
+};

src/internal/storeTrackingUsage.ts

@@ -1,34 +1,9 @@
+import { type Flushable, inFlushUnused, planFlush } from './asyncFlush';
 import { RawStoreFlags } from './store';
 import { checkNotInNotificationPhase, RawStoreWritable } from './storeWritable';
 import { activeConsumer, untrack } from './untrack';
 
-let flushUnusedQueue: RawStoreTrackingUsage<any>[] | null = null;
-let inFlushUnused = false;
-
-export const flushUnused = (): void => {
-  // Ignoring coverage for the following lines because, unless there is a bug in tansu (which would have to be fixed!)
-  // there should be no way to trigger this error.
-  /* v8 ignore next 3 */
-  if (inFlushUnused) {
-    throw new Error('assert failed: recursive flushUnused call');
-  }
-  inFlushUnused = true;
-  try {
-    const queue = flushUnusedQueue;
-    if (queue) {
-      flushUnusedQueue = null;
-      for (let i = 0, l = queue.length; i < l; i++) {
-        const producer = queue[i];
-        producer.flags &= ~RawStoreFlags.FLUSH_PLANNED;
-        producer.checkUnused();
-      }
-    }
-  } finally {
-    inFlushUnused = false;
-  }
-};
-
-export abstract class RawStoreTrackingUsage<T> extends RawStoreWritable<T> {
+export abstract class RawStoreTrackingUsage<T> extends RawStoreWritable<T> implements Flushable {
   private extraUsages = 0;
   abstract startUse(): void;
   abstract endUse(): void;
@@ -53,13 +28,8 @@ export abstract class RawStoreTrackingUsage<T> extends RawStoreWritable<T> {
       if (inFlushUnused || flags & RawStoreFlags.HAS_VISIBLE_ONUSE) {
         this.flags &= ~RawStoreFlags.START_USE_CALLED;
         untrack(() => this.endUse());
-      } else if (!(flags & RawStoreFlags.FLUSH_PLANNED)) {
-        this.flags |= RawStoreFlags.FLUSH_PLANNED;
-        if (!flushUnusedQueue) {
-          flushUnusedQueue = [];
-          queueMicrotask(flushUnused);
-        }
-        flushUnusedQueue.push(this);
+      } else {
+        planFlush(this);
       }
     }
   }