@peerbit/react 0.0.33 → 0.0.35

package/src/useLocal.tsx

@@ -1,125 +0,0 @@
-import { ClosedError, Documents, WithContext } from "@peerbit/document";
-import { useEffect, useRef, useState } from "react";
-import * as indexerTypes from "@peerbit/indexer-interface";
-import { debounceLeadingTrailing } from "./utils.js";
-
-type QueryLike = {
-    query?: indexerTypes.Query[] | indexerTypes.QueryLike;
-    sort?: indexerTypes.Sort[] | indexerTypes.Sort | indexerTypes.SortLike;
-};
-type QueryOptons = {
-    query: QueryLike;
-    id: string;
-};
-
-const logWithId = (
-    options: { debug?: boolean | { id: string } } | undefined,
-    ...args: any[]
-) => {
-    if (!options?.debug) return;
-
-    if (typeof options.debug === "boolean") {
-        console.log(...args);
-    } else if (typeof options.debug.id === "string") {
-        console.log(options.debug.id, ...args);
-    }
-};
-
-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 | { id: string };
-    } & QueryOptons
-) => {
-    const [all, setAll] = useState<RT[]>([]);
-    const emptyResultsRef = useRef(false);
-
-    useEffect(() => {
-        if (!db || db.closed || options?.query === null) {
-            // null query means no query at all
-            return;
-        }
-
-        logWithId(
-            options,
-            "reset local",
-            db?.closed ? undefined : db?.rootAddress,
-            options?.id,
-            options?.resolve,
-            options?.onChanges,
-            options?.transform
-        );
-
-        const _l = async (args?: any) => {
-            try {
-                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))
-                    );
-                }
-                logWithId(
-                    options,
-                    options?.id,
-                    results,
-                    "query",
-                    options?.query
-                );
-
-                emptyResultsRef.current = results.length === 0;
-                setAll(() => {
-                    options?.onChanges?.(results);
-                    return results;
-                });
-            } catch (error) {
-                if (error instanceof ClosedError) {
-                    return;
-                }
-                throw error;
-            }
-        };
-
-        const debounced = debounceLeadingTrailing(_l, options?.debounce ?? 123);
-
-        const handleChange = () => {
-            if (emptyResultsRef.current) {
-                debounced.cancel();
-                _l();
-            } else {
-                debounced();
-            }
-        };
-
-        debounced();
-        db.events.addEventListener("change", handleChange);
-
-        return () => {
-            db.events.removeEventListener("change", handleChange);
-            debounced.cancel();
-        };
-    }, [
-        db?.closed ? undefined : db?.rootAddress,
-        options?.id,
-        options?.resolve,
-        options?.onChanges,
-        options?.transform,
-    ]);
-
-    return all;
-};

package/src/useMount.tsx

@@ -1,15 +0,0 @@
-import { type EffectCallback, useEffect, useRef } from "react";
-
-export const useMount = (effect: EffectCallback) => {
-    const mounted = useRef(false);
-
-    useEffect(() => {
-        if (!mounted.current) {
-            effect();
-        }
-
-        mounted.current = true;
-
-        return () => {};
-    }, [mounted.current]);
-};

package/src/useOnline.tsx

@@ -1,85 +0,0 @@
-import { Program, OpenOptions, ProgramEvents } from "@peerbit/program";
-import { PublicSignKey } from "@peerbit/crypto";
-import { useCallback, useEffect, useMemo, 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; debug?: boolean }
-) => {
-    const [peers, setPeers] = useState<PublicSignKey[]>([]);
-
-    const log: (...args: any) => void = useCallback(() => {
-        if (!program) {
-            return (...args: any[]) => {};
-        }
-        if (options?.debug) {
-            return (...args: any[]) => {
-                console.log(
-                    `[useOnline ${options?.id ? options.id + " " : ""}${
-                        addressOrDefined(program) || "no-address"
-                    }]`,
-                    ...args
-                );
-            };
-        }
-        return () => {};
-    }, [program, options?.debug, options?.id]);
-
-    useEffect(() => {
-        if (!program || program.closed) {
-            log("No program or closed");
-            return;
-        }
-        let changeListener: () => void;
-
-        let closed = false;
-        const p = program;
-        log("Subscribing to online peers");
-        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);
-        };
-    }, [log, options?.id, addressOrDefined(program)]);
-    return {
-        peers,
-    };
-};

package/src/useProgram.tsx

