Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
import { toast } from 'svelte-sonner';
import { z } from 'zod/v4';
import { m } from '#lib/paraglide/messages.js';
import { handleApiResultWithCallbacks } from '#lib/utils/api.js';
import { tryCatch } from '#lib/utils/try-catch.js';
export type TemplateEditorValidationState = {
composeValidationReady: boolean;
envValidationReady: boolean;
composeHasErrors: boolean;
envHasErrors: boolean;
};
type ResetField<T> = {
set: (value: T) => void;
value: T;
};
type ValidationResult<T> = T | undefined | false | null;
type RunTemplateEditorSaveOptions<TValidated, TResult> = {
validationState: TemplateEditorValidationState;
validate: () => ValidationResult<TValidated>;
save: (validated: TValidated) => Promise<TResult>;
failureMessage: string;
setLoading: (value: boolean) => void;
onSuccess: (validated: TValidated, result: TResult) => void | Promise<void>;
};
export function createNamedTemplateSchema() {
return z.object({
name: z.string().min(1, m.templates_template_name_required()),
description: z.string().optional().default(''),
composeContent: z.string().min(1, m.compose_content_is_required()),
envContent: z.string().optional().default('')
});
}
export function createTemplateContentSchema() {
return z.object({
composeContent: z.string().min(1, m.compose_content_is_required()),
envContent: z.string().optional().default('')
});
}
export function getTemplateEditorValidationState(
composeValidationReady: boolean,
envValidationReady: boolean,
composeHasErrors: boolean,
envHasErrors: boolean
): TemplateEditorValidationState {
return {
composeValidationReady,
envValidationReady,
composeHasErrors,
envHasErrors
};
}
export function getTemplateEditorSaveState(
validation: TemplateEditorValidationState,
hasChanges: boolean
): { validationState: TemplateEditorValidationState; canSave: boolean } {
const validationState = getTemplateEditorValidationState(
validation.composeValidationReady,
validation.envValidationReady,
validation.composeHasErrors,
validation.envHasErrors
);
return { validationState, canSave: hasChanges && !hasTemplateEditorErrors(validationState) };
}
export function hasTemplateEditorErrors(state: TemplateEditorValidationState): boolean {
return !state.composeValidationReady || !state.envValidationReady || state.composeHasErrors || state.envHasErrors;
}
export function validateTemplateEditorForm<T>(
state: TemplateEditorValidationState,
validate: () => ValidationResult<T>
): T | null {
if (hasTemplateEditorErrors(state)) {
toast.error(m.templates_validation_error());
return null;
}
const validated = validate();
if (!validated) {
toast.error(m.templates_validation_error());
return null;
}
return validated;
}
export async function runTemplateEditorSave<TValidated, TResult>({
validationState,
validate,
save,
failureMessage,
setLoading,
onSuccess
}: RunTemplateEditorSaveOptions<TValidated, TResult>) {
const validated = validateTemplateEditorForm(validationState, validate);
if (!validated) return;
setLoading(true);
await handleApiResultWithCallbacks({
result: await tryCatch((async () => await save(validated))()),
message: failureMessage,
setLoadingState: setLoading,
onSuccess: async (result) => {
await onSuccess(validated, result);
}
});
}
export function resetTemplateEditorFields<T>(fields: ResetField<T>[]) {
for (const field of fields) {
field.set(field.value);
}
toast.info(m.changes_reset());
}