@peerbit/react 0.0.13 → 0.0.14

package/src/lockstorage.ts

@@ -45,8 +45,13 @@ export class FastMutex {
 
     lock(
         key: string,
-        keepLocked?: () => boolean
-    ): Promise<{ restartCount: number; contentionCount; locksLost: number }> {
+        keepLocked?: () => boolean,
+        options?: { replaceIfSameClient?: boolean }
+    ): Promise<{
+        restartCount: number;
+        contentionCount: number;
+        locksLost: number;
+    }> {
         debug(
             'Attempting to acquire Lock on "%s" using FastMutex instance "%s"',
             key,
@@ -54,25 +59,47 @@ export class FastMutex {
         );
         const x = this.xPrefix + key;
         const y = this.yPrefix + key;
-        let acquireStart = +new Date();
+        let acquireStart = Date.now();
         return new Promise((resolve, reject) => {
-            // we need to differentiate between API calls to lock() and our internal
-            // recursive calls so that we can timeout based on the original lock() and
-            // not each subsequent call.  Therefore, create a new function here within
-            // the promise closure that we use for subsequent calls:
             let restartCount = 0;
             let contentionCount = 0;
             let locksLost = 0;
-            const acquireLock = (key) => {
+
+            const acquireLock = (key: string) => {
+                // If the option is set and the same client already holds both keys,
+                // update the expiry and resolve immediately.
+                if (options?.replaceIfSameClient) {
+                    const currentX = this.getItem(x);
+                    const currentY = this.getItem(y);
+                    if (
+                        currentX === this.clientId &&
+                        currentY === this.clientId
+                    ) {
+                        // Update expiry so that the lock is effectively "replaced"
+                        this.setItem(x, this.clientId, keepLocked);
+                        this.setItem(y, this.clientId, keepLocked);
+                        debug(
+                            'FastMutex client "%s" replaced its own lock on "%s".',
+                            this.clientId,
+                            key
+                        );
+                        return resolve({
+                            restartCount,
+                            contentionCount,
+                            locksLost,
+                        });
+                    }
+                }
+
+                // Check for overall retries/timeouts.
                 if (
                     restartCount > 1000 ||
                     contentionCount > 1000 ||
                     locksLost > 1000
                 ) {
-                    reject("Failed to resolve lock");
+                    return reject("Failed to resolve lock");
                 }
-
-                const elapsedTime = new Date().getTime() - acquireStart;
+                const elapsedTime = Date.now() - acquireStart;
                 if (elapsedTime >= this.timeout) {
                     debug(
                         'Lock on "%s" could not be acquired within %sms by FastMutex client "%s"',
@@ -87,43 +114,40 @@ export class FastMutex {
                     );
                 }
 
+                // First, set key X.
                 this.setItem(x, this.clientId, keepLocked);
 
-                // if y exists, another client is getting a lock, so retry in a bit
+                // Check if key Y exists (another client may be acquiring the lock)
                 let lsY = this.getItem(y);
                 if (lsY) {
                     debug("Lock exists on Y (%s), restarting...", lsY);
                     restartCount++;
-                    setTimeout(() => acquireLock(key));
+                    setTimeout(() => acquireLock(key), 10);
                     return;
                 }
 
-                // ask for inner lock
+                // Request the inner lock by setting Y.
                 this.setItem(y, this.clientId, keepLocked);
 
-                // if x was changed, another client is contending for an inner lock
+                // Re-check X; if it was changed, we have contention.
                 let lsX = this.getItem(x);
                 if (lsX !== this.clientId) {
                     contentionCount++;
                     debug('Lock contention detected. X="%s"', lsX);
-
-                    // Give enough time for critical section:
                     setTimeout(() => {
                         lsY = this.getItem(y);
                         if (lsY === this.clientId) {
-                            // we have a lock
                             debug(
                                 'FastMutex client "%s" won the lock contention on "%s"',
                                 this.clientId,
                                 key
                             );
                             resolve({
+                                restartCount,
                                 contentionCount,
                                 locksLost,
-                                restartCount,
                             });
                         } else {
-                            // we lost the lock, restart the process again
                             restartCount++;
                             locksLost++;
                             debug(
@@ -132,19 +156,19 @@ export class FastMutex {
                                 key,
                                 lsY
                             );
-                            setTimeout(() => acquireLock(key));
+                            setTimeout(() => acquireLock(key), 10);
                         }
                     }, 50);
                     return;
                 }
 
-                // no contention:
+                // No contention: lock is acquired.
                 debug(
                     'FastMutex client "%s" acquired a lock on "%s" with no contention',
                     this.clientId,
                     key
                 );
-                resolve({ contentionCount, locksLost, restartCount });
+                resolve({ restartCount, contentionCount, locksLost });
             };
 
             acquireLock(key);

package/src/useCount.tsx

@@ -0,0 +1,60 @@
+import { ClosedError, Documents, WithContext } from "@peerbit/document";
+import { useEffect, useRef, useState } from "react";
+import * as indexerTypes from "@peerbit/indexer-interface";
+import { debounceLeadingTrailing } from "./utils";
+
+type QueryOptons = {
+    query: indexerTypes.Query[] | indexerTypes.QueryLike;
+    id: string;
+};
+export const useCount = <T extends Record<string, any>>(
+    db?: Documents<T, any, any>,
+    options?: {
+        debounce?: number;
+        debug?: boolean; // add debug option here
+    } & QueryOptons
+) => {
+    const [count, setCount] = useState<number>(0);
+    const countRef = useRef<number>(0);
+
+    useEffect(() => {
+        if (!db || db.closed) {
+            return;
+        }
+
+        const _l = async (args?: any) => {
+            try {
+                const count = await db.count({
+                    query: options?.query,
+                    approximate: true,
+                });
+                countRef.current = count;
+                setCount(count);
+            } catch (error) {
+                if (error instanceof ClosedError) {
+                    return;
+                }
+                throw error;
+            }
+        };
+
+        const debounced = debounceLeadingTrailing(
+            _l,
+            options?.debounce ?? 1000
+        );
+
+        const handleChange = () => {
+            debounced();
+        };
+
+        debounced();
+        db.events.addEventListener("change", handleChange);
+
+        return () => {
+            db.events.removeEventListener("change", handleChange);
+            debounced.cancel();
+        };
+    }, [db?.closed ? undefined : db?.rootAddress, options?.id]);
+
+    return count;
+};

package/src/useLocal.tsx

@@ -1,35 +1,106 @@
-import { ClosedError, Documents, SearchRequest } from "@peerbit/document";
-import { useEffect, useState } from "react";
-export const useLocal = <T extends Record<string, any>>(
-    db?: Documents<T, any>
+import { ClosedError, Documents, WithContext } from "@peerbit/document";
+import { useEffect, useRef, useState } from "react";
+import * as indexerTypes from "@peerbit/indexer-interface";
+import { debounceLeadingTrailing } from "./utils";
+
+type QueryLike = {
+    query?: indexerTypes.Query[] | indexerTypes.QueryLike;
+    sort?: indexerTypes.Sort[] | indexerTypes.Sort | indexerTypes.SortLike;
+};
+type QueryOptons = {
+    query: QueryLike;
+    id: string;
+};
+
+export const useLocal = <
+    T extends Record<string, any>,
+    I extends Record<string, any>,
+    R extends boolean | undefined = true,
+    RT = R extends false ? WithContext<I> : WithContext<T>
+>(
+    db?: Documents<T, I>,
+    options?: {
+        resolve?: R;
+        transform?: (result: RT) => Promise<RT>;
+        onChanges?: (all: RT[]) => void;
+        debounce?: number;
+        debug?: boolean; // add debug option here
+    } & QueryOptons
 ) => {
-    const [all, setAll] = useState<T[]>([]);
+    const [all, setAll] = useState<RT[]>([]);
+    const emptyResultsRef = useRef(false);
+
     useEffect(() => {
         if (!db || db.closed) {
             return;
         }
 
-        const changeListener = async () => {
+        const _l = async (args?: any) => {
             try {
-                setAll(
-                    await db.index.search(new SearchRequest(), {
-                        local: true,
-                        remote: false,
-                    })
-                );
+                const iterator = db.index.iterate(options?.query ?? {}, {
+                    local: true,
+                    remote: false,
+                    resolve: options?.resolve as any,
+                });
+
+                let results: RT[] = (await iterator.all()) as any;
+
+                if (options?.transform) {
+                    results = await Promise.all(
+                        results.map((x) => options.transform!(x))
+                    );
+                }
+                emptyResultsRef.current = results.length === 0;
+                setAll(() => {
+                    options?.onChanges?.(results);
+                    return results;
+                });
             } catch (error) {
                 if (error instanceof ClosedError) {
-                    // ignore
                     return;
                 }
                 throw error;
             }
         };
 
-        changeListener();
-        db.events.addEventListener("change", changeListener);
+        const debounced = debounceLeadingTrailing(
+            _l,
+            options?.debounce ?? 1000
+        );
+
+        let ts = setTimeout(() => {
+            _l();
+        }, 3000);
+
+        const handleChange = () => {
+            if (emptyResultsRef.current) {
+                debounced.cancel();
+                if (options?.debug) {
+                    console.log(
+                        "Empty results detected. Bypassing debounce for immediate search."
+                    );
+                }
+                _l();
+            } else {
+                debounced();
+            }
+        };
+
+        debounced();
+        db.events.addEventListener("change", handleChange);
+
+        return () => {
+            db.events.removeEventListener("change", handleChange);
+            debounced.cancel();
+            clearTimeout(ts);
+        };
+    }, [
+        db?.closed ? undefined : db?.rootAddress,
+        options?.id,
+        options?.resolve,
+        options?.onChanges,
+        options?.transform,
+    ]);
 
-        return () => db.events.addEventListener("change", changeListener);
-    }, [db?.address, db?.closed]);
     return all;
 };

package/src/useOnline.tsx

@@ -0,0 +1,66 @@
+import { Program, OpenOptions, ProgramEvents } from "@peerbit/program";
+import { PublicSignKey } from "@peerbit/crypto";
+import { useEffect, useState } from "react";
+const addressOrDefined = <A, B extends ProgramEvents, P extends Program<A, B>>(
+    p?: P
+) => {
+    try {
+        return p?.rootAddress;
+    } catch (error) {
+        return !!p;
+    }
+};
+type ExtractArgs<T> = T extends Program<infer Args> ? Args : never;
+type ExtractEvents<T> = T extends Program<any, infer Events> ? Events : never;
+
+export const useOnline = <
+    P extends Program<ExtractArgs<P>, ExtractEvents<P>> &
+        Program<any, ProgramEvents>
+>(
+    program?: P,
+    options?: { id?: string }
+) => {
+    const [peers, setPeers] = useState<PublicSignKey[]>([]);
+
+    useEffect(() => {
+        if (!program || program.closed) {
+            return;
+        }
+        let changeListener: () => void;
+
+        let closed = false;
+        const p = program;
+        changeListener = () => {
+            p.getReady()
+                .then((set) => {
+                    setPeers([...set.values()]);
+                })
+                .catch((e) => {
+                    console.error(e, closed);
+                });
+        };
+        p.events.addEventListener("join", changeListener);
+        p.events.addEventListener("leave", changeListener);
+        p.getReady()
+            .then((set) => {
+                setPeers([...set.values()]);
+            })
+            .catch((e) => {
+                console.log("Error getReady()", {
+                    closed,
+                    pClosed: p.closed,
+                    e,
+                });
+            });
+        // TODO AbortController?
+
+        return () => {
+            closed = true;
+            p.events.removeEventListener("join", changeListener);
+            p.events.removeEventListener("leave", changeListener);
+        };
+    }, [options?.id, addressOrDefined(program)]);
+    return {
+        peers,
+    };
+};