feat(settings): restructure settings layout and separate route modules

This commit is contained in:
poyrazavsever
2026-07-20 10:25:40 +03:00
parent cc22c8ee1d
commit b424385667
34 changed files with 2867 additions and 1691 deletions
@@ -0,0 +1,120 @@
"use server";
import { revalidatePath } from "next/cache";
import { getSqliteConnection } from "@/server/db/client";
import { DomainError } from "@/server/domain/errors";
import { I18nService } from "@/server/i18n/service";
import { requireFreelancerBackend } from "@/server/web/freelancer";
import { cleanText } from "@/server/web/form-data";
export async function updateLanguageMetadataAction(
localeCode: string,
formData: FormData,
) {
const name = cleanText(formData.get("name")) ?? "";
const nativeName = cleanText(formData.get("nativeName")) ?? "";
const fallbackLocale = cleanText(formData.get("fallbackLocale")) ?? "";
const textDirection = cleanText(formData.get("textDirection")) ?? "";
if (!name || name.length > 80) {
return { errorKey: "settings.languageDetail.errors.name" };
}
if (!nativeName || nativeName.length > 80) {
return { errorKey: "settings.languageDetail.errors.nativeName" };
}
if (textDirection !== "ltr" && textDirection !== "rtl") {
return { errorKey: "settings.languageDetail.errors.direction" };
}
if (fallbackLocale === localeCode) {
return { errorKey: "settings.languageDetail.errors.selfFallback" };
}
try {
const { actor } = await requireFreelancerBackend();
const service = new I18nService(getSqliteConnection().db);
const current = service
.listLocales(actor)
.find((locale) => locale.code === localeCode);
if (!current) return { errorKey: "settings.languageDetail.errors.notFound" };
if (current.builtIn) {
return { errorKey: "settings.languageDetail.errors.builtInMetadata" };
}
const locale = service.updateLocale(actor, localeCode, {
name,
nativeName,
fallbackLocale,
textDirection,
});
revalidateLanguage(locale.code);
return { success: true };
} catch (error) {
console.error("Language metadata update failed", error);
if (error instanceof DomainError) {
if (error.details?.reason === "fallback_loop") {
return { errorKey: "settings.languageDetail.errors.fallbackLoop" };
}
if (error.details?.reason === "self_fallback") {
return { errorKey: "settings.languageDetail.errors.selfFallback" };
}
}
return { errorKey: "settings.languageDetail.errors.metadataFailed" };
}
}
export async function activateLanguageAction(localeCode: string) {
try {
const { actor } = await requireFreelancerBackend();
const service = new I18nService(getSqliteConnection().db);
const readiness = service.getLocaleReadiness(actor, localeCode);
if (!readiness.canActivate) {
return {
errorKey: "settings.languageDetail.errors.notReady",
missingCriticalCount: readiness.missingCriticalKeys.length,
};
}
service.updateLocale(actor, localeCode, { status: "active" });
revalidateLanguage(localeCode);
return { success: true };
} catch (error) {
console.error("Language activation failed", error);
return { errorKey: "settings.languageDetail.errors.activateFailed" };
}
}
export async function setDetailDefaultLocaleAction(localeCode: string) {
try {
const { actor } = await requireFreelancerBackend();
const service = new I18nService(getSqliteConnection().db);
service.setDefaultLocale(actor, localeCode);
revalidateLanguage(localeCode);
return { success: true };
} catch (error) {
console.error("Detail default locale update failed", error);
return { errorKey: "settings.languageDetail.errors.defaultFailed" };
}
}
export async function archiveLanguageAction(localeCode: string) {
try {
const { actor } = await requireFreelancerBackend();
const service = new I18nService(getSqliteConnection().db);
const readiness = service.getLocaleReadiness(actor, localeCode);
if (!readiness.canArchive) {
return { errorKey: "settings.languageDetail.errors.archiveBlocked" };
}
service.archiveLocale(actor, localeCode);
revalidateLanguage(localeCode);
return { success: true };
} catch (error) {
console.error("Language archive failed", error);
return { errorKey: "settings.languageDetail.errors.archiveFailed" };
}
}
function revalidateLanguage(localeCode: string) {
revalidatePath("/", "layout");
revalidatePath("/settings/language");
revalidatePath("/settings/languages");
revalidatePath(`/settings/languages/${localeCode}`);
}
@@ -0,0 +1,394 @@
"use client";
import Link from "next/link";
import { useRouter } from "next/navigation";
import { useState, useTransition } from "react";
import { AlertTriangle, ArrowLeft, CheckCircle2, Languages, Save, ShieldCheck } from "lucide-react";
import { Badge, Button, Card, CardContent, Input, Label, RadioGroup, RadioGroupItem } from "poyraz-ui/atoms";
import { Alert, AlertDescription, AlertTitle, Select, SelectContent, SelectItem, SelectTrigger, SelectValue, toast } from "poyraz-ui/molecules";
import { useTranslations } from "@/components/i18n/i18n-provider";
import { DestructiveConfirmation } from "@/components/system/destructive-confirmation";
import type { LocaleStatus, TextDirection } from "@/server/db/schema";
import type { LocaleReadiness, LocaleUsage, NamespaceCompletion } from "@/server/i18n/service";
import {
activateLanguageAction,
archiveLanguageAction,
setDetailDefaultLocaleAction,
updateLanguageMetadataAction,
} from "./actions";
type LocaleDetail = {
builtIn: boolean;
code: string;
fallbackLocale: string | null;
name: string;
nativeName: string;
status: LocaleStatus;
textDirection: TextDirection;
};
type LifecycleAction = "activate" | "archive" | "default";
export function LanguageDetail({
completion,
defaultLocale,
fallbackOptions,
locale,
namespaceCompletion,
readiness,
usage,
}: {
completion: number;
defaultLocale: string;
fallbackOptions: Array<{ code: string; nativeName: string }>;
locale: LocaleDetail;
namespaceCompletion: NamespaceCompletion[];
readiness: LocaleReadiness;
usage: LocaleUsage;
}) {
const t = useTranslations();
const router = useRouter();
const [fallbackLocale, setFallbackLocale] = useState(locale.fallbackLocale ?? "");
const [dialog, setDialog] = useState<LifecycleAction | null>(null);
const [pending, startTransition] = useTransition();
const isDefault = defaultLocale === locale.code;
const criticalComplete = readiness.missingCriticalKeys.length === 0;
function updateMetadata(formData: FormData) {
formData.set("fallbackLocale", fallbackLocale);
startTransition(async () => {
const result = await updateLanguageMetadataAction(locale.code, formData);
if (result.errorKey) {
toast.error(t(result.errorKey));
return;
}
toast.success(t("settings.languageDetail.messages.metadataSaved"));
router.refresh();
});
}
function confirmLifecycle() {
if (!dialog) return;
startTransition(async () => {
const result = dialog === "activate"
? await activateLanguageAction(locale.code)
: dialog === "default"
? await setDetailDefaultLocaleAction(locale.code)
: await archiveLanguageAction(locale.code);
if (result.errorKey) {
toast.error(t(result.errorKey, {
count: "missingCriticalCount" in result
? Number(
result.missingCriticalCount
?? readiness.missingCriticalKeys.length,
)
: readiness.archiveReferences,
}));
return;
}
toast.success(t(`settings.languageDetail.messages.${dialog}`));
setDialog(null);
router.refresh();
});
}
const dialogName = dialog ?? "activate";
return (
<div className="space-y-6">
<Card>
<CardContent className="space-y-7 p-6 sm:p-8">
<div className="flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between">
<div className="flex items-start gap-4">
<Button asChild size="icon-sm" variant="secondary" effect="shine">
<Link href="/settings/languages" aria-label={t("settings.languageDetail.actions.back")}>
<ArrowLeft className="h-4 w-4" aria-hidden="true" />
</Link>
</Button>
<div>
<div className="flex flex-wrap items-center gap-2">
<h2 className="text-xl font-semibold text-foreground">{locale.nativeName}</h2>
<Badge variant="secondary">{locale.code}</Badge>
<Badge variant="outline">
{t(`settings.languages.status.${locale.status}`)}
</Badge>
{locale.builtIn && (
<Badge variant="secondary">{t("settings.languages.badges.builtIn")}</Badge>
)}
{isDefault && (
<Badge variant="default">{t("settings.languages.badges.default")}</Badge>
)}
</div>
<p className="mt-1 text-sm text-muted-foreground">{locale.name}</p>
</div>
</div>
<Button asChild variant="secondary" effect="shine" className="gap-2">
<Link href="#translation-completion">
<Languages className="h-4 w-4" aria-hidden="true" />
{t("settings.languageDetail.actions.translations")}
</Link>
</Button>
</div>
{locale.builtIn ? (
<Alert>
<ShieldCheck className="h-4 w-4" aria-hidden="true" />
<AlertTitle>{t("settings.languageDetail.builtIn.title")}</AlertTitle>
<AlertDescription>
{t("settings.languageDetail.builtIn.description")}
</AlertDescription>
</Alert>
) : (
<form action={updateMetadata} className="max-w-3xl space-y-6 border-t border-border pt-7">
<div className="grid gap-5 sm:grid-cols-2">
<div className="space-y-2">
<Label htmlFor="detail-name">{t("settings.languageDetail.fields.name")}</Label>
<Input id="detail-name" name="name" defaultValue={locale.name} maxLength={80} required />
</div>
<div className="space-y-2">
<Label htmlFor="detail-native-name">
{t("settings.languageDetail.fields.nativeName")}
</Label>
<Input
id="detail-native-name"
name="nativeName"
defaultValue={locale.nativeName}
maxLength={80}
required
/>
</div>
</div>
<div className="grid gap-5 sm:grid-cols-2">
<div className="space-y-2">
<Label>{t("settings.languageDetail.fields.fallback")}</Label>
<Select value={fallbackLocale} onValueChange={setFallbackLocale}>
<SelectTrigger>
<SelectValue />
</SelectTrigger>
<SelectContent>
{fallbackOptions.map((option) => (
<SelectItem key={option.code} value={option.code}>
{option.nativeName} ({option.code})
</SelectItem>
))}
</SelectContent>
</Select>
</div>
<fieldset className="space-y-2">
<legend className="text-sm font-medium text-foreground">
{t("settings.languageDetail.fields.direction")}
</legend>
<RadioGroup
name="textDirection"
defaultValue={locale.textDirection}
className="grid grid-cols-2 gap-2"
>
{(["ltr", "rtl"] as const).map((direction) => (
<Label
key={direction}
htmlFor={`detail-direction-${direction}`}
className="flex cursor-pointer items-center gap-2 rounded-lg border border-border p-3"
>
<RadioGroupItem
id={`detail-direction-${direction}`}
value={direction}
/>
{t(`settings.languageNew.direction.${direction}`)}
</Label>
))}
</RadioGroup>
</fieldset>
</div>
<div className="flex justify-end">
<Button
type="submit"
variant="default"
effect="shine"
loading={pending}
className="gap-2"
>
<Save className="h-4 w-4" aria-hidden="true" />
{t("settings.languageDetail.actions.save")}
</Button>
</div>
</form>
)}
</CardContent>
</Card>
<div className="grid gap-6 xl:grid-cols-2">
<Card>
<CardContent className="space-y-5 p-6">
<div>
<h3 className="font-semibold text-foreground">
{t("settings.languageDetail.readiness.title")}
</h3>
<p className="text-sm text-muted-foreground">
{t("settings.languageDetail.readiness.description")}
</p>
</div>
<ReadinessRow
complete={criticalComplete}
label={t("settings.languageDetail.readiness.critical", {
count: readiness.missingCriticalKeys.length,
})}
/>
<ReadinessRow
complete={locale.status === "active"}
label={t("settings.languageDetail.readiness.active")}
/>
<ReadinessRow
complete={readiness.archiveReferences === 0}
label={t("settings.languageDetail.readiness.references", {
count: readiness.archiveReferences,
})}
/>
{!criticalComplete && (
<Alert variant="destructive">
<AlertTriangle className="h-4 w-4" aria-hidden="true" />
<AlertTitle>{t("settings.languageDetail.readiness.blockedTitle")}</AlertTitle>
<AlertDescription>
{t("settings.languageDetail.readiness.blockedDescription", {
count: readiness.missingCriticalKeys.length,
})}
</AlertDescription>
</Alert>
)}
<div className="flex flex-wrap gap-2 border-t border-border pt-5">
{locale.status !== "active" && (
<Button
type="button"
variant="default"
effect="shine"
disabled={!readiness.canActivate}
onClick={() => setDialog("activate")}
>
{t("settings.languageDetail.actions.activate")}
</Button>
)}
{!isDefault && (
<Button
type="button"
variant="secondary"
effect="shine"
disabled={!readiness.canSetDefault}
onClick={() => setDialog("default")}
>
{t("settings.languageDetail.actions.makeDefault")}
</Button>
)}
{!locale.builtIn && locale.status !== "archived" && (
<Button
type="button"
variant="secondary"
effect="shine"
disabled={!readiness.canArchive}
onClick={() => setDialog("archive")}
>
{t("settings.languageDetail.actions.archive")}
</Button>
)}
</div>
</CardContent>
</Card>
<Card>
<CardContent className="space-y-5 p-6">
<div>
<h3 className="font-semibold text-foreground">
{t("settings.languageDetail.usage.title")}
</h3>
<p className="text-sm text-muted-foreground">
{t("settings.languageDetail.usage.description")}
</p>
</div>
<div className="grid gap-3 sm:grid-cols-2">
{Object.entries(usage).map(([key, count]) => (
<div key={key} className="rounded-lg border border-border p-3">
<p className="text-xs text-muted-foreground">
{t(`settings.languageDetail.usage.${key}`)}
</p>
<p className="mt-1 text-lg font-semibold text-foreground">{count}</p>
</div>
))}
</div>
</CardContent>
</Card>
</div>
<Card id="translation-completion" className="scroll-mt-8">
<CardContent className="space-y-5 p-6">
<div className="flex items-end justify-between gap-4">
<div>
<h3 className="font-semibold text-foreground">
{t("settings.languageDetail.completion.title")}
</h3>
<p className="text-sm text-muted-foreground">
{t("settings.languageDetail.completion.description")}
</p>
</div>
<span className="text-2xl font-semibold text-foreground">{completion}%</span>
</div>
<div className="grid gap-3 sm:grid-cols-2 xl:grid-cols-3">
{namespaceCompletion.map((item) => (
<div key={item.namespace} className="rounded-lg border border-border p-4">
<div className="flex items-center justify-between gap-3">
<span className="text-sm font-medium text-foreground">
{t(`settings.languageDetail.namespaces.${item.namespace}`)}
</span>
<span className="text-xs text-muted-foreground">{item.percent}%</span>
</div>
<div className="mt-3 h-1.5 overflow-hidden rounded-full bg-muted">
<div
className="h-full rounded-full bg-primary"
style={{ width: `${item.percent}%` }}
/>
</div>
<p className="mt-2 text-xs text-muted-foreground">
{t("settings.languageDetail.completion.value", {
translated: item.translated,
total: item.total,
})}
</p>
</div>
))}
</div>
</CardContent>
</Card>
<DestructiveConfirmation
open={Boolean(dialog)}
onOpenChange={(open) => {
if (!open) setDialog(null);
}}
loading={pending}
title={t(`settings.languageDetail.dialog.${dialogName}.title`)}
description={t(`settings.languageDetail.dialog.${dialogName}.description`, {
language: locale.nativeName,
})}
cancelLabel={t("settings.languageDetail.dialog.cancel")}
confirmLabel={t(`settings.languageDetail.dialog.${dialogName}.confirm`)}
onConfirm={confirmLifecycle}
/>
</div>
);
}
function ReadinessRow({
complete,
label,
}: {
complete: boolean;
label: string;
}) {
return (
<div className="flex items-center gap-3 text-sm">
{complete ? (
<CheckCircle2 className="h-4 w-4 shrink-0 text-emerald-500" aria-hidden="true" />
) : (
<AlertTriangle className="h-4 w-4 shrink-0 text-amber-500" aria-hidden="true" />
)}
<span className="text-foreground">{label}</span>
</div>
);
}
@@ -0,0 +1,38 @@
import { notFound } from "next/navigation";
import { getSqliteConnection } from "@/server/db/client";
import { I18nService } from "@/server/i18n/service";
import { requireFreelancerBackend } from "@/server/web/freelancer";
import { LanguageDetail } from "./language-detail";
export default async function LanguageDetailPage({
params,
}: {
params: Promise<{ locale: string }>;
}) {
const { actor } = await requireFreelancerBackend();
const { locale: localeCode } = await params;
const service = new I18nService(getSqliteConnection().db);
const locales = service.listLocales(actor);
const locale = locales.find((item) => item.code === localeCode);
if (!locale) notFound();
const completion = service
.getCompletion(actor)
.find((item) => item.locale === locale.code)?.percent ?? 0;
return (
<LanguageDetail
locale={locale}
defaultLocale={service.getSettings(actor).defaultLocale}
completion={completion}
namespaceCompletion={service.getNamespaceCompletion(actor, locale.code)}
readiness={service.getLocaleReadiness(actor, locale.code)}
usage={service.getLocaleUsage(actor, locale.code)}
fallbackOptions={locales
.filter(
(item) => item.code !== locale.code && item.status !== "archived",
)
.map(({ code, nativeName }) => ({ code, nativeName }))}
/>
);
}
@@ -0,0 +1,25 @@
"use server";
import { revalidatePath } from "next/cache";
import { getSqliteConnection } from "@/server/db/client";
import { I18nService } from "@/server/i18n/service";
import { requireFreelancerBackend } from "@/server/web/freelancer";
export async function setInstanceDefaultLocaleAction(code: string) {
try {
const { actor } = await requireFreelancerBackend();
const service = new I18nService(getSqliteConnection().db);
const settings = service.setDefaultLocale(actor, code);
revalidateLanguageManagement();
return { success: true, defaultLocale: settings.defaultLocale };
} catch (error) {
console.error("Default locale update failed", error);
return { errorKey: "settings.languages.errors.defaultFailed" };
}
}
function revalidateLanguageManagement() {
revalidatePath("/", "layout");
revalidatePath("/settings/languages");
revalidatePath("/settings/language");
}
@@ -0,0 +1,209 @@
"use client";
import Link from "next/link";
import { useRouter } from "next/navigation";
import { useMemo, useState, useTransition } from "react";
import { Check, Languages, Plus, Settings2 } from "lucide-react";
import { Badge, Button, Card, CardContent } from "poyraz-ui/atoms";
import { toast } from "poyraz-ui/molecules";
import { useTranslations } from "@/components/i18n/i18n-provider";
import { DestructiveConfirmation } from "@/components/system/destructive-confirmation";
import type { LocaleStatus } from "@/server/db/schema";
import { setInstanceDefaultLocaleAction } from "./actions";
type LanguageListItem = {
builtIn: boolean;
code: string;
completion: number;
fallbackName: string | null;
name: string;
nativeName: string;
status: LocaleStatus;
usage: number;
};
const filters = ["all", "draft", "active", "archived"] as const;
type Filter = (typeof filters)[number];
export function LanguagesList({
initialDefaultLocale,
languages,
}: {
initialDefaultLocale: string;
languages: LanguageListItem[];
}) {
const t = useTranslations();
const router = useRouter();
const [filter, setFilter] = useState<Filter>("all");
const [defaultLocale, setDefaultLocale] = useState(initialDefaultLocale);
const [pendingLocale, setPendingLocale] = useState<LanguageListItem | null>(null);
const [pending, startTransition] = useTransition();
const filtered = useMemo(
() => filter === "all"
? languages
: languages.filter((language) => language.status === filter),
[filter, languages],
);
function confirmDefault() {
if (!pendingLocale) return;
startTransition(async () => {
const result = await setInstanceDefaultLocaleAction(pendingLocale.code);
if (result.errorKey) {
toast.error(t(result.errorKey));
return;
}
setDefaultLocale(result.defaultLocale ?? pendingLocale.code);
setPendingLocale(null);
toast.success(t("settings.languages.messages.defaultSaved"));
router.refresh();
});
}
return (
<Card>
<CardContent className="space-y-7 p-6 sm:p-8">
<div className="flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between">
<div className="space-y-1.5">
<h2 className="text-xl font-semibold text-foreground">
{t("settings.languages.title")}
</h2>
<p className="max-w-2xl text-sm text-muted-foreground">
{t("settings.languages.description")}
</p>
</div>
<Button asChild variant="default" effect="shine" className="gap-2">
<Link href="/settings/languages/new">
<Plus className="h-4 w-4" aria-hidden="true" />
{t("settings.languages.actions.add")}
</Link>
</Button>
</div>
<div
className="flex gap-2 overflow-x-auto border-y border-border py-4"
aria-label={t("settings.languages.filters.ariaLabel")}
>
{filters.map((item) => (
<Button
key={item}
type="button"
size="sm"
effect="shine"
variant={filter === item ? "default" : "secondary"}
onClick={() => setFilter(item)}
>
{t(`settings.languages.filters.${item}`)}
</Button>
))}
</div>
{filtered.length === 0 ? (
<div className="flex min-h-52 flex-col items-center justify-center rounded-xl border border-dashed border-border text-center">
<Languages className="mb-3 h-8 w-8 text-muted-foreground" aria-hidden="true" />
<h3 className="font-medium text-foreground">
{t("settings.languages.empty.title")}
</h3>
<p className="mt-1 text-sm text-muted-foreground">
{t("settings.languages.empty.description")}
</p>
</div>
) : (
<div className="space-y-3">
<div className="hidden grid-cols-[minmax(170px,1.4fr)_100px_minmax(120px,1fr)_110px_90px_minmax(200px,auto)] gap-4 px-4 text-xs font-medium text-muted-foreground lg:grid">
<span>{t("settings.languages.columns.language")}</span>
<span>{t("settings.languages.columns.status")}</span>
<span>{t("settings.languages.columns.fallback")}</span>
<span>{t("settings.languages.columns.completion")}</span>
<span>{t("settings.languages.columns.usage")}</span>
<span className="text-right">{t("settings.languages.columns.actions")}</span>
</div>
{filtered.map((language) => {
const isDefault = language.code === defaultLocale;
return (
<div
key={language.code}
className="grid gap-4 rounded-xl border border-border bg-card p-4 lg:grid-cols-[minmax(170px,1.4fr)_100px_minmax(120px,1fr)_110px_90px_minmax(200px,auto)] lg:items-center"
>
<div className="min-w-0">
<div className="flex flex-wrap items-center gap-2">
<span className="font-medium text-foreground">
{language.nativeName}
</span>
<Badge variant="secondary">{language.code}</Badge>
{language.builtIn && (
<Badge variant="outline">{t("settings.languages.badges.builtIn")}</Badge>
)}
{isDefault && (
<Badge variant="default">{t("settings.languages.badges.default")}</Badge>
)}
</div>
<p className="mt-1 text-xs text-muted-foreground">{language.name}</p>
</div>
<div>
<Badge variant={language.status === "archived" ? "outline" : "secondary"}>
{t(`settings.languages.status.${language.status}`)}
</Badge>
</div>
<span className="text-sm text-foreground">
{language.fallbackName ?? t("settings.languages.values.none")}
</span>
<div className="space-y-1">
<span className="text-sm font-medium text-foreground">
{language.completion}%
</span>
<div className="h-1.5 overflow-hidden rounded-full bg-muted">
<div
className="h-full rounded-full bg-primary"
style={{ width: `${language.completion}%` }}
/>
</div>
</div>
<span className="text-sm text-foreground">
{t("settings.languages.values.usage", { count: language.usage })}
</span>
<div className="flex flex-wrap justify-start gap-2 lg:justify-end">
{language.status === "active" && !isDefault && (
<Button
type="button"
size="sm"
variant="secondary"
effect="shine"
className="gap-1.5"
onClick={() => setPendingLocale(language)}
>
<Check className="h-3.5 w-3.5" aria-hidden="true" />
{t("settings.languages.actions.makeDefault")}
</Button>
)}
<Button asChild size="sm" variant="secondary" effect="shine" className="gap-1.5">
<Link href={`/settings/languages/${encodeURIComponent(language.code)}`}>
<Settings2 className="h-3.5 w-3.5" aria-hidden="true" />
{t("settings.languages.actions.manage")}
</Link>
</Button>
</div>
</div>
);
})}
</div>
)}
<DestructiveConfirmation
open={Boolean(pendingLocale)}
onOpenChange={(open) => {
if (!open) setPendingLocale(null);
}}
loading={pending}
title={t("settings.languages.defaultDialog.title")}
description={t("settings.languages.defaultDialog.description", {
language: pendingLocale?.nativeName ?? "",
})}
cancelLabel={t("settings.languages.defaultDialog.cancel")}
confirmLabel={t("settings.languages.defaultDialog.confirm")}
onConfirm={confirmDefault}
/>
</CardContent>
</Card>
);
}
@@ -0,0 +1,83 @@
"use server";
import { revalidatePath } from "next/cache";
import { getSqliteConnection } from "@/server/db/client";
import { DomainError } from "@/server/domain/errors";
import { I18nService } from "@/server/i18n/service";
import { requireFreelancerBackend } from "@/server/web/freelancer";
import { cleanText } from "@/server/web/form-data";
const SUPPORTED_BCP47_PATTERN = /^[a-z]{2}(?:-[A-Z]{2}[0-9]?)?$/;
export async function createLanguageAction(formData: FormData) {
const rawCode = cleanText(formData.get("code")) ?? "";
const name = cleanText(formData.get("name")) ?? "";
const nativeName = cleanText(formData.get("nativeName")) ?? "";
const fallbackLocale = cleanText(formData.get("fallbackLocale")) ?? "";
const textDirection = cleanText(formData.get("textDirection")) ?? "";
const code = canonicalizeSupportedLocale(rawCode);
if (!code) return { errorKey: "settings.languageNew.errors.code" };
if (!name || name.length > 80) {
return { errorKey: "settings.languageNew.errors.name" };
}
if (!nativeName || nativeName.length > 80) {
return { errorKey: "settings.languageNew.errors.nativeName" };
}
if (textDirection !== "ltr" && textDirection !== "rtl") {
return { errorKey: "settings.languageNew.errors.direction" };
}
if (fallbackLocale === code) {
return { errorKey: "settings.languageNew.errors.selfFallback" };
}
try {
const { actor } = await requireFreelancerBackend();
const service = new I18nService(getSqliteConnection().db);
const locales = service.listLocales(actor);
if (locales.some((locale) => locale.code === code)) {
return { errorKey: "settings.languageNew.errors.duplicate" };
}
if (
!fallbackLocale
|| !locales.some(
(locale) => locale.code === fallbackLocale && locale.status !== "archived",
)
) {
return { errorKey: "settings.languageNew.errors.fallback" };
}
const locale = service.createLocale(actor, {
code,
name,
nativeName,
fallbackLocale,
textDirection,
});
revalidatePath("/settings/languages");
return { success: true, locale: locale.code };
} catch (error) {
console.error("Language creation failed", error);
if (error instanceof DomainError) {
if (error.details?.reason === "fallback_loop") {
return { errorKey: "settings.languageNew.errors.fallbackLoop" };
}
if (error.details?.reason === "self_fallback") {
return { errorKey: "settings.languageNew.errors.selfFallback" };
}
if (error.code === "CONFLICT") {
return { errorKey: "settings.languageNew.errors.duplicate" };
}
}
return { errorKey: "settings.languageNew.errors.createFailed" };
}
}
function canonicalizeSupportedLocale(value: string): string | null {
try {
const [canonical] = Intl.getCanonicalLocales(value.replaceAll("_", "-"));
return canonical && SUPPORTED_BCP47_PATTERN.test(canonical) ? canonical : null;
} catch {
return null;
}
}
@@ -0,0 +1,169 @@
"use client";
import Link from "next/link";
import { useRouter } from "next/navigation";
import { useState, useTransition } from "react";
import { ArrowLeft, Languages, Save } from "lucide-react";
import { Button, Card, CardContent, Input, Label, RadioGroup, RadioGroupItem } from "poyraz-ui/atoms";
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue, toast } from "poyraz-ui/molecules";
import { useTranslations } from "@/components/i18n/i18n-provider";
import { createLanguageAction } from "./actions";
type FallbackOption = {
code: string;
nativeName: string;
};
export function NewLanguageForm({
defaultFallback,
fallbackOptions,
}: {
defaultFallback: string;
fallbackOptions: FallbackOption[];
}) {
const t = useTranslations();
const router = useRouter();
const [fallbackLocale, setFallbackLocale] = useState(defaultFallback);
const [pending, startTransition] = useTransition();
function submit(formData: FormData) {
formData.set("fallbackLocale", fallbackLocale);
startTransition(async () => {
const result = await createLanguageAction(formData);
if (result.errorKey) {
toast.error(t(result.errorKey));
return;
}
toast.success(t("settings.languageNew.messages.created"));
router.push(`/settings/languages/${encodeURIComponent(result.locale ?? "")}`);
});
}
return (
<Card>
<CardContent className="space-y-8 p-6 sm:p-8">
<div className="flex items-start gap-4">
<Button asChild size="icon-sm" variant="secondary" effect="shine">
<Link href="/settings/languages" aria-label={t("settings.languageNew.actions.back")}>
<ArrowLeft className="h-4 w-4" aria-hidden="true" />
</Link>
</Button>
<div className="space-y-1.5">
<h2 className="text-xl font-semibold text-foreground">
{t("settings.languageNew.title")}
</h2>
<p className="max-w-2xl text-sm text-muted-foreground">
{t("settings.languageNew.description")}
</p>
</div>
</div>
<div className="rounded-xl border border-border bg-muted/30 p-4 text-sm text-muted-foreground">
<div className="flex items-start gap-3">
<Languages className="mt-0.5 h-4 w-4 shrink-0" aria-hidden="true" />
<p>{t("settings.languageNew.draftNotice")}</p>
</div>
</div>
<form action={submit} className="max-w-2xl space-y-7">
<div className="grid gap-5 sm:grid-cols-2">
<div className="space-y-2">
<Label htmlFor="locale-code">{t("settings.languageNew.fields.code")}</Label>
<Input
id="locale-code"
name="code"
placeholder={t("settings.languageNew.placeholders.code")}
maxLength={12}
autoCapitalize="none"
required
/>
<p className="text-xs text-muted-foreground">
{t("settings.languageNew.help.code")}
</p>
</div>
<div className="space-y-2">
<Label htmlFor="language-name">{t("settings.languageNew.fields.name")}</Label>
<Input
id="language-name"
name="name"
placeholder={t("settings.languageNew.placeholders.name")}
maxLength={80}
required
/>
</div>
</div>
<div className="space-y-2">
<Label htmlFor="native-name">{t("settings.languageNew.fields.nativeName")}</Label>
<Input
id="native-name"
name="nativeName"
placeholder={t("settings.languageNew.placeholders.nativeName")}
maxLength={80}
required
/>
<p className="text-xs text-muted-foreground">
{t("settings.languageNew.help.nativeName")}
</p>
</div>
<div className="grid gap-5 sm:grid-cols-2">
<div className="space-y-2">
<Label>{t("settings.languageNew.fields.fallback")}</Label>
<Select value={fallbackLocale} onValueChange={setFallbackLocale}>
<SelectTrigger>
<SelectValue placeholder={t("settings.languageNew.placeholders.fallback")} />
</SelectTrigger>
<SelectContent>
{fallbackOptions.map((locale) => (
<SelectItem key={locale.code} value={locale.code}>
{locale.nativeName} ({locale.code})
</SelectItem>
))}
</SelectContent>
</Select>
<p className="text-xs text-muted-foreground">
{t("settings.languageNew.help.fallback")}
</p>
</div>
<fieldset className="space-y-2">
<legend className="text-sm font-medium text-foreground">
{t("settings.languageNew.fields.direction")}
</legend>
<RadioGroup
name="textDirection"
defaultValue="ltr"
className="grid grid-cols-2 gap-2"
>
{(["ltr", "rtl"] as const).map((direction) => (
<Label
key={direction}
htmlFor={`direction-${direction}`}
className="flex cursor-pointer items-center gap-2 rounded-lg border border-border p-3"
>
<RadioGroupItem id={`direction-${direction}`} value={direction} />
{t(`settings.languageNew.direction.${direction}`)}
</Label>
))}
</RadioGroup>
</fieldset>
</div>
<div className="flex justify-end border-t border-border pt-6">
<Button
type="submit"
variant="default"
effect="shine"
loading={pending}
className="gap-2"
>
<Save className="h-4 w-4" aria-hidden="true" />
{t("settings.languageNew.actions.create")}
</Button>
</div>
</form>
</CardContent>
</Card>
);
}
@@ -0,0 +1,22 @@
import { getSqliteConnection } from "@/server/db/client";
import { I18nService } from "@/server/i18n/service";
import { requireFreelancerBackend } from "@/server/web/freelancer";
import { NewLanguageForm } from "./new-language-form";
export default async function NewLanguagePage() {
const { actor } = await requireFreelancerBackend();
const service = new I18nService(getSqliteConnection().db);
const locales = service
.listLocales(actor)
.filter((locale) => locale.status !== "archived");
const defaultLocale = service.getSettings(actor).defaultLocale;
return (
<NewLanguageForm
defaultFallback={locales.some((locale) => locale.code === defaultLocale)
? defaultLocale
: locales[0]?.code ?? "tr"}
fallbackOptions={locales.map(({ code, nativeName }) => ({ code, nativeName }))}
/>
);
}
@@ -0,0 +1,37 @@
import { getSqliteConnection } from "@/server/db/client";
import { I18nService } from "@/server/i18n/service";
import { requireFreelancerBackend } from "@/server/web/freelancer";
import { LanguagesList } from "./languages-list";
export default async function LanguagesSettingsPage() {
const { actor } = await requireFreelancerBackend();
const service = new I18nService(getSqliteConnection().db);
const locales = service.listLocales(actor);
const settings = service.getSettings(actor);
const completion = new Map(
service.getCompletion(actor).map((item) => [item.locale, item.percent]),
);
const localeNames = new Map(locales.map((locale) => [locale.code, locale.nativeName]));
const languages = locales.map((locale) => {
const usage = service.getLocaleUsage(actor, locale.code);
return {
builtIn: locale.builtIn,
code: locale.code,
completion: completion.get(locale.code) ?? 0,
fallbackName: locale.fallbackLocale
? localeNames.get(locale.fallbackLocale) ?? locale.fallbackLocale
: null,
name: locale.name,
nativeName: locale.nativeName,
status: locale.status,
usage: usage.userPreferences + usage.clients + usage.portalInvitations,
};
});
return (
<LanguagesList
initialDefaultLocale={settings.defaultLocale}
languages={languages}
/>
);
}