@duckdb/react-duckdb 1.13.1-dev266.0 → 1.13.1-dev267.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@duckdb/react-duckdb",
-    "version": "1.13.1-dev266.0",
+    "version": "1.13.1-dev267.0",
     "description": "React components for DuckDB-Wasm",
     "license": "MPL-2.0",
     "repository": {

package/src/database_provider.tsx

@@ -18,18 +18,11 @@ type DuckDBProps = {
 
 export const DuckDBProvider: React.FC<DuckDBProps> = (props: DuckDBProps) => {
     const logger = useDuckDBLogger();
-    const bundle = useDuckDBBundle();
     const resolveBundle = useDuckDBBundleResolver();
     const [setup, updateSetup] = React.useState<Resolvable<duckdb.AsyncDuckDB, duckdb.InstantiationProgress>>(
         new Resolvable<duckdb.AsyncDuckDB, duckdb.InstantiationProgress>(),
     );
 
-    React.useEffect(() => {
-        if (!bundle.resolving()) {
-            resolveBundle();
-        }
-    }, [bundle]);
-
     const worker = React.useRef<Worker | null>(null);
     React.useEffect(
         () => () => {
@@ -41,51 +34,50 @@ export const DuckDBProvider: React.FC<DuckDBProps> = (props: DuckDBProps) => {
         [],
     );
 
-    const lock = React.useRef<boolean>(false);
+    const inFlight = React.useRef<Promise<duckdb.AsyncDuckDB | null> | null>(null);
     const resolver = React.useCallback(async () => {
-        // Invalid input?
-        if (!logger || !bundle || bundle.value == null) return null;
-        // Is updating?
-        if (lock.current) return null;
-        lock.current = true;
+        // Run only once
+        if (inFlight.current) return await inFlight.current;
+        inFlight.current = (async () => {
+            // Resolve bundle
+            const bundle = await resolveBundle();
+            if (bundle == null) {
+                updateSetup(s => s.failWith('invalid bundle'));
+                return null;
+            }
 
-        // Create worker and next database
-        let worker: Worker;
-        let next: duckdb.AsyncDuckDB;
-        try {
-            worker = new Worker(bundle.value.mainWorker!);
-            next = new duckdb.AsyncDuckDB(logger, worker);
-        } catch (e: any) {
-            lock.current = false;
-            updateSetup(s => s.failWith(e));
-            return null;
-        }
+            // Create worker and next database
+            let worker: Worker;
+            let next: duckdb.AsyncDuckDB;
+            try {
+                worker = new Worker(bundle.mainWorker!);
+                next = new duckdb.AsyncDuckDB(logger, worker);
+            } catch (e: any) {
+                updateSetup(s => s.failWith(e));
+                return null;
+            }
 
-        // Instantiate the database asynchronously
-        try {
-            await next.instantiate(
-                bundle.value.mainModule,
-                bundle.value.pthreadWorker,
-                (p: duckdb.InstantiationProgress) => {
+            // Instantiate the database asynchronously
+            try {
+                await next.instantiate(bundle.mainModule, bundle.pthreadWorker, (p: duckdb.InstantiationProgress) => {
                     try {
                         updateSetup(s => s.updateRunning(p));
                     } catch (e: any) {
                         console.warn(`progress handler failed with error: ${e.toString()}`);
                     }
-                },
-            );
-            if (props.config !== undefined) {
-                await next.open(props.config!);
+                });
+                if (props.config !== undefined) {
+                    await next.open(props.config!);
+                }
+            } catch (e: any) {
+                updateSetup(s => s.failWith(e));
+                return null;
             }
-        } catch (e: any) {
-            lock.current = false;
-            updateSetup(s => s.failWith(e));
-            return null;
-        }
-        lock.current = false;
-        updateSetup(s => s.completeWith(next));
-        return next;
-    }, [logger, bundle]);
+            updateSetup(s => s.completeWith(next));
+            return next;
+        })();
+        return await inFlight.current;
+    }, [logger]);
 
     return (
         <resolverCtx.Provider value={resolver}>

package/src/platform_provider.tsx

@@ -18,22 +18,26 @@ export const useDuckDBBundleResolver = (): Resolver<duckdb.DuckDBBundle> => Reac
 export const DuckDBPlatform: React.FC<PlatformProps> = (props: PlatformProps) => {
     const [bundle, setBundle] = React.useState<Resolvable<duckdb.DuckDBBundle>>(new Resolvable());
 
-    const lock = React.useRef<boolean>(false);
+    const inFlight = React.useRef<Promise<duckdb.DuckDBBundle | null> | null>(null);
     const resolver = React.useCallback(async () => {
-        if (lock.current) return null;
-        lock.current = true;
-        try {
-            setBundle(b => b.updateRunning());
-            const next = await duckdb.selectBundle(props.bundles);
-            lock.current = false;
-            setBundle(b => b.completeWith(next));
-            return next;
-        } catch (e: any) {
-            lock.current = false;
-            console.error(e);
-            setBundle(b => b.failWith(e));
-            return null;
-        }
+        if (bundle.error) return null;
+        if (bundle.value) return bundle.value;
+        if (inFlight.current) return await inFlight.current;
+        inFlight.current = (async () => {
+            try {
+                setBundle(b => b.updateRunning());
+                const next = await duckdb.selectBundle(props.bundles);
+                inFlight.current = null;
+                setBundle(b => b.completeWith(next));
+                return next;
+            } catch (e: any) {
+                inFlight.current = null;
+                console.error(e);
+                setBundle(b => b.failWith(e));
+                return null;
+            }
+        })();
+        return await inFlight.current;
     }, [props.bundles]);
 
     return (