@fabriciogferreira/use-url-query 0.1.0 → 0.1.2

package/dist/combine.d.ts

@@ -0,0 +1,26 @@
+type ConfigBase = {
+    withEmpty?: boolean;
+    isOrderMatter?: boolean;
+};
+type ConfigGrouped = ConfigBase & {
+    group: true;
+};
+type ConfigUngrouped = ConfigBase & {
+    group?: false;
+};
+export declare function combinations<F, S>(arry: [F[], S[]], config: ConfigGrouped): (F | S)[][][];
+export declare function combinations<F, S>(arry: [F[], S[]], config?: ConfigUngrouped): (F | S)[][];
+type configPowerSet = {
+    removeEmpty?: boolean;
+    withSizes?: number | Array<number> | {
+        min: number;
+        max: number;
+    } | {
+        min: number;
+    } | {
+        max: number;
+    };
+    isOrderMatter?: boolean;
+};
+export declare function powerSet<T>(array: T[], config?: configPowerSet): T[][];
+export {};

package/dist/combine.js

@@ -0,0 +1,71 @@
+export function combinations(arry, config) {
+    const results = [];
+    const first = arry[0];
+    const second = arry[1];
+    first.forEach(fItem => {
+        const groped = [];
+        second.forEach(sItem => {
+            if (config?.isOrderMatter) {
+                groped.push([sItem, fItem]);
+            }
+            groped.push([fItem, sItem]);
+        });
+        if (config?.group) {
+            results.push(groped);
+        }
+        else {
+            results.push(...groped);
+        }
+    });
+    if (config?.withEmpty) {
+        results.push([]);
+    }
+    return results;
+}
+export function powerSet(array, config) {
+    let results = [[]];
+    if (config?.isOrderMatter) {
+        for (const item of array) {
+            const snapshot = [...results];
+            for (const subset of snapshot) {
+                for (let i = 0; i <= subset.length; i++) {
+                    const copy = [...subset];
+                    copy.splice(i, 0, item);
+                    results.push(copy);
+                }
+            }
+        }
+    }
+    else {
+        array.forEach(item => {
+            const length = results.length;
+            for (let i = 0; i < length; i++) {
+                results.push([...results[i], item]);
+            }
+        });
+    }
+    if (config?.removeEmpty) {
+        results.shift();
+    }
+    if (config?.withSizes !== undefined) {
+        const withSizes = config.withSizes;
+        if (typeof withSizes === 'number') {
+            results = results.filter(item => item.length === withSizes);
+        }
+        else if (Array.isArray(withSizes)) {
+            results = results.filter(item => withSizes.includes(item.length));
+        }
+        else if (typeof withSizes === 'object') {
+            if ('min' in withSizes && 'max' in withSizes) {
+                results = results.filter(item => item.length >= withSizes.min && item.length <= withSizes.max);
+            }
+            else if ('min' in withSizes) {
+                results = results.filter(item => item.length >= withSizes.min);
+            }
+            else {
+                results = results.filter(item => item.length <= withSizes.max);
+            }
+        }
+    }
+    return results;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { useUrlQuery, Sort, } from './use-url-query';

package/dist/index.js

@@ -0,0 +1 @@
+export { useUrlQuery, } from './use-url-query';

package/dist/use-url-query.d.ts

@@ -0,0 +1,74 @@
+import { SchemaToQueryStringConfig } from "@fabriciogferreira/schema-to-query-string";
+import { SingleParserBuilder } from 'nuqs';
+type InferParser<P> = P extends SingleParserBuilder<infer T> ? T : number;
+type FiltersFromConfig<C extends FiltersConfig> = {
+    [K in keyof C]?: InferParser<C[K]>;
+};
+type FiltersConfig = Record<string, SingleParserBuilder<any>>;
+type Params<S extends FiltersConfig> = {
+    sorts?: SortParam;
+    normalizeFromUrl?: boolean;
+    filters?: S;
+    schemaToQueryString?: SchemaToQueryStringConfig;
+    filterParamAs?: string;
+    includeParamAs?: string;
+    sortParamAs?: string;
+};
+type Direction = '-' | '';
+export type Sort = {
+    column: string;
+    label: string;
+    direction: Direction;
+    include: boolean;
+};
+export type SortParam = Pick<Sort, 'column' | 'label'>[] | Sort['column'][];
+type AddFilter<C extends FiltersConfig> = <K extends keyof C>(key: K, value: InferParser<C[K]> | null) => void;
+type RemoveFilter<C extends FiltersConfig> = <K extends keyof C>(key: K, value: InferParser<C[K]> | null) => void;
+type AddFilterDebounced<C extends FiltersConfig> = <K extends keyof C>(key: K, value: InferParser<C[K]> | null, timeout?: number) => void;
+type AddInclude = (includes: string | string[]) => void;
+type RemoveInclude = (includes: string | string[]) => void;
+type Page = number | null;
+type RemovePage = () => void;
+type PerPage = number | null;
+type RemovePerPage = () => void;
+type HasSort = (column: string) => boolean | undefined;
+type IsSortAsc = (column: string) => boolean | void;
+type IsSortDesc = (column: string) => boolean | void;
+type MoveSortUp = (column: string) => void;
+type MoveSortDown = (column: string) => void;
+type ToggleSort = (column: string) => void;
+type ToggleSortDirection = (column: string) => void;
+export declare function useUrlQuery<T extends FiltersConfig>({ normalizeFromUrl, schemaToQueryString, sorts: allowedSorts, filters: allowedFilters, filterParamAs: filterParam, includeParamAs: includeParam, sortParamAs: sortParam, }?: Params<T>): {
+    filters: FiltersFromConfig<T>;
+    filtersQueryString: string;
+    addFilter: AddFilter<T>;
+    removeFilter: RemoveFilter<T>;
+    addFilterDebounced: AddFilterDebounced<T>;
+    includes: string[];
+    includeString: string;
+    includeQueryString: string;
+    addInclude: AddInclude;
+    removeInclude: RemoveInclude;
+    page: Page;
+    pageString: string;
+    pageQueryString: string;
+    removePage: RemovePage;
+    setPage: import("react").Dispatch<import("react").SetStateAction<Page>>;
+    perPage: PerPage;
+    perPageString: string;
+    perPageQueryString: string;
+    removePerPage: RemovePerPage;
+    setPerPage: import("react").Dispatch<import("react").SetStateAction<PerPage>>;
+    sorts: Sort[];
+    sortString: string;
+    sortQueryString: string;
+    hasSort: HasSort;
+    isSortAsc: IsSortAsc;
+    isSortDesc: IsSortDesc;
+    moveSortUp: MoveSortUp;
+    moveSortDown: MoveSortDown;
+    toggleSort: ToggleSort;
+    toggleSortDirection: ToggleSortDirection;
+    queryString: string;
+};
+export {};

package/dist/use-url-query.js

@@ -0,0 +1,285 @@
+import { useMemo, useState, useEffect, useRef } from "react";
+import { useRouter } from 'next/router';
+import { useSearchParams } from "next/navigation";
+import { schemaToQueryString as fnSchemaToQueryString } from "@fabriciogferreira/schema-to-query-string";
+//QUERY STRING
+export function useUrlQuery({ normalizeFromUrl = true, schemaToQueryString, sorts: allowedSorts = [], filters: allowedFilters, filterParamAs: filterParam = 'filter', includeParamAs: includeParam = 'include', sortParamAs: sortParam = 'sort', } = {}) {
+    const router = useRouter();
+    const filterDebouncedTimeoutId = useRef(undefined);
+    const [filters, setFilters] = useState({});
+    const filtersQueryString = useMemo(() => {
+        if (allowedFilters === undefined)
+            return '';
+        return Object.entries(allowedFilters)
+            .filter(([key]) => filters[key])
+            .map(([key, value]) => {
+            return filterParam + `[${key}]=${value.serialize(filters[key])}`;
+        })
+            .join('&');
+    }, [filters, allowedFilters]);
+    const addFilter = (column, value) => {
+        setFilters(prevFilters => ({
+            ...prevFilters,
+            [column]: value
+        }));
+    };
+    const removeFilter = (column) => {
+        setFilters(prevFilters => {
+            const newFilters = { ...prevFilters };
+            delete newFilters[column];
+            return newFilters;
+        });
+    };
+    const addFilterDebounced = (column, value, timeout = 300) => {
+        clearTimeout(filterDebouncedTimeoutId.current);
+        filterDebouncedTimeoutId.current = setTimeout(() => {
+            addFilter(column, value);
+        }, timeout);
+    };
+    //INCLUDE
+    const [includes, setIncludes] = useState([]);
+    const includeString = useMemo(() => {
+        return includes.join(',');
+    }, [includes]);
+    const includeQueryString = useMemo(() => {
+        return includeString ? includeParam + '=' + includeString : '';
+    }, [includeString]);
+    const addInclude = (includes) => {
+        const newIncludes = Array.isArray(includes) ? includes : [includes];
+        setIncludes(newIncludes);
+    };
+    const removeInclude = (includesParam) => {
+        const removeIncludes = Array.isArray(includesParam) ? includesParam : [includesParam];
+        const newIncludes = includes.filter(inc => !removeIncludes.includes(inc));
+        setIncludes(newIncludes);
+    };
+    //PAGE
+    const [page, setPage] = useState(null);
+    const pageString = useMemo(() => {
+        return page ? page.toString() : '';
+    }, [page]);
+    const pageQueryString = useMemo(() => {
+        return pageString ? 'page=' + pageString : '';
+    }, [pageString]);
+    const removePage = () => {
+        setPage(null);
+    };
+    //PER PAGE
+    const [perPage, setPerPage] = useState(null);
+    const perPageString = useMemo(() => {
+        return perPage ? perPage.toString() : '';
+    }, [perPage]);
+    const perPageQueryString = useMemo(() => {
+        return perPageString ? 'perPage=' + perPageString : '';
+    }, [perPageString]);
+    const removePerPage = () => {
+        setPerPage(null);
+    };
+    //SORT
+    const normalizedSorts = allowedSorts.map(allowedSort => {
+        const restItem = typeof allowedSort === 'string'
+            ? { column: allowedSort, label: allowedSort }
+            : allowedSort;
+        return {
+            ...restItem,
+            direction: '',
+            include: false
+        };
+    });
+    const [sorts, setSorts] = useState(normalizedSorts);
+    const sortString = useMemo(() => {
+        return sorts.filter(sort => sort.include)
+            .map(sort => sort.direction + sort.column)
+            .join(',');
+    }, [sorts]);
+    const sortQueryString = useMemo(() => {
+        return sortString ? sortParam + '=' + sortString : '';
+    }, [sortString]);
+    const findSort = (column) => {
+        return sorts.find(sort => sort.column === column);
+    };
+    const hasSort = (column) => {
+        return findSort(column) !== undefined;
+    };
+    const isSortAscOrDesc = (column, direction) => {
+        const sort = findSort(column);
+        if (sort === undefined)
+            return sort;
+        return sort.direction === direction;
+    };
+    const isSortAsc = (column) => {
+        return isSortAscOrDesc(column, '');
+    };
+    const isSortDesc = (column) => {
+        return isSortAscOrDesc(column, '-');
+    };
+    const moveSortUp = (column) => {
+        let index = sorts.findIndex(sort => sort.column === column);
+        if (index <= 0)
+            return;
+        const newSorts = [...sorts];
+        if (index >= 1) {
+            const from = index;
+            const to = index - 1;
+            [newSorts[from], newSorts[to]] = [newSorts[to], newSorts[from]];
+            index = to;
+        }
+        setSorts(newSorts);
+    };
+    const moveSortDown = (column) => {
+        let index = sorts.findIndex(sort => sort.column === column);
+        if (index < 0 || index === sorts.length - 1)
+            return;
+        const newSorts = [...sorts];
+        if (index < sorts.length - 1) {
+            const from = index;
+            const to = index + 1;
+            [newSorts[from], newSorts[to]] = [newSorts[to], newSorts[from]];
+            index = to;
+        }
+        setSorts(newSorts);
+    };
+    const toggleSort = (column) => {
+        const index = sorts.findIndex(sort => sort.column === column);
+        if (index === -1)
+            return;
+        const newSorts = [...sorts];
+        newSorts[index].include = !newSorts[index].include;
+        setSorts(newSorts);
+    };
+    const toggleSortDirection = (column) => {
+        const index = sorts.findIndex(s => s.column === column);
+        if (index === -1)
+            return;
+        const newSorts = [...sorts];
+        newSorts[index].direction = newSorts[index].direction === '' ? '-' : '';
+        setSorts(newSorts);
+    };
+    // function sortToEnd() { };
+    // function sortToBegin() { };
+    // function swapSorts() { };
+    // function moveSortTo() { };
+    // function disableSort() { };
+    // function enableSort() { }
+    // function disableSorts() { };
+    // function enableSorts() { }
+    //QUERY STRING
+    let schemaConverted = '';
+    if (schemaToQueryString) {
+        const { string: resultSchemaConverted, } = fnSchemaToQueryString(schemaToQueryString.schema, schemaToQueryString.rootResource, schemaToQueryString.includeKey, schemaToQueryString.fieldsKey);
+        schemaConverted = resultSchemaConverted;
+    }
+    const queryString = useMemo(() => {
+        const parts = [filtersQueryString, sortQueryString, includeQueryString, pageQueryString, perPageQueryString, schemaConverted].filter(Boolean);
+        return parts.length ? '?' + parts.join('&') : '';
+    }, [filtersQueryString, sortQueryString, includeQueryString, pageQueryString, perPageQueryString]);
+    useEffect(() => {
+        router.push(queryString);
+    }, [queryString, router]);
+    //LIFECYCLE
+    useEffect(() => {
+        if (!normalizeFromUrl)
+            return;
+        const searchParams = useSearchParams();
+        if (searchParams == undefined)
+            return;
+        const newFilters = {};
+        for (const key in allowedFilters) {
+            const paramValue = searchParams.get(filterParam + `[${key}]`);
+            const parser = allowedFilters[key];
+            //TODO: test what happens if paramValue is null, because parser.parse(null) non accepts null
+            if (paramValue === null) {
+                continue;
+            }
+            const filterValue = parser.parse(paramValue);
+            newFilters[key] = filterValue;
+        }
+        const newSorts = [...sorts];
+        searchParams.forEach((value, key) => {
+            const sortMatch = key.match(`^${sortParam}$`);
+            if (sortMatch) {
+                const sortings = value.split(',');
+                const orderingMap = new Map();
+                sortings.forEach((sorting, index) => {
+                    const column = sorting.replace(/^-/, '');
+                    const newSortIndex = newSorts.findIndex(newSort => newSort.column === column);
+                    if (newSortIndex < 0)
+                        return;
+                    orderingMap.set(column, index);
+                    if (sorting.startsWith('-')) {
+                        newSorts[newSortIndex].direction = '-';
+                    }
+                    newSorts[newSortIndex].include = true;
+                });
+                newSorts.sort((a, b) => {
+                    const aIndex = orderingMap.get(a.column);
+                    const bIndex = orderingMap.get(b.column);
+                    if (aIndex === undefined && bIndex === undefined)
+                        return 0;
+                    if (aIndex === undefined)
+                        return 1;
+                    if (bIndex === undefined)
+                        return -1;
+                    return aIndex - bIndex;
+                });
+                return;
+            }
+        });
+        setFilters(newFilters);
+        setSorts(newSorts);
+    }, [normalizeFromUrl]);
+    return {
+        //FIELDS
+        // fields
+        // fieldsString
+        // fieldsQueryString
+        // addField,
+        // removeField,
+        // toggleField,
+        //FILTER
+        filters,
+        filtersQueryString,
+        addFilter,
+        removeFilter,
+        addFilterDebounced,
+        //INCLUDE
+        includes,
+        includeString,
+        includeQueryString,
+        addInclude,
+        removeInclude,
+        //PAGE
+        page,
+        pageString,
+        pageQueryString,
+        removePage,
+        setPage,
+        //PER PAGE
+        perPage,
+        perPageString,
+        perPageQueryString,
+        removePerPage,
+        setPerPage,
+        //SORT
+        sorts,
+        sortString,
+        sortQueryString,
+        hasSort,
+        isSortAsc,
+        isSortDesc,
+        moveSortUp,
+        moveSortDown,
+        toggleSort,
+        toggleSortDirection,
+        // sortToEnd,
+        // sortToBegin,
+        // swapSorts,
+        // moveSortTo,
+        // disableSort,
+        // enableSort,
+        // disableSorts,
+        // enableSorts,
+        //QUERY STRING
+        queryString,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@fabriciogferreira/use-url-query",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"publishConfig": {
 		"access": "public"
 	},