@@ -1,148 +0,0 @@
-import { Program, OpenOptions, ProgramEvents } from "@peerbit/program";
-import { usePeer } from "./usePeer.js";
-import { PublicSignKey } from "@peerbit/crypto";
-import { useEffect, useReducer, useRef, useState } from "react";
-const addressOrDefined = <A, B extends ProgramEvents, P extends Program<A, B>>(
-    p?: P
-) => {
-    try {
-        return p?.address;
-    } 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 function useProgram<
-    P extends Program<ExtractArgs<P>, ExtractEvents<P>> &
-        Program<any, ProgramEvents>,
->(
-    addressOrOpen?: P | string,
-    options?: OpenOptions<P> & {
-        id?: string;
-        keepOpenOnUnmount?: boolean;
-    }
-) {
-    const { peer } = usePeer();
-    let [program, setProgram] = useState<P | undefined>();
-    const [id, setId] = useState<string | undefined>(options?.id);
-    let [loading, setLoading] = useState(true);
-    const [session, forceUpdate] = useReducer((x) => x + 1, 0);
-    let programLoadingRef = useRef<Promise<P>>(undefined);
-    const [peers, setPeers] = useState<PublicSignKey[]>([]);
-
-    let closingRef = useRef<Promise<any>>(Promise.resolve());
-    /*   if (options?.debug) {
-          console.log("useProgram", addressOrOpen, options);
-      } */
-    useEffect(() => {
-        if (!peer || !addressOrOpen) {
-            return;
-        }
-        setLoading(true);
-        let changeListener: (() => void) | undefined = undefined;
-
-        closingRef.current.then(() => {
-            programLoadingRef.current = peer
-                ?.open(addressOrOpen as P | string, {
-                    ...options,
-                    existing: "reuse",
-                })
-                .then((p: P) => {
-                    // if program has topics do change listening on peers
-                    if (
-                        [p, ...p.allPrograms].filter(
-                            (x: any) =>
-                                x.closed === false &&
-                                x.getTopics &&
-                                x.getTopics?.().length > 0
-                        ).length === 0
-                    ) {
-                        setPeers([peer.identity.publicKey]);
-                    } else {
-                        changeListener = () => {
-                            p.getReady().then(
-                                (ready: Map<string, PublicSignKey>) => {
-                                    setPeers([...ready.values()]);
-                                }
-                            );
-                        };
-                        p.events.addEventListener("join", changeListener);
-                        p.events.addEventListener("leave", changeListener);
-                        p.getReady()
-                            .then((ready: Map<string, PublicSignKey>) => {
-                                setPeers([...ready.values()]);
-                            })
-                            .catch((e: any) => {
-                                console.log("Error getReady()", e);
-                            });
-                    }
-
-                    setProgram(p);
-                    forceUpdate();
-                    if (options?.id) {
-                        setId(p.address);
-                    }
-                    return p;
-                })
-                .catch((e: unknown) => {
-                    console.error("failed to open", e);
-                    throw e;
-                })
-                .finally(() => {
-                    setLoading(false);
-                });
-        });
-
-        // TODO AbortController?
-        return () => {
-            let startRef = programLoadingRef.current;
-
-            // TODO don't close on reopen the same db?
-            if (programLoadingRef.current) {
-                closingRef.current =
-                    programLoadingRef.current.then((p) => {
-                        const unsubscribe = () => {
-                            changeListener &&
-                                p.events.removeEventListener(
-                                    "join",
-                                    changeListener
-                                );
-                            changeListener &&
-                                p.events.removeEventListener(
-                                    "leave",
-                                    changeListener
-                                );
-                        };
-
-                        if (programLoadingRef.current === startRef) {
-                            setProgram(undefined);
-                            programLoadingRef.current = undefined as any;
-                        }
-
-                        if (options?.keepOpenOnUnmount) {
-                            unsubscribe();
-                            return; // nothing to close
-                        }
-
-                        return p.close().then(unsubscribe);
-                    }) || Promise.resolve();
-            }
-        };
-    }, [
-        peer?.identity.publicKey.hashcode(),
-        options?.id,
-        typeof addressOrOpen === "string"
-            ? addressOrOpen
-            : addressOrDefined(addressOrOpen as P),
-    ]);
-    return {
-        program,
-        session,
-        loading,
-        promise: programLoadingRef.current,
-        peers,
-        id,
-    };
-}