wrolpi/app/src/hooks/customHooks.js
lrnselfreliance 306386e801
app: Flasher saved configs and Statistics distinguish pending from empty (#733)
The Flasher's saved configurations started as [] with no loading
flag, and the Saved Firmwares tab is the default tab, so every load
painted "No saved configurations yet." until the fetch returned.  The
api helper returned [] on a non-OK response too, so a failed fetch
read as an empty list.

useStatistics used useState() with no initial value, so the
Statistics page's first render saw undefined and flashed "Failed to
fetch statistics" for one frame before the effect set {} and the
spinner appeared.

Invariants now enforced and tested:
* null = pending, undefined = fetch failed, [] / object = loaded.  The
  api helper returns undefined (and toasts) on a non-OK response.
* The Saved Firmwares tab shows a placeholder while pending, an error
  on failure, and "No saved configurations yet." only once the server
  confirmed there are none.  Only the newest configs request may write
  state, since save and delete refetch.
* The Statistics page shows its loader while pending and its error
  only for a failed fetch.

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-26 17:05:02 -06:00

2181 lines
71 KiB
JavaScript

import React, {useCallback, useContext, useEffect, useRef, useState} from "react";
import {
ApiDownError,
createChannel,
fetchChannels,
fetchDecoded,
fetchAuthors,
fetchDomains,
fetchSubjects,
filesSearch,
getArchive,
getDoc,
getArchiveStatistics,
getChannel,
getConfigs,
getDomain,
getDownloads,
getFiles,
getInventories,
createInventory,
saveInventory,
deleteInventory,
getCatalog,
saveCatalog,
getOutdatedZims,
getSettings,
getStatistics,
getStatus,
getVideo,
getVideoCaptions,
getVideoComments,
getVideoDescription,
getVideosStatistics,
postDumpConfig,
postImportConfig,
saveSettings,
searchArchives,
searchChannels,
searchDirectories,
searchDocs,
searchVideos,
searchZim,
updateChannel,
updateDomain,
} from "../api";
import {
unblockBluetooth,
blockBluetooth,
startHotspot,
stopHotspot,
startDesktop,
stopDesktop,
startVnc,
stopVnc,
enableThrottle,
disableThrottle,
getControllerStats,
} from "../api/controller";
import {createSearchParams, useLocation, useSearchParams} from "react-router";
import {enumerate, filterToMimetypes, humanFileSize, secondsToFullDuration} from "../components/Common";
import {QueryContext, SettingsContext, StatusContext} from "../contexts/contexts";
import {toast} from "../components/ui";
import {useSearch} from "../components/Search";
import _ from "lodash";
import {TagsSelector} from "../Tags";
import {useForm} from "./useForm";
export const useIsTouchDevice = () => {
// Detects if the device has a coarse pointer (touch screen).
// Used to disable drag selection on mobile devices.
// Initialize synchronously to avoid race conditions with dependent hooks.
const [isTouchDevice, setIsTouchDevice] = useState(() => {
if (typeof window !== 'undefined') {
return window.matchMedia('(pointer: coarse)').matches;
}
return false;
});
useEffect(() => {
const touchQuery = window.matchMedia('(pointer: coarse)');
const handleChange = (e) => setIsTouchDevice(e.matches);
touchQuery.addEventListener('change', handleChange);
return () => touchQuery.removeEventListener('change', handleChange);
}, []);
return isTouchDevice;
};
export const useElementWidth = () => {
// Tracks the rendered width (in pixels) of an element. Returns a callback ref to attach to the element
// and its current width. Uses a callback ref (not a plain ref) so it re-attaches if the element mounts
// later (e.g. after data loads), and a ResizeObserver so the width updates as the container/viewport changes.
const [width, setWidth] = useState(0);
const observer = useRef(null);
const ref = useCallback((node) => {
if (observer.current) {
observer.current.disconnect();
observer.current = null;
}
if (node && typeof ResizeObserver === 'function') {
setWidth(node.offsetWidth);
observer.current = new ResizeObserver(() => setWidth(node.offsetWidth));
observer.current.observe(node);
}
}, []);
return [ref, width];
};
export const usePlatformModifier = () => {
// Detects if the user is on macOS to display the correct keyboard shortcut modifier.
const [isMac, setIsMac] = useState(false);
useEffect(() => {
// Modern API (Chrome 90+)
if (navigator.userAgentData?.platform) {
setIsMac(navigator.userAgentData.platform === 'macOS');
} else {
// Fallback for older browsers
setIsMac(/Mac|iPhone|iPad|iPod/.test(navigator.platform));
}
}, []);
return {
isMac,
modifierKey: isMac ? '\u2318' : 'Ctrl',
modifierKeyLong: isMac ? 'Cmd' : 'Ctrl',
};
};
export const useKeyboardDetected = () => {
// Detects if a hardware keyboard is present by listening for key presses.
// On desktop devices, returns true immediately.
// On touch devices (iPad with Bluetooth keyboard), returns true after the first key press
// outside of input fields. This allows showing keyboard shortcuts to iPad users with
// external keyboards while hiding them for pure touch users.
const [keyboardDetected, setKeyboardDetected] = useState(false);
const isTouchDevice = useIsTouchDevice();
useEffect(() => {
// Desktop devices always have a keyboard.
if (!isTouchDevice) {
setKeyboardDetected(true);
return;
}
const handleKeyDown = (e) => {
// A key press outside of input fields indicates a hardware keyboard is connected.
if (!e.target.matches('input, textarea, [contenteditable]')) {
setKeyboardDetected(true);
document.removeEventListener('keydown', handleKeyDown);
}
};
document.addEventListener('keydown', handleKeyDown);
return () => document.removeEventListener('keydown', handleKeyDown);
}, [isTouchDevice]);
return keyboardDetected;
};
const calculatePage = (offset, limit) => {
return offset && limit ? Math.round((offset / limit) + 1) : 1;
}
const calculateTotalPages = (total, limit) => {
// Return the total divided by the limit, but always at least 1.
if (!total || !limit || total < limit) {
return 1;
}
return Math.ceil(total / limit);
}
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 useLatestRequest = (delay = 300, defaultLoading = false) => {
// A hook which ignores older requests and will only set `data` to the latest response's data.
// usage: sendRequest(async () => await yourAPICall(...args));
//
// Invariants:
// * `loading` is true from the moment `sendRequest` is called until the latest request settles,
// including the debounce delay. Consumers use `loading` to choose between a spinner and an
// empty state, so it must never be false while a request is pending.
// * Only the latest request may write `data` or clear `loading`. A stale request that settles
// late (resolve or reject) is ignored.
// The results from awaiting `fetchFunction`.
const [data, setData] = React.useState(null);
const latestRequestRef = React.useRef(0);
const debounceTimerRef = React.useRef(null);
// Loading while awaiting.
const [loading, setLoading] = React.useState(defaultLoading);
const sendRequest = React.useCallback((fetchFunction) => {
if (debounceTimerRef.current) {
clearTimeout(debounceTimerRef.current);
}
// Claim the latest id now, not when the debounce fires, so an earlier fetch that is still
// in flight is already stale and cannot write `data` or clear `loading` while this
// request is pending.
const requestId = ++latestRequestRef.current;
// Report the pending request before the debounce so the caller never shows "no results"
// for a search that has not run yet.
setLoading(true);
debounceTimerRef.current = setTimeout(async () => {
debounceTimerRef.current = null;
try {
const result = await fetchFunction();
if (requestId === latestRequestRef.current) {
setData(result);
}
} catch (error) {
console.error('Request failed:', error);
if (requestId === latestRequestRef.current) {
setData(null);
}
} finally {
if (requestId === latestRequestRef.current) {
setLoading(false);
}
}
}, delay);
}, [delay]);
// Do not fire a debounced request after the caller has unmounted, and treat any fetch still in
// flight as stale so it does not set state on the unmounted hook.
React.useEffect(() => {
return () => {
if (debounceTimerRef.current) {
clearTimeout(debounceTimerRef.current);
debounceTimerRef.current = null;
}
latestRequestRef.current++;
};
}, []);
return {data, sendRequest, loading};
};
const getSearchParamCopy = (searchParams) => {
let copy = {};
if (searchParams) {
Array.from(searchParams.keys()).forEach(key => {
const value = searchParams.getAll(key)
copy[key] = value.length === 1 ? value[0] : value;
})
}
copy = removeEmptyValues(copy);
return copy;
}
const removeEmptyValues = (obj) => {
Object.entries(obj).forEach(([k, v]) => {
// Clear any empty values.
if (v === null || v === undefined || (Array.isArray(v) && v.length === 0)) {
delete obj[k];
}
});
return obj
}
export const useQuery = () => {
const location = useLocation();
const [searchParams, setSearchParams] = useSearchParams();
const updateQuery = (newParams, replace = false) => {
// Update the old state with the new values.
let newSearchParams = replace ?
newParams
: {...getSearchParamCopy(searchParams), ...newParams};
newSearchParams = removeEmptyValues(newSearchParams);
console.debug('useQuery.updateQuery', newSearchParams);
setSearchParams(newSearchParams);
};
const getLocationStr = (newSearchParams, pathname) => {
// Get the current location, but with new params appended.
newSearchParams = removeEmptyValues({...getSearchParamCopy(searchParams), ...newSearchParams});
const newQuery = createSearchParams(newSearchParams);
return `${pathname || location.pathname}?${newQuery.toString()}`
}
return {searchParams, updateQuery, getLocationStr}
}
export const QueryProvider = (props) => {
return <QueryContext.Provider value={useQuery()}>
{props.children}
</QueryContext.Provider>
}
export const useOneQuery = (name) => {
const {searchParams, updateQuery} = React.useContext(QueryContext);
const value = searchParams.get(name);
const setValue = (newValue, replace = false) => {
updateQuery({[name]: newValue}, replace);
}
return [value, setValue]
}
export const useAllQuery = (name) => {
const {searchParams, updateQuery} = React.useContext(QueryContext);
const value = searchParams.getAll(name);
const setValue = (newValue, replace = false) => {
updateQuery({[name]: newValue}, replace);
}
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(undefined); // Display error.
setTotal(0);
}
}
useEffect(() => {
_fetchDomains();
}, []);
return [domains, total];
}
export const useAuthors = () => {
const [authors, setAuthors] = useState(null);
const [total, setTotal] = useState(null);
const _fetchAuthors = async () => {
setAuthors(null);
setTotal(0);
try {
let [authors, total] = await fetchAuthors();
setAuthors(authors);
setTotal(total);
} catch (e) {
setAuthors(undefined);
setTotal(0);
}
}
useEffect(() => {
_fetchAuthors();
}, []);
return [authors, total];
}
export const useSubjects = () => {
const [subjects, setSubjects] = useState(null);
const [total, setTotal] = useState(null);
const _fetchSubjects = async () => {
setSubjects(null);
setTotal(0);
try {
let [subjects, total] = await fetchSubjects();
setSubjects(subjects);
setTotal(total);
} catch (e) {
setSubjects(undefined);
setTotal(0);
}
}
useEffect(() => {
_fetchSubjects();
}, []);
return [subjects, total];
}
export const useDoc = (fileGroupId) => {
const [docFile, setDocFile] = useState(null);
const [doc, setDoc] = useState(null);
const fetchDoc = async () => {
try {
const response = await getDoc(fileGroupId);
if (response.ok) {
const data = await response.json();
setDocFile(data.file_group);
setDoc(data.doc);
} else {
setDocFile(undefined);
}
} catch (e) {
console.error(e);
setDocFile(undefined);
}
}
useEffect(() => {
fetchDoc();
}, [fileGroupId]);
return {docFile, doc, fetchDoc};
}
export const useDomain = (domainId) => {
const emptyDomain = {
domain: '',
directory: '',
description: '',
tag_name: null,
};
const fetchDomain = async () => {
if (!domainId) {
console.debug('Not fetching domain because no domainId is provided');
return;
}
const d = await getDomain(domainId);
// Prevent controlled to uncontrolled
d.directory = d.directory || '';
d.description = d.description || '';
d.tag_name = d.tag_name || null;
return d;
};
const submitDomain = async () => {
const body = {
directory: form.formData.directory,
description: form.formData.description,
// Convert null to empty string - backend expects "" to clear tag
tag_name: form.formData.tag_name === null ? '' : form.formData.tag_name,
};
return await updateDomain(domainId, body);
};
const form = useForm({
fetcher: fetchDomain,
emptyFormData: emptyDomain,
clearOnSuccess: false,
submitter: submitDomain
});
React.useEffect(() => {
form.fetcher();
}, [domainId]);
const domain = form.formData;
return {domain, form, fetchDomain: form.fetcher};
}
export const useArchive = (fileGroupId) => {
const [archiveFileGroup, setArchiveFileGroup] = useState(null);
const [history, setHistory] = useState(null);
const fetchArchive = async () => {
try {
const {file_group, history} = await getArchive(fileGroupId);
setArchiveFileGroup(file_group);
setHistory(history);
} catch (e) {
console.error(e);
setArchiveFileGroup(undefined);
}
}
useEffect(() => {
fetchArchive();
}, [fileGroupId]);
return {archiveFile: archiveFileGroup, history, fetchArchive};
}
export const usePages = (defaultLimit = 24, totalPages = 0) => {
const {searchParams, updateQuery} = React.useContext(QueryContext);
const offset = searchParams.get('o') || 0;
const limit = parseInt(searchParams.get('l') || defaultLimit || 24);
const [activePage, setActivePage] = useState(calculatePage(offset, limit));
const [totalPages_, setTotalPages] = useState(totalPages);
const setLimit = (value) => {
setPage(1);
updateQuery({l: value, o: null});
}
const setPage = (value) => {
console.debug(`setPage ${value}`);
setActivePage(value);
value = value - 1; // Page really starts as 0.
updateQuery({o: value * limit});
}
const setTotal = (total) => {
const newTotalPages = calculateTotalPages(total, limit);
console.debug('newTotalPages', newTotalPages);
setTotalPages(newTotalPages);
}
// Used for useEffect.
const effect = JSON.stringify({offset, limit, activePage});
return {offset, limit, setLimit, activePage, setPage, totalPages: totalPages_, setTotal, effect};
}
export const useSearchArchives = (defaultLimit) => {
const {domain} = useSearchDomain();
const {offset, limit, setLimit, activePage, setPage} = usePages(defaultLimit);
const {searchParams, updateQuery} = React.useContext(QueryContext);
const searchStr = searchParams.get('q') || '';
const order = searchParams.get('order');
const activeTags = searchParams.getAll('tag');
const {view} = useSearchView();
const headline = view === 'headline';
const {deep} = useSearchDeep();
const [archives, setArchives] = useState(null);
const [totalPages, setTotalPages] = useState(0);
const localSearchArchives = async () => {
setArchives(null);
try {
let [archives_, total] = await searchArchives(offset, limit, domain, searchStr, order, activeTags, headline,
deep);
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(undefined); // Could not get Archives, display error.
}
}
useEffect(() => {
localSearchArchives();
}, [searchStr, limit, domain, order, offset, JSON.stringify(activeTags), headline, deep]);
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,
}
}
const docFilterToMimetype = (filter) => {
if (filter === 'pdf') return 'application/pdf';
if (filter === 'epub') return 'application/epub';
if (filter === 'comic') return 'application/x-cb';
if (filter === 'mobi') return 'application/x-mobipocket-ebook';
return null;
}
export const useSearchDocs = (defaultLimit) => {
const {offset, limit, setLimit, activePage, setPage} = usePages(defaultLimit);
const {searchParams, updateQuery} = React.useContext(QueryContext);
const searchStr = searchParams.get('q') || '';
const order = searchParams.get('order');
const activeTags = searchParams.getAll('tag');
const author = searchParams.get('author') || '';
const subject = searchParams.get('subject') || '';
const filter = searchParams.get('filter') || '';
const {deep} = useSearchDeep();
const [docs, setDocs] = useState(null);
const [totalPages, setTotalPages] = useState(0);
const localSearchDocs = async () => {
setDocs(null);
try {
const mimetype = docFilterToMimetype(filter);
let [docs_, total] = await searchDocs(offset, limit, searchStr, order, activeTags, author, subject,
mimetype, deep);
setDocs(docs_);
setTotalPages(calculateTotalPages(total, limit));
} catch (e) {
console.error(e);
setDocs(undefined);
}
}
useEffect(() => {
localSearchDocs();
}, [searchStr, limit, order, offset, JSON.stringify(activeTags), author, subject, filter, deep]);
const setSearchStr = (value) => {
updateQuery({q: value, o: 0, order: undefined});
}
const setOrderBy = (value) => {
setPage(1);
updateQuery({order: value});
}
return {
docs,
limit,
setLimit,
offset,
order,
setOrderBy,
totalPages,
activePage,
setPage,
searchStr,
setSearchStr,
author,
subject,
fetchDocs: localSearchDocs,
}
}
export const useSearchVideos = (defaultLimit, channelId, order_by) => {
const {searchParams, updateQuery} = React.useContext(QueryContext);
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 {view} = useSearchView();
const headline = view === 'headline';
const anyTag = searchParams.get('anyTag') === 'true';
const censored = searchParams.get('censored') === 'true';
const {deep} = useSearchDeep();
const [videos, setVideos] = useState(null);
const [totalPages, setTotalPages] = useState(0);
const [loading, setLoading] = useState(false);
const localSearchVideos = async () => {
setVideos(null);
setLoading(true);
try {
let [videos_, total] = await searchVideos(offset, limit, channelId, searchStr, order, activeTags, headline,
censored, deep);
setVideos(videos_);
setTotalPages(calculateTotalPages(total, limit));
} catch (e) {
console.error(e);
setVideos(undefined);// Could not get Videos, display error.
} finally {
setLoading(false);
}
}
useEffect(() => {
localSearchVideos();
}, [searchStr, limit, channelId, offset, order_by, JSON.stringify(activeTags), headline, censored, deep]);
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,
loading,
}
}
export const useVideo = (fileGroupId) => {
const [videoFile, setVideoFile] = useState(null);
const [prevFile, setPrevFile] = useState(null);
const [nextFile, setNextFile] = useState(null);
const fetchVideo = async () => {
if (fileGroupId && videoFile && Number(videoFile.id) !== Number(fileGroupId)) {
// Video is changing. Clear the old video before fetching.
setVideoFile(null);
setPrevFile(null);
setNextFile(null);
}
try {
const [v, p, n] = await getVideo(fileGroupId);
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();
}, [fileGroupId]);
return {videoFile, prevFile, nextFile, fetchVideo};
}
export const useVideoExtras = (fileGroupId) => {
// Fetches extra data to display on a Video's page. These are served separately from the
// Video itself so list responses stay small and never read files from disk.
//
// Each value is null while pending, undefined when the fetch failed, and empty ([] or '') when
// the server confirmed there is nothing. The API serializes a missing info_json field as null,
// so a null response is normalized to empty here; consumers must never see null for "none".
const [comments, setComments] = useState(null);
const [description, setDescription] = useState(null);
// Every fetch takes the next generation number; only the newest generation may write state.
// Matching on the video id is not enough: leaving and returning to the same video, or a save
// that refetches the description, must both beat an older request still in flight.
const commentsGen = useRef(0);
const descriptionGen = useRef(0);
const fetchComments = async () => {
const gen = ++commentsGen.current;
try {
const result = await getVideoComments(fileGroupId);
if (gen === commentsGen.current) {
setComments(result.comments || []);
}
} catch (e) {
console.error(e);
if (gen === commentsGen.current) {
setComments(undefined);
}
}
}
const fetchDescription = async () => {
const gen = ++descriptionGen.current;
try {
const result = await getVideoDescription(fileGroupId);
if (gen === descriptionGen.current) {
setDescription(result.description || '');
}
} catch (e) {
console.error(e);
if (gen === descriptionGen.current) {
setDescription(undefined);
}
}
}
useEffect(() => {
// Whether switching to a new video or to none, the previous video's data must not linger,
// and any request still in flight for it must not land.
commentsGen.current++;
descriptionGen.current++;
setComments(null);
setDescription(null);
if (fileGroupId) {
fetchComments();
fetchDescription();
}
}, [fileGroupId]);
return {comments, description, fetchDescription}
}
export const useVideoCaptions = (fileGroupId) => {
const [captions, setCaptions] = useState(null);
const [captionsLoading, setCaptionsLoading] = useState(false);
const captionsFetched = useRef(false);
const fetchCaptions = async () => {
if (captionsFetched.current || !fileGroupId) return;
setCaptionsLoading(true);
try {
const result = await getVideoCaptions(fileGroupId);
setCaptions(result.captions);
} catch (e) {
console.error(e);
} finally {
setCaptionsLoading(false);
captionsFetched.current = true;
}
}
useEffect(() => {
setCaptions(null);
setCaptionsLoading(false);
captionsFetched.current = false;
}, [fileGroupId]);
return {captions, captionsLoading, fetchCaptions}
}
export const useChannel = (channel_id) => {
const emptyChannel = {
name: '',
directory: '',
url: '',
tag_name: null,
download_missing_data: null,
};
const fetchChannel = async () => {
if (!channel_id) {
console.debug('Not fetching channel because no channel_id is provided');
return;
}
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'] || '';
c['download_missing_data'] = c['download_missing_data'] ?? true;
return c;
}
const submitChannel = async () => {
const body = {
name: form.formData.name,
directory: form.formData.directory,
url: form.formData.url,
download_missing_data: form.formData.download_missing_data,
};
if (channel_id) {
return await updateChannel(channel_id, body);
} else {
// Can create a Channel with a Tag.
body.tag_name = form.formData.tag_name;
return await createChannel(body);
}
}
const form = useForm({
fetcher: fetchChannel,
emptyFormData: emptyChannel,
clearOnSuccess: false,
submitter: submitChannel
});
React.useEffect(() => {
// Channel may be gotten from Video data, fetch the Channel again.
form.fetcher();
}, [channel_id]);
return {
channel: form.formData,
form,
fetchChannel: form.fetcher,
};
}
export const useChannels = () => {
const [channels, setChannels] = useState(null);
const [total, setTotal] = useState(null);
const [metadata, setMetadata] = useState(null);
const _fetchChannels = async () => {
setChannels(null);
setTotal(0);
setMetadata(null);
try {
let [channels, total, metadata] = await fetchChannels();
setChannels(channels);
setTotal(total);
setMetadata(metadata);
} catch (e) {
console.error(e);
setChannels(undefined); // Display error.
setTotal(0);
setMetadata(undefined);
}
}
useEffect(() => {
_fetchChannels();
}, []);
return [channels, total, metadata];
}
export const useSearchRecentFiles = () => {
const [searchFiles, setSearchFiles] = useState(null);
const [loading, setLoading] = useState(false);
const localSearchFiles = async () => {
setLoading(true);
try {
let [file_groups, total] = await filesSearch(
null, 12, null, null, null, [], false,
null, null, null, false, 'viewed');
setSearchFiles(file_groups);
} catch (e) {
console.error(e);
toast({
type: 'error',
title: 'Unexpected server response',
description: 'Could not get recent files',
time: 5000,
});
} finally {
setLoading(false);
}
}
React.useEffect(() => {
localSearchFiles();
}, []);
return {searchFiles, loading, fetchFiles: localSearchFiles};
}
export const useSearchFiles = (defaultLimit = 48, emptySearch = false, model) => {
const {
activeTags, anyTag,
pages,
searchStr,
filter,
model: model_,
setSearchStr,
months,
dateRange,
} = useSearch(defaultLimit, emptySearch, model);
const {view} = useSearchView();
const {deep} = useSearchDeep();
const [searchFiles, setSearchFiles] = useState(null);
const [total, setTotal] = useState(null);
const [loading, setLoading] = useState(false);
const headline = view === 'headline';
const localSearchFiles = async () => {
if (!emptySearch && !searchStr && !activeTags) {
return;
}
const mimetypes = filterToMimetypes(filter);
setSearchFiles(null);
let fromDate;
let toDate;
if (dateRange) {
fromDate = dateRange[0];
toDate = dateRange[1];
}
setLoading(true);
console.log('localSearchFiles', fromDate, toDate, months);
try {
let [file_groups, total_] = await filesSearch(
pages.offset, pages.limit, searchStr, mimetypes, model || model_, activeTags, headline,
months, fromDate, toDate, anyTag, null, null, null, deep);
setSearchFiles(file_groups);
setTotal(total_);
pages.setTotal(total_);
} catch (e) {
setTotal(null);
pages.setTotal(0);
console.error(e);
toast({
type: 'error',
title: 'Unexpected server response',
description: 'Could not get files',
time: 5000,
});
} finally {
setLoading(false);
}
}
// Only search after the user has stopped typing. Estimates will always happen.
const debouncedLocalSearchFiles = _.debounce(async () => {
await localSearchFiles();
}, 1000);
useEffect(() => {
if (searchStr || (activeTags && activeTags.length > 0)) {
setLoading(true);
debouncedLocalSearchFiles();
}
// Handle when this is unmounted.
return () => debouncedLocalSearchFiles.cancel();
}, [
searchStr,
pages.effect,
filter,
model,
model_,
JSON.stringify(activeTags),
headline,
JSON.stringify(months),
JSON.stringify(dateRange),
anyTag,
deep,
]);
return {
searchFiles,
total,
searchStr,
filter,
setSearchStr,
pages,
activeTags,
loading,
};
}
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.error(e);
setBrowseFiles(undefined); // Display error.
}
}
useEffect(() => {
fetchFiles();
}, [JSON.stringify(openFolders)])
return {browseFiles, openFolders, setOpenFolders, fetchFiles};
}
export const useConfigs = () => {
const [configs, setConfigs] = useState(null);
const [loading, setLoading] = useState(false);
const fetchConfigs = async () => {
setLoading(true);
console.log('fetching configs...');
try {
const data = await getConfigs();
setConfigs(data['configs']);
console.debug('fetching configs successful');
} catch (e) {
// Ignore SyntaxError because they happen when the API is down.
if (!(e instanceof SyntaxError)) {
console.error(e);
}
setConfigs(undefined);
} finally {
setLoading(false);
}
}
const importConfig = async (fileName) => {
try {
await postImportConfig(fileName);
} catch (e) {
console.error(e);
}
}
const saveConfig = async (fileName) => {
try {
await postDumpConfig(fileName);
} catch (e) {
console.error(e);
}
}
return {configs, loading, fetchConfigs, importConfig, saveConfig}
}
export const useDownloads = () => {
const [onceDownloads, setOnceDownloads] = useState(null);
const [recurringDownloads, setRecurringDownloads] = useState(null);
const [pendingOnceDownloads, setPendingOnceDownloads] = useState(null);
const fetchDownloads = async () => {
try {
const data = await getDownloads();
setOnceDownloads(data['once_downloads']);
setRecurringDownloads(data['recurring_downloads']);
setPendingOnceDownloads(data['pending_once_downloads']);
} catch (e) {
console.error(e);
// Display errors.
setOnceDownloads(undefined);
setRecurringDownloads(undefined);
setPendingOnceDownloads(undefined);
}
}
useRecurringTimeout(fetchDownloads, 3 * 1000);
return {onceDownloads, recurringDownloads, pendingOnceDownloads, fetchDownloads}
}
// Every hardware toggle works the same way: one field of the shared status object
// says whether the subsystem is on, and starting/stopping it is a Controller call.
// `on` is null when the status is unknown, which the UI renders as unsupported.
const useSubsystemToggle = ({
statusField,
onValue = 'on',
offValues = ['off'],
start,
stop,
errorTitle,
errorDescription,
refetchStatus = false,
}) => {
const [on, setOn] = useState(null);
const {status, fetchStatus} = useContext(StatusContext);
const value = status?.[statusField];
useEffect(() => {
if (value === onValue) {
setOn(true);
} else if (offValues.includes(value)) {
setOn(false);
} else {
setOn(null);
}
}, [value]);
const setSubsystem = async (enable) => {
const previous = on;
setOn(null);
try {
if (enable) {
await start();
} else {
await stop();
}
} catch (e) {
console.error(`${errorTitle}:`, e);
toast({
type: 'error',
title: errorTitle,
description: e.message || errorDescription,
time: 5000,
});
// Nothing changed, so the status poll will not re-sync `on`; without this
// the toggle stays disabled and reads as unsupported until it remounts.
setOn(previous);
}
if (refetchStatus) {
await fetchStatus();
}
}
return {on, setOn, setSubsystem};
}
export const useHotspot = () => {
const {status} = useContext(StatusContext);
// Hotspot is unsupported on Docker.
const {dockerized, hotspot_ssid, hotspot_status} = status;
const {on, setOn, setSubsystem} = useSubsystemToggle({
statusField: 'hotspot_status',
onValue: 'connected',
// The WiFi device being in use for a network is a kind of "off": the hotspot
// is not running, but starting it takes the user off that network.
offValues: ['disconnected', 'off', 'in_use'],
start: startHotspot,
stop: stopHotspot,
errorTitle: 'Hotspot Error',
errorDescription: 'Could not modify hotspot. See server logs.',
});
return {
on,
inUse: hotspot_status === 'in_use',
hotspotSsid: hotspot_ssid,
setOn,
setHotspot: setSubsystem,
dockerized,
};
}
export const useThrottle = () => {
const {on, setOn, setSubsystem} = useSubsystemToggle({
statusField: 'throttle_status',
onValue: 'powersave',
offValues: ['ondemand'],
start: enableThrottle,
stop: disableThrottle,
errorTitle: 'Throttle Error',
errorDescription: 'Could not modify throttle. See server logs.',
// The governor is read from sysfs, so refetch rather than wait for the poll.
refetchStatus: true,
});
return {on, setOn, setThrottle: setSubsystem};
}
export const useBluetooth = () => {
const {on, setSubsystem} = useSubsystemToggle({
statusField: 'bluetooth_status',
start: unblockBluetooth,
stop: blockBluetooth,
errorTitle: 'Bluetooth Error',
errorDescription: 'Could not modify Bluetooth. See server logs.',
});
return {on, setBluetooth: setSubsystem};
}
export const useDesktop = () => {
const {on, setSubsystem} = useSubsystemToggle({
statusField: 'desktop_status',
start: startDesktop,
stop: stopDesktop,
errorTitle: 'Desktop Error',
errorDescription: 'Could not start/stop the desktop. See server logs.',
});
return {on, setDesktop: setSubsystem};
}
export const useVnc = () => {
const {status} = useContext(StatusContext);
const {on, setSubsystem} = useSubsystemToggle({
statusField: 'vnc_status',
start: startVnc,
stop: stopVnc,
errorTitle: 'VNC Error',
errorDescription: 'Could not start/stop VNC. See server logs.',
});
// VNC serves the desktop session, so it cannot be started without one.
return {on, desktopRunning: status?.desktop_status === 'on', setVnc: setSubsystem};
}
export const useSearchDirectories = (value) => {
const [directoryName, setDirectoryName] = useState(value ?? '');
const [directories, setDirectories] = useState(null);
const [channelDirectories, setChannelDirectories] = useState(null);
const [domainDirectories, setDomainDirectories] = useState(null);
const [isDir, setIsDir] = useState(false);
const [loading, setLoading] = useState(false);
const localSearchDirectories = async () => {
setLoading(true);
try {
const result = await searchDirectories(directoryName);
setDirectories(result.directories);
setChannelDirectories(result.channel_directories);
setDomainDirectories(result.domain_directories);
setIsDir(result.is_dir);
} finally {
setLoading(false);
}
};
useEffect(() => {
localSearchDirectories();
}, [directoryName]);
useEffect(() => {
// Directory value was changed above. Coerce null/undefined (an unset form field) to an
// empty string so the controlled input stays controlled and never builds a null result.
setDirectoryName(value ?? '');
}, [value]);
return {
directoryName,
setDirectoryName,
directories,
loading,
channelDirectories,
domainDirectories,
isDir,
}
}
export const useSettings = () => {
const [settings, setSettings] = useState({});
const [pending, setPending] = useState(false);
const fetchSettings = async () => {
if (window.apiDown) {
return;
}
setPending(true);
try {
const newSettings = await getSettings();
if (newSettings) {
setSettings(newSettings);
}
} catch (e) {
// Don't clear settings on error — keep the last known good values.
} finally {
setPending(false);
}
}
useEffect(() => {
fetchSettings();
}, []);
return {settings, pending, fetchSettings, saveSettings};
}
export const useSettingsInterval = () => {
const {settings, pending, fetchSettings, saveSettings} = useSettings();
useRecurringTimeout(fetchSettings, 1000 * 10);
return {settings, pending, fetchSettings, saveSettings};
}
export const useMediaDirectory = () => {
const {settings} = React.useContext(SettingsContext);
return settings['media_directory'];
}
export const useStatus = () => {
const [status, setStatus] = useState({});
const fetchStatus = async () => {
try {
// Fetch from both endpoints in parallel
const [appStatus, controllerStats] = await Promise.all([
getStatus().then(result => {
window.apiDown = false;
return result;
}).catch(e => {
if (e instanceof ApiDownError) {
window.apiDown = true;
return {};
}
throw e;
}),
getControllerStats().catch(e => {
// Controller may be down, continue with app status only
console.debug('Controller stats unavailable:', e.message);
return {};
}),
]);
// Merge both responses - controller stats override app status for system info
setStatus({...appStatus, ...controllerStats});
} catch (e) {
if (e instanceof ApiDownError) {
// API is down, do not log this error.
window.apiDown = true;
setStatus({});
return;
}
// Ignore SyntaxError because they happen when the API is down.
if (!(e instanceof SyntaxError)) {
console.error(e);
}
}
}
useEffect(() => {
// Used to tell other hooks to stop fetching intervals.
window.apiDown = false;
}, []);
return {status, fetchStatus}
}
export const useStatusInterval = () => {
const {status, fetchStatus} = useStatus();
useRecurringTimeout(fetchStatus, 1000 * 3);
return {status, fetchStatus};
}
export const StatusProvider = (props) => {
const statusValue = useStatusInterval();
const settingsValue = useSettingsInterval();
const statusMemoValue = React.useMemo(() => statusValue, [statusValue]);
const settingsMemoValue = React.useMemo(() => settingsValue, [settingsValue]);
return <StatusContext.Provider value={statusMemoValue}>
<SettingsContext.Provider value={settingsMemoValue}>
{props.children}
</SettingsContext.Provider>
</StatusContext.Provider>
}
export const useStatusFlag = (flag) => {
const {status} = useContext(StatusContext);
return status?.flags?.[flag] || false;
}
export const useCPUTemperature = () => {
const {status} = React.useContext(StatusContext);
const temperature = status?.cpu_stats?.temperature || 0;
const highTemperature = status?.cpu_stats?.high_temperature || 75;
const criticalTemperature = status?.cpu_stats?.critical_temperature || 85;
return {temperature, highTemperature, criticalTemperature}
}
// Reports the hottest drive's SMART temperature so the navbar can warn about
// an overheating disk, mirroring useCPUTemperature. Drives without a
// temperature reading (USB flash, unsupported bridges, spun-down) are ignored.
export const useDriveTemperature = () => {
const {status} = React.useContext(StatusContext);
const smart = status?.smart_stats;
const highTemperature = smart?.high_temperature || 55;
const criticalTemperature = smart?.critical_temperature || 65;
const drives = Array.isArray(smart?.drives) ? smart.drives : [];
const hottest = drives
.filter((d) => typeof d.temperature === 'number')
.reduce((max, d) => (max === null || d.temperature > max.temperature ? d : max), null);
return {
device: hottest?.device || null,
temperature: hottest?.temperature ?? 0,
highTemperature,
criticalTemperature,
}
}
// Reports drives whose SMART health is degraded, so the navbar can warn of an
// imminent or developing drive failure. The backend's derived `health` is
// 'PASS', 'WARN', 'FAIL', or null (unknown): FAIL is an imminent failure
// (back up now), WARN means unreadable/pending sectors are accumulating.
export const useDriveHealth = () => {
const {status} = React.useContext(StatusContext);
const drives = Array.isArray(status?.smart_stats?.drives) ? status.smart_stats.drives : [];
const verdict = (d) => (d.health || d.assessment);
const failingDevices = drives.filter((d) => verdict(d) === 'FAIL').map((d) => d.device);
const warningDevices = drives.filter((d) => verdict(d) === 'WARN').map((d) => d.device);
return {
failingDevices, failing: failingDevices.length > 0,
warningDevices, warning: warningDevices.length > 0,
};
}
export const useLoad = () => {
const {status} = React.useContext(StatusContext);
let minute_1 = status?.load_stats?.minute_1;
let minute_5 = status?.load_stats?.minute_5;
let minute_15 = status?.load_stats?.minute_15;
let mediumLoad = false;
let highLoad = false;
let cores;
if (status && status.cpu_stats) {
// Medium load when 1/2 cores are busy, High load when 3/4+ cores are busy.
cores = status.cpu_stats.cores;
const quarter = cores / 4;
if (cores && minute_1 >= (quarter * 3)) {
highLoad = true;
} else if (cores && minute_1 >= (quarter * 2)) {
mediumLoad = true;
}
}
return {minute_1, minute_5, minute_15, mediumLoad, highLoad, cores};
}
export const useIOStats = () => {
const {status} = React.useContext(StatusContext);
const percentIdle = status?.iostat_stats?.percent_idle;
const percentIOWait = status?.iostat_stats?.percent_iowait;
const percentNice = status?.iostat_stats?.percent_nice;
const percentSteal = status?.iostat_stats?.percent_steal;
const percentSystem = status?.iostat_stats?.percent_system;
const percentUser = status?.iostat_stats?.percent_user;
return {percentIdle, percentIOWait, percentNice, percentSteal, percentSystem, percentUser};
}
export const useMemoryStats = () => {
const {status} = React.useContext(StatusContext);
const total = status?.memory_stats?.total;
const used = status?.memory_stats?.used;
const free = status?.memory_stats?.free;
const cached = status?.memory_stats?.cached;
let percent;
if (total && used) {
percent = Math.round((used / total) * 100);
}
return {total, used, free, cached, percent}
}
export const usePowerStats = () => {
const {status} = React.useContext(StatusContext);
const underVoltage = status?.power_stats?.under_voltage;
const overCurrent = status?.power_stats?.over_current;
return {underVoltage, overCurrent};
}
export const useVideoStatistics = () => {
const [statistics, setStatistics] = useState(null);
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);
setStatistics(undefined); // Display error.
}
}
useEffect(() => {
fetchStatistics();
}, []);
return {statistics, fetchStatistics}
}
export const useArchiveStatistics = () => {
const [statistics, setStatistics] = useState(null);
const fetchStatistics = async () => {
try {
let stats = await getArchiveStatistics();
stats.archives.sum_size = humanFileSize(stats.archives.sum_size);
stats.archives.max_size = humanFileSize(stats.archives.max_size);
stats.historical.average_size = humanFileSize(stats.historical.average_size);
setStatistics(stats);
} catch (e) {
console.error(e);
setStatistics(undefined); // Display error.
}
}
useEffect(() => {
fetchStatistics();
}, []);
return {statistics, fetchStatistics}
}
export const useInventories = () => {
// Single in-memory store: every inventory (full) is loaded once. The list, the selected inventory's items,
// the summary, location suggestions, and the ration calculator all derive from this — no per-action GETs.
// Mutations persist the whole changed inventory (optimistically) instead of calling granular endpoints.
const [inventories, setInventories] = useState(null);
const ref = useRef([]);
useEffect(() => {
ref.current = inventories || [];
}, [inventories]);
const fetchInventories = async () => {
const result = await getInventories();
if (Array.isArray(result)) {
setInventories(result);
}
};
useEffect(() => {
fetchInventories();
}, []);
// Persist a patch ({name?, fields?, items?}) to one inventory: update locally first for snappy UI, then save.
// On conflict/error the saved value is null, so we re-fetch to reconcile with the server.
const persistInventory = async (slug, patch) => {
const current = ref.current.find(i => i.slug === slug);
const version = current ? current.version : undefined;
setInventories(prev => (prev || []).map(i => i.slug === slug ? {...i, ...patch} : i));
const saved = await saveInventory(slug, {...patch, version});
if (saved) {
setInventories(prev => (prev || []).map(i => i.slug === slug ? saved : i));
} else {
await fetchInventories();
}
return saved;
};
const addInventory = async (name, type) => {
const inventory = await createInventory({name, type});
if (inventory) {
setInventories(prev => [...(prev || []), inventory]);
}
return inventory;
};
const removeInventory = async (slug) => {
const response = await deleteInventory(slug);
if (response.ok) {
setInventories(prev => (prev || []).filter(i => i.slug !== slug));
}
return response;
};
return {inventories, fetchInventories, persistInventory, addInventory, removeInventory}
}
// The shared food catalog: load once, persist the whole list on change (optimistic).
export const useCatalog = () => {
const [catalog, setCatalog] = useState(null);
const fetchCatalog = async () => {
const result = await getCatalog();
if (Array.isArray(result)) {
setCatalog(result);
}
};
useEffect(() => {
fetchCatalog();
}, []);
const persistCatalog = async (items) => {
setCatalog(items);
const saved = await saveCatalog(items);
if (Array.isArray(saved)) {
setCatalog(saved);
} else {
await fetchCatalog();
}
return saved;
};
return {catalog, fetchCatalog, persistCatalog};
};
// Pool location suggestions from every inventory's `location`-type fields (shared across inventories).
export const collectLocations = (inventories) => {
const locations = new Set();
(inventories || []).forEach(inv => {
const keys = (inv.fields || []).filter(f => f.type === 'location').map(f => f.key);
if (keys.length === 0) {
return;
}
(inv.items || []).forEach(item => keys.forEach(k => {
if (item[k]) {
locations.add(item[k]);
}
}));
});
return Array.from(locations).sort();
};
export const useStatistics = () => {
// null = pending, undefined = fetch failed (the api helper returns undefined on a non-OK
// response), an object = loaded. Never undefined on the first render: the page shows its
// error for undefined.
const [statistics, setStatistics] = useState(null);
const fetchFileStatistics = async () => {
try {
const s = await getStatistics();
setStatistics(s ?? undefined);
} catch (e) {
console.error(e);
setStatistics(undefined);
}
}
useEffect(() => {
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 [sort, setSort] = useOneQuery('order');
return {sort, setSort}
}
export const useSearchCensored = () => {
// Filters Videos to only those which are no longer available for download (?censored=true).
const [value, setValue] = useOneQuery('censored');
const censored = value === 'true';
const setCensored = (newValue) => setValue(newValue ? 'true' : undefined);
return {censored, setCensored}
}
export const useSearchDeep = () => {
// Search all text including captions/document contents (?deep=true). Slower, but more thorough.
const [value, setValue] = useOneQuery('deep');
const deep = value === 'true';
const setDeep = (newValue) => setValue(newValue ? 'true' : undefined);
return {deep, setDeep}
}
export const useSearchDate = () => {
// Filters files using
// ?month=1&month=2&month=3
// and
// ?fromDate=2023&toDate=2024
const {searchParams, updateQuery} = React.useContext(QueryContext);
const months = searchParams.getAll('month');
let fromDate = searchParams.get('fromDate');
let toDate = searchParams.get('toDate');
fromDate = fromDate ? parseInt(fromDate) : null;
toDate = toDate ? parseInt(toDate) : null;
const clearDate = () => {
console.log('clearDate');
updateQuery({fromDate: null, toDate: null, month: null, 'o': 0});
}
const setDates = (newFromDate, newToDate, newMonths) => {
console.log('setDates', newFromDate, newToDate, newMonths);
updateQuery({fromDate: newFromDate, toDate: newToDate, month: newMonths, 'o': 0});
}
const anySearch = (months && months.length > 0) || (fromDate !== null || toDate !== null);
const isEmpty = !anySearch;
return {dateRange: [fromDate, toDate], setDates, months, clearDate, isEmpty}
}
export const useUploadFile = () => {
const [files, setFiles] = useState([]);
const [progresses, setProgresses] = useState({});
const [destination, setDestination] = useState('');
const [tagNames, setTagNames] = React.useState([]);
const [overwrite, setOverwrite] = React.useState(false);
const [totalSize, setTotalSize] = useState(0);
const [uploadedSize, setUploadedSize] = useState(0);
const [overallProgress, setOverallProgress] = useState(0);
const [inProgress, setInProgress] = useState(false);
const handleProgress = (name, chunk, totalChunks, status, type) => {
const percent = Math.round((100 * chunk) / totalChunks);
const newProgress = {[name]: {percent, status, type}};
setProgresses(prevState => {
const updatedProgresses = {...prevState, ...newProgress};
// Calculate total uploaded size based on all files' progress
let totalUploaded = 0;
files.forEach(file => {
const fileProgress = updatedProgresses[file.name];
if (fileProgress) {
const chunkSize = 10 * 1024 * 1024; // 10MB - same as in doUpload
const fileSize = file.size;
const totalFileChunks = Math.ceil(fileSize / chunkSize);
// For completed files, count the full size
if (fileProgress.status === 'complete' || fileProgress.status === 'conflicting') {
totalUploaded += fileSize;
}
// For files in progress, count the completed chunks
else if (fileProgress.percent > 0) {
const completedChunks = Math.floor((fileProgress.percent / 100) * totalFileChunks);
const completedSize = Math.min(completedChunks * chunkSize, fileSize);
totalUploaded += completedSize;
}
}
});
setUploadedSize(totalUploaded);
if (totalSize > 0) {
const newOverallProgress = Math.round((totalUploaded / totalSize) * 100);
setOverallProgress(newOverallProgress);
}
return updatedProgresses;
});
}
const handleFilesChange = (newFiles) => {
let newProgresses = {};
let newTotalSize = 0;
newFiles.forEach(file => {
newProgresses = {...newProgresses, [file.name]: {percent: 0, status: 'pending'}};
newTotalSize += file.size;
});
setProgresses(newProgresses);
setFiles(newFiles);
setTotalSize(newTotalSize);
setUploadedSize(0);
setOverallProgress(0);
}
const doUpload = async () => {
// `''` is the media directory, which the file browser uploads to when no folder is
// selected; only a missing destination means there is nowhere to put the files.
if (!files || files.length === 0 || destination === null || destination === undefined) {
return;
}
setInProgress(true);
for (let i = 0; i < files.length; i++) {
const file = files[i];
console.log(`Uploading file:`, file.path);
const chunkNum = 0;
const chunkSize = 10 * 1024 * 1024; // 10MB
const totalChunks = Math.ceil(file.size / chunkSize);
const tries = 0;
const maxTries = 20;
// Start recursive function to upload the file and wait for it to complete
// before moving to the next file
try {
await new Promise((resolve, reject) => {
const uploadNextChunk = async (currentChunkNum, currentTries) => {
if (currentTries > maxTries) {
console.error(`Exceeded max tries ${maxTries}`);
reject(new Error(`Exceeded max tries ${maxTries}`));
return;
}
const start = currentChunkNum * chunkSize;
const end = Math.min(start + chunkSize, file.size);
const chunk = file.slice(start, end);
const formData = new FormData();
formData.append('chunkNumber', currentChunkNum.toString());
formData.append('filename', file.path);
formData.append('totalChunks', totalChunks.toString());
formData.append('destination', destination);
formData.append('mkdir', 'true');
if (overwrite) {
formData.append('overwrite', 'true');
}
formData.append('chunkSize', chunk.size.toString());
formData.append('chunk', chunk);
for (let j = 0; j < tagNames.length; j++) {
formData.append('tagNames', tagNames[j]);
}
console.debug(`file upload: tries=${currentTries} chunkNum=${currentChunkNum} totalChunks=${totalChunks} chunkSize=${chunk.size} destination=${destination} tagNames=${tagNames}`);
// Create a new XMLHttpRequest for each chunk to avoid InvalidStateError
const chunkXhr = new XMLHttpRequest();
chunkXhr.open('POST', '/api/files/upload', true);
chunkXhr.onreadystatechange = async () => {
if (chunkXhr.readyState === 4) {
if (chunkXhr.status === 200 || chunkXhr.status === 416) {
const data = JSON.parse(chunkXhr.responseText);
handleProgress(file.name, currentChunkNum, totalChunks, 'pending', file.type);
const expectedChunk = data['expected_chunk'];
if (chunkXhr.status === 416) {
console.warn(`Server requested a different chunk ${currentChunkNum}`);
uploadNextChunk(expectedChunk, currentTries + 1);
} else {
console.debug(`Uploading of chunk ${currentChunkNum} succeeded, got request for chunk ${expectedChunk}`);
// Success, reset tries.
uploadNextChunk(expectedChunk, 0);
}
} else if (chunkXhr.status === 201) {
handleProgress(file.name, totalChunks, totalChunks, 'complete', file.type);
console.info(`Uploading of ${file.path} completed.`);
resolve(); // File upload completed successfully
} else if (chunkXhr.status === 400) {
handleProgress(file.name, totalChunks, totalChunks, 'conflicting', file.type);
const data = JSON.parse(chunkXhr.responseText);
if (data['code'] === 'FILE_UPLOAD_FAILED') {
console.error('File already exists. Giving up.');
reject(new Error('File already exists'));
}
} else {
handleProgress(file.name, totalChunks, totalChunks, 'failed', file.type);
console.error(`Failed to upload chunk ${currentChunkNum}. Giving up.`);
reject(new Error(`Failed to upload chunk ${currentChunkNum}`));
}
}
};
chunkXhr.send(formData);
};
// Start uploading the first chunk
uploadNextChunk(chunkNum, tries);
});
} catch (error) {
console.error(`Error uploading file ${file.path}:`, error);
// Continue with the next file even if this one failed
}
}
// Clear form after upload.
setFiles([]);
setInProgress(false);
}
// Stable across renders. Callers put it in effect dependencies, and every call sets state
// with fresh objects -- an unstable identity there re-runs the effect on the render its own
// setState caused, which React ends with "Maximum update depth exceeded".
const doClear = React.useCallback(() => {
setFiles([]);
setProgresses({});
setTotalSize(0);
setUploadedSize(0);
setOverallProgress(0);
setInProgress(false);
}, []);
useEffect(() => {
doUpload()
}, [JSON.stringify(files)]);
const tagsSelector = <TagsSelector selectedTagNames={tagNames} onChange={(i,) => setTagNames(i)}/>;
return {
destination, setDestination,
doClear,
doUpload,
files,
progresses,
setFiles: handleFilesChange,
tagNames,
tagsSelector,
overwrite, setOverwrite,
overallProgress,
totalSize,
uploadedSize,
inProgress,
}
}
export const useSearchZim = (searchStr, zimId, active, activeTags, defaultLimit = 10) => {
const [zim, setZim] = useState(null);
const pages = usePages(defaultLimit);
const [loading, setLoading] = useState(false);
const localFetchSearch = async () => {
if (!active) {
return;
}
setLoading(true);
try {
const zim = await searchZim(pages.offset, pages.limit, searchStr, zimId, activeTags);
setZim(zim);
pages.setTotal(zim.estimate);
} catch (e) {
pages.setTotal(0);
console.error(`Failed to search Zim ${zimId}`);
console.error(e);
}
setLoading(false);
}
useEffect(() => {
localFetchSearch();
}, [active, searchStr, JSON.stringify(activeTags), pages.effect]);
return {zim, fetchSearch: localFetchSearch, pages, loading}
}
export const useOutdatedZims = () => {
const [outdated, setOutdated] = useState(null);
const [current, setCurrent] = useState(null);
const localFetchOutdatedZims = async () => {
const zims = await getOutdatedZims();
setOutdated(zims['outdated']);
setCurrent(zims['current']);
}
useEffect(() => {
localFetchOutdatedZims();
}, []);
return {outdated, current, fetchOutdatedZims: localFetchOutdatedZims}
}
export const useVINDecoder = (defaultVINNumber = '') => {
const [value, setValue] = useState(defaultVINNumber);
// The response vin from the API.
const [vin, setVin] = useState(null);
const localFetchDecoded = async () => {
if (!value) {
return;
}
try {
const vin = await fetchDecoded(value);
setVin(vin);
} catch (e) {
console.error('Failed to decode VIN number');
setVin(null);
}
}
useEffect(() => {
localFetchDecoded();
}, [value]);
return {value, setValue, vin}
}
export const useWROLMode = () => {
// Returns the current boolean WROL Mode, during fetch this returns null.
const {settings} = useContext(SettingsContext);
return settings ? settings.wrol_mode : null;
}
export const useDockerized = () => {
const {status} = React.useContext(StatusContext);
return status && status['dockerized'] === true;
}
export const useCalcQuery = () => {
const [calc, setCalc] = useOneQuery('calc');
return [calc, setCalc]
}
export const useSearchChannels = (defaultTagNames) => {
const [tagNames, setTagNames] = useState(defaultTagNames || []);
// null = pending, undefined = fetch failed, [] = no channels. A search starts on mount, so the
// first render is already loading; consumers must never see [] for a search that has not run.
const [channels, setChannels] = useState(null);
const [loading, setLoading] = useState(true);
// Only the newest request may write state; a slow response for previous tags is dropped.
const requestGen = useRef(0);
const localSearchChannels = async () => {
const gen = ++requestGen.current;
setChannels(null);
setLoading(true);
try {
const {channels: newChannels} = await searchChannels(tagNames);
if (gen === requestGen.current) {
setChannels(newChannels || []);
}
} catch (e) {
console.error(e);
if (gen === requestGen.current) {
setChannels(undefined);
}
} finally {
if (gen === requestGen.current) {
setLoading(false);
}
}
};
// The caller's tags come from the URL and change in place while the view stays mounted, so
// follow their contents. Keyed on the serialized list because the caller builds a new array
// every render; adopting it by reference would refetch forever.
const tagKey = JSON.stringify(defaultTagNames || []);
useEffect(() => {
setTagNames(prev => JSON.stringify(prev) === tagKey ? prev : JSON.parse(tagKey));
}, [tagKey]);
useEffect(() => {
localSearchChannels();
}, [tagNames]);
return {
tagNames,
setTagNames,
channels,
loading,
}
}
/**
* Detect whether the WROLPi browser extension is installed AND has this
* destination configured. The extension's background worker dynamically
* registers a content script on each configured destination origin; that
* script appends `<meta name="wrolpi-extension" content="<version>">` to the
* head. We read for that marker.
*
* Three-state result so callers can avoid flashing UI during the race
* between React's first render and the content script's document_idle:
* null — checking; render nothing
* false — confirmed absent (after recheck); show "install me" UI
* <string> — installed; the version string the extension reported
*
* Observes <head> for a late-arriving marker (e.g., the user installs the
* extension while the page is open, or grants the destination permission
* after page load) so the banner clears without requiring a manual reload.
*/
export function useExtensionInstalled() {
const detect = () => {
const meta = document.querySelector('meta[name="wrolpi-extension"]');
if (!meta) return null;
return meta.getAttribute('content') || true;
};
const [state, setState] = useState(detect);
useEffect(() => {
// Observe <head> for the marker meta tag appearing at any time.
// Once we see it we clean up — there's no need to keep watching.
const observer = new MutationObserver(() => {
const result = detect();
if (result) setState(result);
});
if (document.head) {
observer.observe(document.head, {childList: true, subtree: true});
}
return () => observer.disconnect();
}, []);
useEffect(() => {
if (state !== null) return;
// Recheck once after the document_idle window closes; only then
// commit to "false". Avoids flashing the banner on every dashboard
// load while we're just waiting for the content script to run.
const t = setTimeout(() => setState(detect() ?? false), 500);
return () => clearTimeout(t);
}, [state]);
return state;
}