mirror of
https://github.com/lrnselfreliance/wrolpi.git
synced 2026-10-26 19:01:39 -04:00
765 lines
21 KiB
JavaScript
765 lines
21 KiB
JavaScript
import {useContext, useEffect, useRef, useState} from "react";
|
|
import {
|
|
fetchDomains,
|
|
fetchFilesProgress,
|
|
filesSearch,
|
|
getArchive,
|
|
getChannel,
|
|
getChannels,
|
|
getDirectories,
|
|
getDownloads,
|
|
getFiles,
|
|
getInventory,
|
|
getSettings,
|
|
getStatistics,
|
|
getStatus,
|
|
getThrottleStatus,
|
|
getVideo,
|
|
getVideosStatistics,
|
|
searchArchives,
|
|
searchVideos,
|
|
setHotspot,
|
|
setThrottle,
|
|
} from "../api";
|
|
import {createSearchParams, useSearchParams} from "react-router-dom";
|
|
import {enumerate, filterToMimetypes, humanFileSize, secondsToFullDuration} from "../components/Common";
|
|
import {StatusContext} from "../contexts/contexts";
|
|
import {toast} from "react-semantic-toasts-2";
|
|
|
|
const calculatePage = (offset, limit) => {
|
|
return offset && limit ? Math.round((offset / limit) + 1) : 1;
|
|
}
|
|
|
|
const calculateTotalPages = (total, limit) => {
|
|
return total && limit ? Math.round(total / limit) : 1;
|
|
}
|
|
|
|
export const useRecurringTimeout = (callback, delay) => {
|
|
const timer = useRef(null);
|
|
|
|
useEffect(() => {
|
|
const repeat = async () => {
|
|
// Recursively call the callback.
|
|
await callback();
|
|
timer.current = window.setTimeout(repeat, delay);
|
|
}
|
|
|
|
// Call the repeating function instantly to fetch data fast.
|
|
repeat();
|
|
|
|
// Clear the timeout on unload.
|
|
return () => clearTimeout(timer.current);
|
|
}, [delay])
|
|
}
|
|
|
|
export const useQuery = () => {
|
|
const [searchParams, setSearchParams] = useSearchParams();
|
|
|
|
const setQuery = (obj) => {
|
|
setSearchParams(createSearchParams(obj), {replace: true});
|
|
}
|
|
|
|
const updateQuery = (obj) => {
|
|
const newQuery = {};
|
|
for (const entry of searchParams.entries()) {
|
|
newQuery[entry[0]] = entry[1];
|
|
}
|
|
Object.entries(obj).forEach(([key, value]) => {
|
|
if (value === undefined || value === null || value === '') {
|
|
delete newQuery[key];
|
|
} else {
|
|
newQuery[key] = value;
|
|
}
|
|
})
|
|
setQuery(newQuery);
|
|
}
|
|
|
|
return {searchParams, setSearchParams, setQuery, updateQuery}
|
|
}
|
|
|
|
export const useOneQuery = (name) => {
|
|
const {searchParams, updateQuery} = useQuery();
|
|
const value = searchParams.get(name);
|
|
|
|
const setValue = (newValue) => {
|
|
updateQuery({[name]: newValue});
|
|
}
|
|
|
|
return [value, setValue]
|
|
}
|
|
|
|
export const useAllQuery = (name) => {
|
|
const {searchParams, updateQuery} = useQuery();
|
|
const value = searchParams.getAll(name);
|
|
|
|
const setValue = (newValue) => {
|
|
updateQuery({[name]: newValue});
|
|
}
|
|
|
|
return [value, setValue]
|
|
}
|
|
|
|
export const useDomains = () => {
|
|
const [domains, setDomains] = useState(null);
|
|
const [total, setTotal] = useState(null);
|
|
|
|
const _fetchDomains = async () => {
|
|
setDomains(null);
|
|
setTotal(0);
|
|
try {
|
|
let [domains, total] = await fetchDomains();
|
|
setDomains(domains);
|
|
setTotal(total);
|
|
} catch (e) {
|
|
setDomains([]);
|
|
setTotal(0);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
_fetchDomains();
|
|
}, []);
|
|
|
|
return [domains, total];
|
|
}
|
|
|
|
export const useArchive = (archiveId) => {
|
|
const [archiveFileGroup, setArchiveFileGroup] = useState(null);
|
|
const [history, setHistory] = useState(null);
|
|
|
|
const fetchArchive = async () => {
|
|
try {
|
|
const [file_group, history] = await getArchive(archiveId);
|
|
setArchiveFileGroup(file_group);
|
|
setHistory(history);
|
|
} catch (e) {
|
|
console.error(e);
|
|
setArchiveFileGroup(undefined);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
fetchArchive();
|
|
}, [archiveId]);
|
|
|
|
return {archiveFile: archiveFileGroup, history, fetchArchive};
|
|
}
|
|
|
|
export const usePages = (defaultLimit) => {
|
|
const {searchParams, updateQuery} = useQuery();
|
|
const offset = searchParams.get('o') || 0;
|
|
const limit = parseInt(searchParams.get('l') || defaultLimit || 24);
|
|
const [activePage, setActivePage] = useState(calculatePage(offset, limit));
|
|
|
|
const setLimit = (value) => {
|
|
setPage(1);
|
|
updateQuery({l: value, o: null});
|
|
}
|
|
|
|
const setPage = (value) => {
|
|
setActivePage(value);
|
|
value = value - 1; // Page really starts as 0.
|
|
updateQuery({o: value * limit});
|
|
}
|
|
|
|
return {offset, limit, setLimit, activePage, setPage};
|
|
}
|
|
|
|
export const useSearchArchives = (defaultLimit) => {
|
|
const {domain} = useSearchDomain();
|
|
const {offset, limit, setLimit, activePage, setPage} = usePages(defaultLimit);
|
|
const {searchParams, updateQuery} = useQuery();
|
|
const searchStr = searchParams.get('q') || '';
|
|
const order = searchParams.get('order');
|
|
const activeTags = searchParams.getAll('tag');
|
|
|
|
const [archives, setArchives] = useState(null);
|
|
const [totalPages, setTotalPages] = useState(0);
|
|
|
|
const localSearchArchives = async () => {
|
|
setArchives(null);
|
|
setTotalPages(0);
|
|
try {
|
|
let [archives_, total] = await searchArchives(offset, limit, domain, searchStr, order, activeTags);
|
|
setArchives(archives_);
|
|
setTotalPages(calculateTotalPages(total, limit));
|
|
} catch (e) {
|
|
console.error(e);
|
|
toast({
|
|
type: 'error',
|
|
title: 'Unexpected server response',
|
|
description: 'Could not get archives',
|
|
time: 5000,
|
|
});
|
|
setArchives([]);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
localSearchArchives();
|
|
}, [searchStr, limit, domain, order, activePage, JSON.stringify(activeTags)]);
|
|
|
|
const setSearchStr = (value) => {
|
|
updateQuery({q: value, o: 0, order: undefined});
|
|
}
|
|
|
|
const setOrderBy = (value) => {
|
|
setPage(1);
|
|
updateQuery({order: value});
|
|
}
|
|
|
|
return {
|
|
archives,
|
|
limit,
|
|
setLimit,
|
|
offset,
|
|
order,
|
|
setOrderBy,
|
|
totalPages,
|
|
activePage,
|
|
setPage,
|
|
searchStr,
|
|
setSearchStr,
|
|
fetchArchives: localSearchArchives,
|
|
}
|
|
}
|
|
|
|
export const useSearchVideos = (defaultLimit, channelId, order_by) => {
|
|
const {searchParams, updateQuery} = useQuery();
|
|
const {offset, limit, setLimit, activePage, setPage} = usePages(defaultLimit);
|
|
const searchStr = searchParams.get('q') || '';
|
|
const order = searchParams.get('order') || order_by;
|
|
const activeTags = searchParams.getAll('tag');
|
|
|
|
const [videos, setVideos] = useState();
|
|
const [totalPages, setTotalPages] = useState(0);
|
|
|
|
const localSearchVideos = async () => {
|
|
setVideos(null);
|
|
setTotalPages(0);
|
|
try {
|
|
let [videos_, total] = await searchVideos(offset, limit, channelId, searchStr, order, activeTags);
|
|
setVideos(videos_);
|
|
setTotalPages(calculateTotalPages(total, limit));
|
|
} catch (e) {
|
|
console.error(e);
|
|
toast({
|
|
type: 'error',
|
|
title: 'Unexpected server response',
|
|
description: 'Could not get videos',
|
|
time: 5000,
|
|
});
|
|
setVideos([]);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
localSearchVideos();
|
|
}, [searchStr, limit, channelId, offset, order_by, JSON.stringify(activeTags)]);
|
|
|
|
const setSearchStr = (value) => {
|
|
updateQuery({q: value, o: 0, order: undefined});
|
|
}
|
|
|
|
const setOrderBy = (value) => {
|
|
setPage(1);
|
|
updateQuery({order: value});
|
|
}
|
|
|
|
return {
|
|
videos,
|
|
totalPages,
|
|
limit,
|
|
offset,
|
|
order,
|
|
searchStr,
|
|
activePage,
|
|
setPage,
|
|
setLimit,
|
|
setSearchStr,
|
|
setOrderBy,
|
|
fetchVideos: localSearchVideos,
|
|
activeTags,
|
|
}
|
|
}
|
|
|
|
export const useVideo = (videoId) => {
|
|
const [videoFile, setVideoFile] = useState(null);
|
|
const [prevFile, setPrevFile] = useState(null);
|
|
const [nextFile, setNextFile] = useState(null);
|
|
|
|
const fetchVideo = async () => {
|
|
if (videoId && videoFile && Number(videoFile.video.id) !== Number(videoId)) {
|
|
// Video is changing. Clear the old video before fetching.
|
|
setVideoFile(null);
|
|
setPrevFile(null);
|
|
setNextFile(null);
|
|
}
|
|
try {
|
|
const [v, p, n] = await getVideo(videoId);
|
|
setVideoFile(v);
|
|
setPrevFile(p);
|
|
setNextFile(n);
|
|
} catch (e) {
|
|
console.error(e);
|
|
setVideoFile(undefined);
|
|
setPrevFile(undefined);
|
|
setNextFile(undefined);
|
|
toast({
|
|
type: 'error',
|
|
title: 'Unexpected server response',
|
|
description: 'Could not get the video',
|
|
time: 5000,
|
|
})
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
fetchVideo();
|
|
}, [videoId]);
|
|
|
|
return {videoFile, prevFile, nextFile, fetchVideo};
|
|
}
|
|
|
|
export const useChannel = (channel_id) => {
|
|
const emptyChannel = {
|
|
name: '',
|
|
directory: '',
|
|
mkdir: false,
|
|
url: '',
|
|
download_frequency: '',
|
|
match_regex: '',
|
|
};
|
|
const [fetched, setFetched] = useState(false);
|
|
const [channel, setChannel] = useState(emptyChannel);
|
|
const [original, setOriginal] = useState({});
|
|
|
|
const localGetChannel = async () => {
|
|
if (channel_id) {
|
|
try {
|
|
const c = await getChannel(channel_id);
|
|
// Prevent controlled to uncontrolled.
|
|
c['url'] = c['url'] || '';
|
|
c['download_frequency'] = c['download_frequency'] || '';
|
|
c['match_regex'] = c['match_regex'] || '';
|
|
setChannel(c);
|
|
setOriginal(c);
|
|
setFetched(true);
|
|
} catch (e) {
|
|
console.error(e);
|
|
toast({
|
|
type: 'error',
|
|
title: 'Unexpected server response',
|
|
description: 'Could not get Channel',
|
|
time: 5000,
|
|
});
|
|
}
|
|
} else {
|
|
setChannel(emptyChannel);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
localGetChannel();
|
|
}, [channel_id])
|
|
|
|
const changeValue = (name, value) => {
|
|
setChannel({...channel, [name]: value});
|
|
}
|
|
|
|
return {channel, changeValue, original, fetched, fetchChannel: localGetChannel};
|
|
}
|
|
|
|
export const useChannels = () => {
|
|
const [channels, setChannels] = useState(null);
|
|
|
|
const fetchChannels = async () => {
|
|
setChannels(null);
|
|
try {
|
|
const c = await getChannels();
|
|
setChannels(c);
|
|
} catch (e) {
|
|
console.error(e);
|
|
toast({
|
|
type: 'error',
|
|
title: 'Unexpected server response',
|
|
description: 'Could not get channels',
|
|
time: 5000,
|
|
});
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
fetchChannels();
|
|
}, []);
|
|
|
|
return {channels, fetchChannels}
|
|
}
|
|
|
|
export const useSearchFiles = (defaultLimit = 48, emptySearch = false, model) => {
|
|
const {searchParams, updateQuery} = useQuery();
|
|
const limit = searchParams.get('l') || defaultLimit;
|
|
const offset = searchParams.get('o') || 0;
|
|
const searchStr = searchParams.get('q');
|
|
const filter = searchParams.get('filter');
|
|
const model_ = searchParams.get('model');
|
|
const activeTags = searchParams.getAll('tag');
|
|
|
|
const [searchFiles, setSearchFiles] = useState(null);
|
|
const [totalPages, setTotalPages] = useState(0);
|
|
const [activePage, setActivePage] = useState(calculatePage(offset, limit));
|
|
|
|
const localSearchFiles = async () => {
|
|
if (!emptySearch && !searchStr && !activeTags) {
|
|
return;
|
|
}
|
|
const mimetypes = filterToMimetypes(filter);
|
|
setSearchFiles(null);
|
|
setTotalPages(0);
|
|
try {
|
|
let [file_groups, total] = await filesSearch(
|
|
offset, limit, searchStr, mimetypes, model || model_, activeTags);
|
|
setSearchFiles(file_groups);
|
|
setTotalPages(calculateTotalPages(total, limit));
|
|
} catch (e) {
|
|
console.error(e);
|
|
toast({
|
|
type: 'error',
|
|
title: 'Unexpected server response',
|
|
description: 'Could not get files',
|
|
time: 5000,
|
|
});
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
localSearchFiles();
|
|
}, [searchStr, limit, offset, activePage, filter, model, model_, JSON.stringify(activeTags)]);
|
|
|
|
const setPage = (i) => {
|
|
i = parseInt(i);
|
|
let l = parseInt(limit);
|
|
updateQuery({o: (l * i) - l})
|
|
setActivePage(i);
|
|
}
|
|
|
|
const setSearchStr = (value) => {
|
|
updateQuery({q: value, o: null});
|
|
}
|
|
|
|
const setLimit = (value) => {
|
|
setActivePage(1);
|
|
updateQuery({l: value, o: 0});
|
|
}
|
|
|
|
return {searchFiles, totalPages, limit, searchStr, filter, setSearchStr, activePage, setPage, setLimit, activeTags};
|
|
}
|
|
|
|
export const useBrowseFiles = () => {
|
|
const [browseFiles, setBrowseFiles] = useState(null);
|
|
const [openFolders, setOpenFolders] = useAllQuery('folders');
|
|
|
|
const fetchFiles = async () => {
|
|
try {
|
|
const files = await getFiles(openFolders);
|
|
setBrowseFiles(files);
|
|
} catch (e) {
|
|
console.log(e);
|
|
setBrowseFiles([]);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
fetchFiles();
|
|
}, [JSON.stringify(openFolders)])
|
|
|
|
return {browseFiles, openFolders, setOpenFolders, fetchFiles};
|
|
}
|
|
|
|
export const useFilesProgress = () => {
|
|
const [progress, setProgress] = useState(null);
|
|
|
|
const localFetchFilesProgress = async () => {
|
|
try {
|
|
let p = await fetchFilesProgress();
|
|
setProgress(p);
|
|
} catch (e) {
|
|
setProgress(null);
|
|
console.error(e);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
localFetchFilesProgress();
|
|
}, []);
|
|
|
|
return {progress, fetchFilesProgress: localFetchFilesProgress}
|
|
}
|
|
|
|
export const useFilesProgressInterval = () => {
|
|
const {progress, fetchFilesProgress} = useFilesProgress();
|
|
|
|
useRecurringTimeout(fetchFilesProgress, 1000 * 3);
|
|
|
|
return {progress, fetchFilesProgress};
|
|
}
|
|
|
|
export const useHotspot = () => {
|
|
const [on, setOn] = useState(null);
|
|
const {status} = useContext(StatusContext);
|
|
// Hotspot is unsupported on Docker.
|
|
const {dockerized} = status;
|
|
|
|
useEffect(() => {
|
|
if (status && status['hotspot_status']) {
|
|
const {hotspot_status} = status;
|
|
if (hotspot_status === 'connected') {
|
|
setOn(true);
|
|
} else if (hotspot_status === 'disconnected' || hotspot_status === 'unavailable') {
|
|
setOn(false);
|
|
} else {
|
|
setOn(null);
|
|
}
|
|
}
|
|
}, [status]);
|
|
|
|
const localSetHotspot = async (on) => {
|
|
setOn(null);
|
|
await setHotspot(on);
|
|
}
|
|
|
|
return {on, setOn, setHotspot: localSetHotspot, dockerized};
|
|
}
|
|
|
|
export const useDownloads = () => {
|
|
const [onceDownloads, setOnceDownloads] = useState(null);
|
|
const [recurringDownloads, setRecurringDownloads] = useState(null);
|
|
|
|
const fetchDownloads = async () => {
|
|
try {
|
|
const data = await getDownloads();
|
|
setOnceDownloads(data['once_downloads']);
|
|
setRecurringDownloads(data['recurring_downloads']);
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
|
|
useRecurringTimeout(fetchDownloads, 3 * 1000);
|
|
|
|
return {onceDownloads, recurringDownloads, fetchDownloads}
|
|
}
|
|
|
|
export const useThrottle = () => {
|
|
const [on, setOn] = useState(null);
|
|
|
|
const fetchThrottleStatus = async () => {
|
|
let status;
|
|
try {
|
|
status = await getThrottleStatus();
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
if (status === 'powersave') {
|
|
setOn(true);
|
|
} else if (status === 'ondemand') {
|
|
setOn(false);
|
|
} else {
|
|
setOn(null);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
fetchThrottleStatus();
|
|
}, []);
|
|
|
|
const localSetThrottle = async (on) => {
|
|
setOn(null);
|
|
await setThrottle(on);
|
|
await fetchThrottleStatus();
|
|
}
|
|
|
|
return {on, setOn, setThrottle: localSetThrottle};
|
|
}
|
|
|
|
export const useDirectories = (defaultDirectory) => {
|
|
const [directories, setDirectories] = useState();
|
|
const [directory, setDirectory] = useState(defaultDirectory);
|
|
const [exists, setExists] = useState();
|
|
const [isDir, setIsDir] = useState();
|
|
const [isFile, setIsFile] = useState();
|
|
|
|
const fetchDirectories = async () => {
|
|
if (defaultDirectory && directory === '') {
|
|
setDirectory(defaultDirectory);
|
|
}
|
|
try {
|
|
const {directories, is_dir, exists_, is_file} = await getDirectories(directory);
|
|
setDirectories(directories);
|
|
setIsDir(is_dir);
|
|
setExists(exists_);
|
|
setIsFile(is_file);
|
|
} catch (e) {
|
|
toast({
|
|
type: 'error',
|
|
title: 'Unexpected server response',
|
|
description: 'Could not get directories',
|
|
time: 5000,
|
|
});
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
fetchDirectories();
|
|
}, [directory, defaultDirectory]);
|
|
|
|
return {directory, directories, setDirectory, exists, isDir, isFile};
|
|
}
|
|
|
|
export const useSettings = () => {
|
|
const [settings, setSettings] = useState({});
|
|
|
|
const fetchSettings = async () => {
|
|
try {
|
|
setSettings(await getSettings())
|
|
} catch (e) {
|
|
setSettings({});
|
|
toast({
|
|
type: 'error',
|
|
title: 'Unexpected server response',
|
|
description: 'Could not get directories',
|
|
time: 5000,
|
|
});
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
fetchSettings();
|
|
}, []);
|
|
|
|
return {settings, fetchSettings};
|
|
}
|
|
|
|
export const useSettingsInterval = () => {
|
|
const {settings, fetchSettings} = useSettings();
|
|
|
|
useRecurringTimeout(fetchSettings(), 1000 * 3);
|
|
|
|
return {settings, fetchSettings};
|
|
}
|
|
|
|
export const useStatus = () => {
|
|
const [status, setStatus] = useState({});
|
|
|
|
const fetchStatus = async () => {
|
|
try {
|
|
const s = await getStatus();
|
|
setStatus(s);
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
|
|
return {status, fetchStatus}
|
|
}
|
|
|
|
export const useStatusInterval = () => {
|
|
const {status, fetchStatus} = useStatus();
|
|
|
|
useRecurringTimeout(fetchStatus, 1000 * 3);
|
|
|
|
return {status, fetchStatus};
|
|
}
|
|
|
|
|
|
export const useVideoStatistics = () => {
|
|
const [statistics, setStatistics] = useState({});
|
|
|
|
const fetchStatistics = async () => {
|
|
try {
|
|
let stats = await getVideosStatistics();
|
|
stats.videos.sum_duration = secondsToFullDuration(stats.videos.sum_duration);
|
|
stats.videos.sum_size = humanFileSize(stats.videos.sum_size);
|
|
stats.videos.max_size = humanFileSize(stats.videos.max_size);
|
|
stats.historical.average_size = humanFileSize(stats.historical.average_size);
|
|
setStatistics(stats);
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
fetchStatistics();
|
|
}, []);
|
|
|
|
return {statistics, fetchStatistics}
|
|
}
|
|
|
|
export const useInventory = (inventoryId) => {
|
|
const [byCategory, setByCategory] = useState();
|
|
const [bySubcategory, setBySubcategory] = useState();
|
|
const [byName, setByName] = useState();
|
|
|
|
const fetchInventory = async () => {
|
|
if (!inventoryId) {
|
|
return
|
|
}
|
|
|
|
try {
|
|
const inventory = await getInventory(inventoryId);
|
|
setByCategory(enumerate(inventory['by_category']));
|
|
setBySubcategory(enumerate(inventory['by_subcategory']));
|
|
setByName(enumerate(inventory['by_name']));
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
fetchInventory();
|
|
}, [inventoryId]);
|
|
|
|
return {byCategory, bySubcategory, byName, fetchInventory}
|
|
}
|
|
|
|
export const useStatistics = () => {
|
|
const [statistics, setStatistics] = useState();
|
|
|
|
const fetchFileStatistics = async () => {
|
|
try {
|
|
const s = await getStatistics();
|
|
setStatistics(s);
|
|
} catch (e) {
|
|
console.error(e);
|
|
setStatistics(undefined);
|
|
}
|
|
}
|
|
|
|
useEffect(() => {
|
|
setStatistics({});
|
|
fetchFileStatistics();
|
|
}, []);
|
|
|
|
return {statistics};
|
|
}
|
|
|
|
export const useSearchFilter = () => {
|
|
const [filter, setFilter] = useOneQuery('filter');
|
|
return {filter, setFilter}
|
|
}
|
|
|
|
export const useSearchDomain = () => {
|
|
const [domains] = useDomains();
|
|
const [domain, setDomain] = useOneQuery('domain');
|
|
return {domain, domains, setDomain}
|
|
}
|
|
|
|
export const useSearchView = () => {
|
|
const [view, setView] = useOneQuery('view');
|
|
return {view, setView}
|
|
}
|
|
|
|
export const useSearchOrder = () => {
|
|
const [order, setOrder] = useOneQuery('order');
|
|
return {sort: order, setSort: setOrder}
|
|
}
|