99 lines
4.1 KiB
TypeScript
99 lines
4.1 KiB
TypeScript
import type { ClusterModel, GameLoader, ManagedPackage, ManagedVersion, PackageCategories, Paginated, Provider, SearchQuery, SearchResult } from '@/bindings.gen';
|
|
import type { BindingCommands } from '@/types/global';
|
|
import type { UndefinedInitialDataOptions } from '@tanstack/react-query';
|
|
import type { Dispatch, SetStateAction } from 'react';
|
|
import { bindings } from '@/main';
|
|
import { PROVIDERS } from '@/utils';
|
|
import { useCommand, useCommandMut } from '@onelauncher/common';
|
|
import { useNavigate } from '@tanstack/react-router';
|
|
import { createContext, useContext, useEffect, useMemo, useState } from 'react';
|
|
|
|
export interface BrowserControllerType {
|
|
cluster: ClusterModel | undefined;
|
|
setCluster: Dispatch<SetStateAction<ClusterModel | undefined>>;
|
|
provider: Provider;
|
|
setProvider: Dispatch<SetStateAction<Provider>>;
|
|
query: SearchQuery;
|
|
setQuery: Dispatch<SetStateAction<SearchQuery>>;
|
|
search: () => void;
|
|
}
|
|
|
|
const BrowserContext = createContext<BrowserControllerType | null>(null);
|
|
|
|
export function useBrowserContext() {
|
|
const context = useContext(BrowserContext);
|
|
if (!context)
|
|
throw new Error('useBrowserContext must be used within a BrowserProvider');
|
|
return context;
|
|
}
|
|
|
|
export function BrowserProvider(props: any) {
|
|
const { children } = props;
|
|
const [cluster, setCluster] = useState<ClusterModel | undefined>(undefined);
|
|
const [provider, setProvider] = useState<Provider>(PROVIDERS[0]);
|
|
const navigate = useNavigate();
|
|
const [query, setQuery] = useState<SearchQuery>({
|
|
filters: {
|
|
categories: null,
|
|
game_versions: null,
|
|
loaders: null,
|
|
package_type: 'mod',
|
|
},
|
|
query: null,
|
|
limit: 18 as unknown as bigint,
|
|
offset: null,
|
|
sort: null,
|
|
});
|
|
|
|
useEffect(() => {
|
|
if (query.filters?.categories || query.query)
|
|
navigate({ to: '/app/browser/search' });
|
|
}, [navigate, query]);
|
|
|
|
const context = useMemo<BrowserControllerType>(() => ({
|
|
cluster,
|
|
setCluster,
|
|
provider,
|
|
setProvider,
|
|
query,
|
|
setQuery,
|
|
search: () => {},
|
|
}), [cluster, provider, query]);
|
|
|
|
return (
|
|
<BrowserContext.Provider value={context}>
|
|
{children}
|
|
</BrowserContext.Provider>
|
|
);
|
|
}
|
|
|
|
export function getCategories(categories: PackageCategories) {
|
|
if ('Mod' in categories)
|
|
return categories.Mod;
|
|
if ('ResourcePack' in categories)
|
|
return categories.ResourcePack;
|
|
if ('Shader' in categories)
|
|
return categories.Shader;
|
|
if ('DataPack' in categories)
|
|
return categories.DataPack;
|
|
if ('ModPack' in categories)
|
|
return categories.ModPack;
|
|
return [];
|
|
}
|
|
|
|
export function useBrowserSearch(provider: Provider, query: SearchQuery, options?: Omit<UndefinedInitialDataOptions<Paginated<SearchResult>>, 'queryKey' | 'queryFn'> | undefined) {
|
|
const validFilters = useMemo(() => Object.values(query.filters ?? {}).filter(a => a).length > 0, [query.filters]);
|
|
return useCommand(`search.${provider}`, () => bindings.core.searchPackages(provider, validFilters ? query : { ...query, filters: null }), options);
|
|
}
|
|
|
|
export function usePackageData(provider: Provider, slug: string, options?: Omit<UndefinedInitialDataOptions<ManagedPackage>, 'queryKey' | 'queryFn'> | undefined, key: false | BindingCommands | (string & {}) = `getPackage.${provider}.${slug}`) {
|
|
return useCommand(key, () => bindings.core.getPackage(provider, slug), options);
|
|
}
|
|
|
|
export function usePackageVersions(provider: Provider, slug: string, { mc_version, loader, offset, limit, ...options }: { mc_version?: string | null; loader?: GameLoader | null; offset?: number; limit: number } & Omit<UndefinedInitialDataOptions<Paginated<ManagedVersion>>, 'queryKey' | 'queryFn'>, key: false | BindingCommands | (string & {}) = `getPackageVersions.${provider}.${slug}.${mc_version}.${loader}.${offset}`) {
|
|
return useCommand(key, () => bindings.core.getPackageVersions(provider, slug, mc_version ?? null, loader ?? null, (offset ?? 0) as unknown as bigint, limit as unknown as bigint), options);
|
|
}
|
|
|
|
export function useDownloadPackage(cluster: ClusterModel, provider: Provider, version: ManagedVersion, skipCompatibility = false) {
|
|
return useCommandMut(() => bindings.core.downloadPackage(provider, version.project_id, version.version_id, cluster.id, skipCompatibility));
|
|
}
|