@hydevs/hypb/dist/hooks/useRecordWhere.js

<img src="https://github.com/Hydevs-Corp/Hypb/blob/9308ab4c17196e5c0083c983a528326fd2cba867/.github/assets/banner.png" alt="usehooks-ts banner" align="center" />

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { useEffect, useState } from 'react';
import { toFilters } from '../functions';
import { Hypb } from '../functions/pocketbase';
import { unsubcribe } from '../functions/unsubcribe';
export function useRecordWhere(collection, filter, params = {
    defaultValue: undefined,
    resetOnNotFound: false,
}) {
    const [record, setRecord] = useState(params.defaultValue);
    const [loading, setLoading] = useState(true);
    const [currentFilter, setCurrentFilter] = useState(filter);
    const getList = (action) => __awaiter(this, void 0, void 0, function* () {
        setLoading(true);
        let newFilter = currentFilter;
        switch (action === null || action === void 0 ? void 0 : action.mode) {
            case 'add':
                newFilter =
                    typeof currentFilter === 'string' || !currentFilter
                        ? action.filters
                        : [
                            ...currentFilter.filter((filter) => {
                                return !action.filters.some((f) => f.left === filter.left && f.operator === filter.operator);
                            }),
                            ...action.filters,
                        ];
                break;
            case 'replace':
                newFilter = action.filters;
                break;
            case 'reset':
                newFilter = filter;
                break;
        }
        setCurrentFilter(newFilter);
        const computedFilter = typeof newFilter === 'string' ? newFilter : toFilters(newFilter);
        if (computedFilter) {
            try {
                const list = yield Hypb.pb
                    .collection(collection)
                    .getFirstListItem(computedFilter, params.queryParams);
                setRecord(list);
            }
            catch (e) {
                params.resetOnNotFound &&
                    setRecord(params.defaultValue);
                if (params.onNotFound) {
                    if (yield params.onNotFound())
                        yield getList();
                }
            }
            setLoading(false);
        }
        else {
            setLoading(false);
        }
    });
    useEffect(() => {
        getList();
    }, []);
    const [deleted, isDeleted] = useState(false);
    useEffect(() => {
        let unsub;
        if (params.realtime && record && record.id)
            unsub = Hypb.pb
                .collection(collection)
                .subscribe(record.id, (e) => {
                if (e.action === 'update')
                    setRecord(e.record);
                if (e.action === 'delete') {
                    isDeleted(true);
                }
            });
        return () => {
            unsubcribe(unsub);
        };
    }, [record === null || record === void 0 ? void 0 : record.id]);
    return { record, invalidate: getList, loading, deleted };
}