Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
import { browser } from '$app/env';
import { PersistedState } from 'runed';
import { decodeSort, type CompactTablePrefs } from '#lib/components/arcane-table/arcane-table.types.svelte.js';
import { TABLE_PAGE_SIZE_ALL, TABLE_PAGE_SIZE_OPTIONS } from '#lib/constants/table-pagination.js';
import { environmentStore } from '#lib/stores/environment.store.svelte.js';
import type { FilterMap, FilterValue, SearchPaginationSortRequest } from '#lib/types/shared.js';
const DEFAULT_LIMIT = 20;
function normalizeTablePageSize(limit: unknown): number | undefined {
const parsed = typeof limit === 'number' ? limit : Number.parseInt(String(limit), 10);
if (!Number.isFinite(parsed)) return undefined;
if (parsed === TABLE_PAGE_SIZE_ALL) return parsed;
return TABLE_PAGE_SIZE_OPTIONS.includes(parsed as (typeof TABLE_PAGE_SIZE_OPTIONS)[number]) ? parsed : undefined;
}
function cloneRequest(options: SearchPaginationSortRequest): SearchPaginationSortRequest {
return {
search: options.search,
filters: options.filters ? { ...options.filters } : undefined,
pagination: options.pagination ? { ...options.pagination } : undefined,
sort: options.sort ? { ...options.sort } : undefined,
includeInternal: options.includeInternal,
includeHidden: options.includeHidden
};
}
function buildFilterMap(pairs?: [string, unknown][]): FilterMap {
const filters: FilterMap = {};
if (!pairs?.length) return filters;
for (const [id, rawValue] of pairs) {
let value: unknown = rawValue;
if (value instanceof Set) {
value = Array.from(value);
}
if (Array.isArray(value)) {
const entries = value.filter((entry) => entry !== undefined && entry !== null && `${entry}`.trim() !== '');
if (entries.length === 0) continue;
filters[id] = entries as FilterValue;
continue;
}
if (value === undefined || value === null) continue;
if (typeof value === 'string') {
const trimmed = value.trim();
if (!trimmed) continue;
filters[id] = trimmed;
continue;
}
filters[id] = value as FilterValue;
}
return filters;
}
function normalizeSearch(value: unknown): string | undefined {
if (typeof value !== 'string') return undefined;
const trimmed = value.trim();
return trimmed.length > 0 ? trimmed : undefined;
}
export function resolveInitialTableRequest(
persistKey: string,
defaults: SearchPaginationSortRequest,
options: { deferredSortColumns?: readonly string[]; restoreAllPageSize?: boolean } = {}
): SearchPaginationSortRequest {
const base = cloneRequest(defaults);
const fallbackLimit = base.pagination?.limit ?? DEFAULT_LIMIT;
if (!base.pagination) {
base.pagination = { page: 1, limit: fallbackLimit };
} else {
base.pagination = {
page: base.pagination.page ?? 1,
limit: base.pagination.limit ?? fallbackLimit
};
}
if (!browser) return base;
try {
const persisted = new PersistedState<CompactTablePrefs>(
persistKey,
{ v: [], f: [], g: '', l: fallbackLimit },
{ syncTabs: false }
);
const current = persisted.current ?? {};
const filters = buildFilterMap(current.f);
if (Object.keys(filters).length > 0) {
base.filters = filters;
base.pagination = { ...base.pagination!, page: 1 };
}
const search = normalizeSearch(current.g);
if (search !== undefined) {
base.search = search;
base.pagination = { ...base.pagination!, page: 1 };
}
let limit = normalizeTablePageSize(current.l);
if (limit === TABLE_PAGE_SIZE_ALL && options.restoreAllPageSize === false) {
limit = fallbackLimit;
}
if (limit !== undefined && base.pagination?.limit !== limit) {
base.pagination = { page: 1, limit };
}
const sort = decodeSort(current.s);
if (sort && !options.deferredSortColumns?.includes(sort.column)) {
base.sort = sort;
}
} catch (error) {
return base;
}
return base;
}
export function resolveInitialListPageRequest(
persistKey: string,
sort: NonNullable<SearchPaginationSortRequest['sort']>,
limit = 20
): SearchPaginationSortRequest {
return resolveInitialTableRequest(persistKey, {
pagination: {
page: 1,
limit
},
sort
} satisfies SearchPaginationSortRequest);
}
type QueryClientLike = {
query: <T>(options: { queryKey: unknown; queryFn: () => Promise<T> }) => Promise<T>;
};
type ParentWithQueryClient = () => Promise<unknown>;
export async function resolveListPageLoadContext(
parent: ParentWithQueryClient,
persistKey: string,
sort: NonNullable<SearchPaginationSortRequest['sort']>,
limit = 20
) {
const parentData = (await parent()) as { queryClient: QueryClientLike };
const envId = await environmentStore.getCurrentEnvironmentId();
const environments = await environmentStore.getShownEnvironments();
const requestOptions = resolveInitialListPageRequest(persistKey, sort, limit);
return {
queryClient: parentData.queryClient,
envId,
environments,
scope: environmentStore.shownKey,
requestOptions
};
}
export function transformPaginationParams(options?: SearchPaginationSortRequest): Record<string, any> {
const params: Record<string, any> = {};
if (!options) return params;
if (options.search) {
params['search'] = options.search;
}
if (options.pagination) {
const { page, limit } = options.pagination;
params['start'] = Math.max(0, (page - 1) * limit);
params['limit'] = limit;
}
if (options.sort) {
params['sort'] = options.sort.column;
params['order'] = options.sort.direction;
}
if (options.filters) {
Object.entries(options.filters).forEach(([key, value]) => {
if (Array.isArray(value)) {
params[key] = value.join(',');
} else {
params[key] = String(value);
}
});
}
if (typeof options.includeHidden === 'boolean') {
params['includeHidden'] = String(options.includeHidden);
}
if (typeof options.includeInternal === 'boolean') {
params['includeInternal'] = String(options.includeInternal);
}
return params;
}