@oktis-works/admin 0.4.13 → 0.4.15

package/dist/server/chunks/i18n_CH59YTvE.mjs

@@ -0,0 +1,1406 @@
+import { r as __exportAll } from "./rolldown-runtime_BMI-E3GI.mjs";
+import { createSignal, onMount } from "solid-js";
+//#region src/i18n/config.ts
+var SUPPORTED_LOCALES = [
+	"pt-BR",
+	"en",
+	"es-ES",
+	"ru",
+	"uk",
+	"tr",
+	"he",
+	"it",
+	"pl",
+	"zh-CN",
+	"ja",
+	"ar",
+	"sw",
+	"yo",
+	"zu",
+	"am",
+	"ha",
+	"ig"
+];
+var RTL_LOCALES = ["he", "ar"];
+var LOCALE_LABELS = {
+	"pt-BR": "Português (Brasil)",
+	"en": "English",
+	"es-ES": "Español",
+	"ru": "Русский",
+	"uk": "Українська",
+	"tr": "Türkçe",
+	"he": "עברית",
+	"it": "Italiano",
+	"pl": "Polski",
+	"zh-CN": "中文 (简体)",
+	"ja": "日本語",
+	"ar": "العربية",
+	"sw": "Kiswahili",
+	"yo": "Yorùbá",
+	"zu": "isiZulu",
+	"am": "አማርኛ",
+	"ha": "Hausa",
+	"ig": "Igbo"
+};
+var LOCALE_FLAGS = {
+	"pt-BR": "🇧🇷",
+	"en": "🇺🇸",
+	"es-ES": "🇪🇸",
+	"ru": "🇷🇺",
+	"uk": "🇺🇦",
+	"tr": "🇹🇷",
+	"he": "🇮🇱",
+	"it": "🇮🇹",
+	"pl": "🇵🇱",
+	"zh-CN": "🇨🇳",
+	"ja": "🇯🇵",
+	"ar": "🇸🇦",
+	"sw": "🇹🇿",
+	"yo": "🇳🇬",
+	"zu": "🇿🇦",
+	"am": "🇪🇹",
+	"ha": "🇳🇬",
+	"ig": "🇳🇬"
+};
+function isRTLLocale(locale) {
+	return RTL_LOCALES.includes(locale);
+}
+//#endregion
+//#region \0rolldown_dynamic_import_helper.js
+var _rolldown_dynamic_import_helper_default = (glob, path, segments) => {
+	const query = path.lastIndexOf("?");
+	const v = glob[query === -1 || query < path.lastIndexOf("/") ? path : path.slice(0, query)];
+	if (v) return typeof v === "function" ? v() : Promise.resolve(v);
+	return new Promise((_, reject) => {
+		(typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(reject.bind(null, /* @__PURE__ */ new Error("Unknown variable dynamic import: " + path + (path.split("/").length !== segments ? ". Note that variables only represent file names one level deep." : ""))));
+	});
+};
+//#endregion
+//#region src/i18n/loaders.ts
+var localeCache = /* @__PURE__ */ new Map();
+/** Carrega arquivo JSON de locale */
+async function loadLocale(locale) {
+	if (localeCache.has(locale)) return localeCache.get(locale);
+	try {
+		const module = await _rolldown_dynamic_import_helper_default(/* #__PURE__ */ Object.assign({
+			"./locales/ar.json": () => import("./ar_DMC8HaoP.mjs"),
+			"./locales/en.json": () => Promise.resolve().then(() => en_exports),
+			"./locales/es-ES.json": () => import("./es-ES_DZvHskAD.mjs"),
+			"./locales/he.json": () => import("./he_zy3stNhR.mjs"),
+			"./locales/it.json": () => import("./it_BiUDLszZ.mjs"),
+			"./locales/ja.json": () => import("./ja_DjFAG7hL.mjs"),
+			"./locales/pl.json": () => import("./pl_0Xe9Qom2.mjs"),
+			"./locales/pt-BR.json": () => import("./pt-BR_DIZpU2Mk.mjs"),
+			"./locales/ru.json": () => import("./ru_DFvIxd0Y.mjs"),
+			"./locales/sw.json": () => import("./sw_CmaPgGYa.mjs"),
+			"./locales/tr.json": () => import("./tr_B_acwl2e.mjs"),
+			"./locales/uk.json": () => import("./uk_DXnk4imL.mjs"),
+			"./locales/yo.json": () => import("./yo_DDQ8a-0v.mjs"),
+			"./locales/zh-CN.json": () => import("./zh-CN_763uzTMQ.mjs")
+		}), `./locales/${locale}.json`, 3);
+		const translations = module.default ?? module;
+		localeCache.set(locale, translations);
+		return translations;
+	} catch {
+		if (locale !== "en") return loadLocale("en");
+		return {};
+	}
+}
+//#endregion
+//#region src/lib/api.ts
+var API_BASE = "";
+var ApiClient = class {
+	baseUrl;
+	csrfToken = null;
+	refreshPromise = null;
+	refreshOwner = typeof globalThis.crypto?.randomUUID === "function" ? globalThis.crypto.randomUUID() : Math.random().toString(36).slice(2);
+	refreshLockKey = "okcms:auth:refresh-lock";
+	constructor(baseUrl = API_BASE) {
+		this.baseUrl = baseUrl;
+	}
+	/** Inicializa lendo CSRF do cookie (chamado no boot da app) */
+	async init() {
+		try {
+			await this.ensureCsrfToken();
+		} catch {}
+	}
+	/** Sessão válida — verifica via /me (usa cookies HttpOnly automaticamente) */
+	async isLoggedIn() {
+		try {
+			await this.request("GET", "/api/v1/auth/me");
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/** Obtém tenantId do backend via /me */
+	async getTenantId() {
+		try {
+			return (await this.request("GET", "/api/v1/auth/me")).tenantId ?? null;
+		} catch {
+			return null;
+		}
+	}
+	/** Obtém locale do usuário logado via /me/locale */
+	async getUserLocale() {
+		try {
+			return (await this.request("GET", "/api/v1/users/me/locale")).locale ?? "pt-BR";
+		} catch {
+			return "pt-BR";
+		}
+	}
+	/** Salva locale do usuário via /me/locale */
+	async setUserLocale(locale) {
+		await this.request("PUT", "/api/v1/users/me/locale", { locale });
+	}
+	/** Sessão atual (/auth/me) — usuário + tenant + papéis (alimenta o admin bar) */
+	async getMe() {
+		return this.request("GET", "/api/v1/auth/me");
+	}
+	/** Auditoria recente — notificações reais do sino no admin bar */
+	async getAuditLogs(limit = 8) {
+		return this.request("GET", `/api/v1/audit-logs?limit=${limit}`);
+	}
+	/** Login — o backend seta cookies HttpOnly e CSRF; retorna user + tenantId */
+	async login(input) {
+		await this.ensureCsrfToken();
+		return await this.request("POST", "/api/v1/auth/login", input);
+	}
+	/** Logout — limpa cookies no backend */
+	async logout() {
+		await this.request("POST", "/api/v1/auth/logout", {});
+		this.csrfToken = null;
+	}
+	/** Refresh de access token via cookie refresh_token */
+	async refreshTokens() {
+		if (this.refreshPromise) return this.refreshPromise;
+		this.refreshPromise = this.refreshWithCrossTabLock().finally(() => {
+			this.refreshPromise = null;
+		});
+		return this.refreshPromise;
+	}
+	async refreshWithCrossTabLock() {
+		if (typeof window === "undefined" || typeof localStorage === "undefined") {
+			await this.request("POST", "/api/v1/auth/refresh", {}, void 0, { skipRefresh: true });
+			return;
+		}
+		const now = Date.now();
+		let current;
+		try {
+			current = JSON.parse(localStorage.getItem(this.refreshLockKey) ?? "null");
+		} catch {
+			await this.request("POST", "/api/v1/auth/refresh", {}, void 0, { skipRefresh: true });
+			return;
+		}
+		if (current?.owner && current.owner !== this.refreshOwner && Number(current.expiresAt) > now) {
+			await this.waitForOtherTabRefresh(Number(current.expiresAt));
+			return;
+		}
+		try {
+			localStorage.setItem(this.refreshLockKey, JSON.stringify({
+				owner: this.refreshOwner,
+				expiresAt: now + 1e4
+			}));
+		} catch {
+			await this.request("POST", "/api/v1/auth/refresh", {}, void 0, { skipRefresh: true });
+			return;
+		}
+		try {
+			await this.request("POST", "/api/v1/auth/refresh", {}, void 0, { skipRefresh: true });
+		} finally {
+			try {
+				if (JSON.parse(localStorage.getItem(this.refreshLockKey) ?? "null")?.owner === this.refreshOwner) localStorage.removeItem(this.refreshLockKey);
+			} catch {}
+		}
+	}
+	async waitForOtherTabRefresh(expiresAt) {
+		while (Date.now() < Math.min(expiresAt, Date.now() + 1e4)) {
+			await new Promise((resolve) => setTimeout(resolve, 100));
+			try {
+				const lock = JSON.parse(localStorage.getItem(this.refreshLockKey) ?? "null");
+				if (!lock || Number(lock.expiresAt) <= Date.now()) return;
+			} catch {
+				return;
+			}
+		}
+	}
+	/** Requisição genérica com:
+	* - credentials: 'include' (envia cookies HttpOnly)
+	* - auto-refresh em 401
+	* - CSRF header para mutações
+	*/
+	async request(method, path, body, headers, options) {
+		const url = `${this.baseUrl}${path}`;
+		const send = async () => {
+			const requestHeaders = {
+				"Content-Type": "application/json",
+				...headers
+			};
+			if (![
+				"GET",
+				"HEAD",
+				"OPTIONS"
+			].includes(method.toUpperCase())) {
+				const csrf = await this.ensureCsrfToken();
+				if (csrf) requestHeaders["x-csrf-token"] = csrf;
+			}
+			return fetch(url, {
+				method,
+				headers: requestHeaders,
+				credentials: "include",
+				body: body ? JSON.stringify(body) : void 0
+			});
+		};
+		let response = await send();
+		if (response.status === 401 && !options?.skipRefresh && !path.includes("/auth/refresh") && !path.includes("/auth/logout")) {
+			await this.refreshTokens();
+			response = await send();
+		}
+		if (response.status === 403 && !options?.skipCsrfRecovery) {
+			let errorCode = "";
+			try {
+				errorCode = (await (typeof response.clone === "function" ? response.clone() : response).json()).error ?? "";
+			} catch {}
+			if (errorCode === "CSRF_TOKEN_INVALID") {
+				await this.ensureCsrfToken(true);
+				response = await send();
+			}
+		}
+		if (!response.ok) {
+			const error = await response.json().catch(() => ({ error: "Request failed" }));
+			throw new Error(error.error ?? `Request failed: ${response.status}`);
+		}
+		return response.json();
+	}
+	/** Garante um token CSRF sincronizado com o cookie do browser. */
+	async ensureCsrfToken(force = false) {
+		const cookieToken = this.readCsrfCookie();
+		if (!force && cookieToken) {
+			this.csrfToken = cookieToken;
+			return cookieToken;
+		}
+		if (!force && this.csrfToken) return this.csrfToken;
+		try {
+			const response = await fetch(`${this.baseUrl}/api/v1/auth/csrf`, {
+				credentials: "include",
+				headers: { Accept: "application/json" }
+			});
+			if (!response.ok) return this.csrfToken;
+			const data = await response.json();
+			this.csrfToken = data.csrfToken ?? this.readCsrfCookie();
+		} catch {}
+		return this.csrfToken;
+	}
+	readCsrfCookie() {
+		if (typeof document !== "undefined") {
+			const match = document.cookie.match(/(?:^|;\s*)csrf_token=([^;]+)/);
+			if (match?.[1]) return match[1];
+		}
+		return this.csrfToken;
+	}
+	async getContent(options) {
+		const params = new URLSearchParams();
+		if (options?.page) params.set("page", String(options.page));
+		if (options?.limit) params.set("limit", String(options.limit));
+		if (options?.type) params.set("type", options.type);
+		if (options?.status) params.set("status", options.status);
+		if (options?.search) params.set("search", options.search);
+		return this.request("GET", `/api/v1/content?${params.toString()}`);
+	}
+	async getContentById(id) {
+		return this.request("GET", `/api/v1/content/${id}`);
+	}
+	async createContent(data) {
+		return this.request("POST", `/api/v1/content`, data);
+	}
+	async updateContent(id, data) {
+		return this.request("PUT", `/api/v1/content/${id}`, data);
+	}
+	async deleteContent(id) {
+		await this.request("DELETE", `/api/v1/content/${id}`);
+	}
+	/** A2: publica via rota real do publisher (eventBus + cache + revisions). */
+	async publishContent(id) {
+		const response = await this.request("POST", `/api/v1/content/${id}/publish`);
+		return "content" in response ? response.content : response;
+	}
+	/** A2: despublica via rota real do publisher. */
+	async unpublishContent(id) {
+		const response = await this.request("POST", `/api/v1/content/${id}/unpublish`);
+		return "content" in response ? response.content : response;
+	}
+	/** Atalho usado pela ContentList: publish/unpublish conforme status atual. */
+	async publishToggle(id, isPublished) {
+		return isPublished ? this.unpublishContent(id) : this.publishContent(id);
+	}
+	async getContentTypes() {
+		return this.request("GET", "/api/v1/content-types");
+	}
+	async createContentType(data) {
+		return this.request("POST", "/api/v1/content-types", data);
+	}
+	async updateContentType(slug, data) {
+		return this.request("PUT", `/api/v1/content-types/${slug}`, data);
+	}
+	async deleteContentType(slug) {
+		await this.request("DELETE", `/api/v1/content-types/${slug}`);
+	}
+	async getTaxonomies() {
+		return this.request("GET", "/api/v1/taxonomies");
+	}
+	async createTaxonomy(data) {
+		return this.request("POST", "/api/v1/taxonomies", data);
+	}
+	async attachTaxonomy(slug, contentType) {
+		await this.request("POST", `/api/v1/taxonomies/${slug}/attach`, { contentType });
+	}
+	async detachTaxonomy(slug, contentType) {
+		await this.request("POST", `/api/v1/taxonomies/${slug}/detach`, { contentType });
+	}
+	async deleteTaxonomy(slug) {
+		await this.request("DELETE", `/api/v1/taxonomies/${slug}`);
+	}
+	async getTaxonomyTerms(slug) {
+		return this.request("GET", `/api/v1/taxonomies/${encodeURIComponent(slug)}/terms`);
+	}
+	async createTaxonomyTerm(slug, data) {
+		return this.request("POST", `/api/v1/taxonomies/${encodeURIComponent(slug)}/terms`, data);
+	}
+	async updateTaxonomyTerm(slug, id, data) {
+		return this.request("PUT", `/api/v1/taxonomies/${encodeURIComponent(slug)}/terms/${id}`, data);
+	}
+	async deleteTaxonomyTerm(slug, id) {
+		await this.request("DELETE", `/api/v1/taxonomies/${encodeURIComponent(slug)}/terms/${id}`);
+	}
+	async getCategories() {
+		return this.request("GET", "/api/v1/categories");
+	}
+	async createCategory(data) {
+		return this.request("POST", "/api/v1/categories", data);
+	}
+	async updateCategory(id, data) {
+		return this.request("PUT", `/api/v1/categories/${id}`, data);
+	}
+	async deleteCategory(id) {
+		await this.request("DELETE", `/api/v1/categories/${id}`);
+	}
+	async getTags() {
+		return this.request("GET", "/api/v1/tags");
+	}
+	async createTag(data) {
+		return this.request("POST", "/api/v1/tags", data);
+	}
+	async updateTag(id, data) {
+		return this.request("PUT", `/api/v1/tags/${id}`, data);
+	}
+	async deleteTag(id) {
+		await this.request("DELETE", `/api/v1/tags/${id}`);
+	}
+	async getMenus() {
+		return this.request("GET", "/api/v1/menus");
+	}
+	async createMenu(data) {
+		return this.request("POST", "/api/v1/menus", data);
+	}
+	async updateMenu(id, data) {
+		return this.request("PUT", `/api/v1/menus/${id}`, data);
+	}
+	async deleteMenu(id) {
+		await this.request("DELETE", `/api/v1/menus/${id}`);
+	}
+	async getFieldGroups(context) {
+		if (context?.type) {
+			const qs = new URLSearchParams({ type: context.type });
+			for (const [key, value] of Object.entries(context)) if (key !== "type" && value) qs.set(key, value);
+			return this.request("GET", `/api/v1/field-groups?${qs.toString()}`);
+		}
+		return this.request("GET", "/api/v1/field-groups");
+	}
+	async getFieldGroup(id) {
+		return this.request("GET", `/api/v1/field-groups/${id}`);
+	}
+	async createFieldGroup(data) {
+		return this.request("POST", "/api/v1/field-groups", data);
+	}
+	async updateFieldGroup(id, data) {
+		return this.request("PUT", `/api/v1/field-groups/${id}`, data);
+	}
+	async deleteFieldGroup(id) {
+		await this.request("DELETE", `/api/v1/field-groups/${id}`);
+	}
+	async getFieldTypes(category) {
+		const query = category ? `?category=${encodeURIComponent(category)}` : "";
+		return this.request("GET", `/api/v1/field-types${query}`);
+	}
+	async getWebhooks() {
+		return this.request("GET", "/api/v1/webhooks");
+	}
+	async createWebhook(data) {
+		return this.request("POST", "/api/v1/webhooks", data);
+	}
+	async updateWebhook(id, data) {
+		return this.request("PUT", `/api/v1/webhooks/${id}`, data);
+	}
+	async deleteWebhook(id) {
+		await this.request("DELETE", `/api/v1/webhooks/${id}`);
+	}
+	async getBuilds(options) {
+		const params = new URLSearchParams();
+		if (options?.page) params.set("page", String(options.page));
+		if (options?.limit) params.set("limit", String(options.limit));
+		if (options?.status) params.set("status", options.status);
+		return this.request("GET", `/api/v1/builds?${params.toString()}`);
+	}
+	async createBuild(data) {
+		return this.request("POST", "/api/v1/builds", data);
+	}
+	async getDeployments(options) {
+		const params = new URLSearchParams();
+		if (options?.page) params.set("page", String(options.page));
+		if (options?.limit) params.set("limit", String(options.limit));
+		if (options?.status) params.set("status", options.status);
+		return this.request("GET", `/api/v1/deployments?${params.toString()}`);
+	}
+	async createDeployment(data) {
+		return this.request("POST", "/api/v1/deployments", data);
+	}
+	async rollbackDeployment(id, rollbackToId) {
+		return this.request("POST", `/api/v1/deployments/${id}/rollback`, { rollbackToId });
+	}
+	async getEvents(options) {
+		const params = new URLSearchParams();
+		if (options?.page) params.set("page", String(options.page));
+		if (options?.limit) params.set("limit", String(options.limit));
+		if (options?.type) params.set("type", options.type);
+		return this.request("GET", `/api/v1/events?${params.toString()}`);
+	}
+	async listMedia(options) {
+		const params = new URLSearchParams();
+		if (options?.page) params.set("page", String(options.page));
+		if (options?.limit) params.set("limit", String(options.limit));
+		if (options?.mimeType) params.set("mimeType", options.mimeType);
+		if (options?.search) params.set("search", options.search);
+		return this.request("GET", `/api/v1/media?${params.toString()}`);
+	}
+	async getMedia(id) {
+		return this.request("GET", `/api/v1/media/${id}`);
+	}
+	/** Upload multipart — NÃO seta Content-Type (o fetch precisa do boundary). */
+	async uploadMedia(file, options) {
+		const formData = new FormData();
+		formData.append("file", file);
+		if (options?.alt) formData.append("alt", options.alt);
+		if (options?.caption) formData.append("caption", options.caption);
+		const url = `${this.baseUrl}/api/v1/media/upload`;
+		const send = async () => {
+			const csrf = await this.ensureCsrfToken();
+			const requestHeaders = {};
+			if (csrf) requestHeaders["x-csrf-token"] = csrf;
+			return fetch(url, {
+				method: "POST",
+				headers: requestHeaders,
+				credentials: "include",
+				body: formData
+			});
+		};
+		let response = await send();
+		if (response.status === 401) {
+			await this.refreshTokens();
+			response = await send();
+		}
+		if (response.status === 403) {
+			let errorCode = "";
+			try {
+				errorCode = (await response.clone().json()).error ?? "";
+			} catch {}
+			if (errorCode === "CSRF_TOKEN_INVALID") {
+				await this.ensureCsrfToken(true);
+				response = await send();
+			}
+		}
+		if (!response.ok) {
+			const error = await response.json().catch(() => ({ error: `Upload failed: ${response.status}` }));
+			throw new Error(error.error ?? `Upload failed: ${response.status}`);
+		}
+		return response.json();
+	}
+	async updateMedia(id, data) {
+		return this.request("PUT", `/api/v1/media/${id}`, data);
+	}
+	async deleteMedia(id) {
+		await this.request("DELETE", `/api/v1/media/${id}`);
+	}
+	async listUsers(options) {
+		const params = new URLSearchParams();
+		if (options?.page) params.set("page", String(options.page));
+		if (options?.limit) params.set("limit", String(options.limit));
+		if (options?.search) params.set("search", options.search);
+		if (options?.status) params.set("status", options.status);
+		return this.request("GET", `/api/v1/users?${params.toString()}`);
+	}
+	async getUser(id) {
+		return this.request("GET", `/api/v1/users/${id}`);
+	}
+	async createUser(data) {
+		return this.request("POST", "/api/v1/users", data);
+	}
+	async updateUser(id, data) {
+		return this.request("PUT", `/api/v1/users/${id}`, data);
+	}
+	async deleteUser(id) {
+		await this.request("DELETE", `/api/v1/users/${id}`);
+	}
+	async setUserPassword(id, password) {
+		await this.request("PUT", `/api/v1/users/${id}/password`, { password });
+	}
+	async assignRole(userId, roleId) {
+		return this.request("POST", `/api/v1/users/${userId}/roles`, { roleId });
+	}
+	async removeRole(userId, roleId) {
+		return this.request("DELETE", `/api/v1/users/${userId}/roles/${roleId}`);
+	}
+	async listRoles() {
+		return this.request("GET", "/api/v1/roles");
+	}
+	async createRole(data) {
+		return this.request("POST", "/api/v1/roles", data);
+	}
+	async updateRole(id, data) {
+		return this.request("PUT", `/api/v1/roles/${id}`, data);
+	}
+	async deleteRole(id) {
+		await this.request("DELETE", `/api/v1/roles/${id}`);
+	}
+	async listTenants(options) {
+		const params = new URLSearchParams();
+		if (options?.page) params.set("page", String(options.page));
+		if (options?.limit) params.set("limit", String(options.limit));
+		if (options?.search) params.set("search", options.search);
+		return this.request("GET", `/api/v1/tenants?${params.toString()}`);
+	}
+	async createTenant(data) {
+		return this.request("POST", "/api/v1/tenants", data);
+	}
+	async updateTenant(id, data) {
+		return this.request("PUT", `/api/v1/tenants/${id}`, data);
+	}
+	async deleteTenant(id) {
+		await this.request("DELETE", `/api/v1/tenants/${id}`);
+	}
+	async getSettings(group) {
+		const query = group ? `?group=${encodeURIComponent(group)}` : "";
+		return this.request("GET", `/api/v1/settings${query}`);
+	}
+	async updateSettings(items) {
+		await this.request("PUT", "/api/v1/settings", items);
+	}
+	async healthCheck() {
+		return this.request("GET", "/health");
+	}
+	async getThemes() {
+		return (await this.request("GET", "/api/v1/themes")).map((theme) => ({
+			id: String(theme["id"] ?? ""),
+			name: String(theme["name"] ?? ""),
+			version: theme["version"] ? String(theme["version"]) : void 0,
+			status: String(theme["status"] ?? "INSTALLED"),
+			manifest: theme["manifest"] ?? null
+		}));
+	}
+	async activateTheme(id) {
+		return this.request("POST", `/api/v1/themes/${id}/activate`);
+	}
+	async deactivateTheme(id) {
+		return this.request("POST", `/api/v1/themes/${id}/deactivate`);
+	}
+	async installTheme(data) {
+		return this.request("POST", "/api/v1/themes/install", data);
+	}
+	async uninstallTheme(id) {
+		await this.request("DELETE", `/api/v1/themes/${id}`);
+	}
+	async getPlugins() {
+		return (await this.request("GET", "/api/v1/plugins")).map((plugin) => ({
+			id: String(plugin["id"] ?? ""),
+			name: String(plugin["name"] ?? ""),
+			version: String(plugin["version"] ?? ""),
+			status: String(plugin["status"] ?? "INSTALLED"),
+			manifest: plugin["manifest"] ?? null
+		}));
+	}
+	async activatePlugin(id) {
+		return this.request("POST", `/api/v1/plugins/${id}/activate`);
+	}
+	async deactivatePlugin(id) {
+		return this.request("POST", `/api/v1/plugins/${id}/deactivate`);
+	}
+	async installPlugin(data) {
+		return this.request("POST", "/api/v1/plugins/install", data);
+	}
+	async uninstallPlugin(id) {
+		await this.request("DELETE", `/api/v1/plugins/${id}`);
+	}
+};
+var apiClient = new ApiClient();
+//#endregion
+//#region src/i18n/locale.ts
+var LOCALE_COOKIE = "admin_locale";
+/** Obtém locale do cookie */
+function getCookieLocale() {
+	if (typeof document === "undefined") return null;
+	const match = document.cookie.match(new RegExp(`(?:^|; )${LOCALE_COOKIE}=([^;]+)`));
+	if (match?.[1] && SUPPORTED_LOCALES.includes(match[1])) return match[1];
+	return null;
+}
+/** Define locale no cookie (1 ano) */
+function setCookieLocale(locale) {
+	if (typeof document === "undefined") return;
+	document.cookie = `${LOCALE_COOKIE}=${locale}; path=/; max-age=31536000; SameSite=Lax`;
+}
+/** Obtém locale do Accept-Language header */
+function getBrowserLocale() {
+	if (typeof navigator === "undefined") return "en";
+	const lang = navigator.language?.split("-")[0]?.toLowerCase();
+	const fullLang = navigator.language?.toLowerCase();
+	for (const locale of SUPPORTED_LOCALES) if (locale.toLowerCase() === fullLang || locale.split("-")[0] === lang) return locale;
+	return "en";
+}
+/** Obtém locale do usuário logado via API */
+async function getUserLocaleFromAPI() {
+	try {
+		const locale = await apiClient.getUserLocale();
+		if (locale && SUPPORTED_LOCALES.includes(locale)) return locale;
+	} catch {}
+	return null;
+}
+/** Salva locale do usuário via API */
+async function setUserLocaleInAPI(locale) {
+	await apiClient.setUserLocale(locale);
+}
+/** Resolve locale final com prioridade: cookie → user API → browser → default */
+async function resolveLocale() {
+	const cookie = getCookieLocale();
+	if (cookie) return cookie;
+	const user = await getUserLocaleFromAPI();
+	if (user) return user;
+	const browser = getBrowserLocale();
+	if (browser) return browser;
+	return "en";
+}
+/** Muda locale (salva no cookie + API se logado) */
+async function changeLocale(locale) {
+	setCookieLocale(locale);
+	try {
+		await setUserLocaleInAPI(locale);
+	} catch {}
+}
+//#endregion
+//#region src/i18n/locales/en.json
+var en_exports = /* @__PURE__ */ __exportAll({
+	access: () => access,
+	activity: () => activity,
+	adminBar: () => adminBar,
+	common: () => common,
+	content: () => content,
+	dashboard: () => dashboard,
+	default: () => en_default,
+	footer: () => footer,
+	helpTabs: () => helpTabs,
+	layout: () => layout,
+	login: () => login,
+	media: () => media,
+	operations: () => operations,
+	plugins: () => plugins,
+	resources: () => resources,
+	screenOptions: () => screenOptions,
+	settings: () => settings,
+	themes: () => themes,
+	users: () => users
+});
+var layout = {
+	"appName": "OkCMS",
+	"admin": "Admin",
+	"nav": {
+		"dashboard": "Dashboard",
+		"content": "Content",
+		"media": "Media",
+		"users": "Users",
+		"settings": "Settings",
+		"plugins": "Plugins",
+		"themes": "Themes"
+	},
+	"actions": {
+		"logout": "Logout",
+		"newPost": "New Post",
+		"uploadMedia": "Upload Media",
+		"addUser": "Add User",
+		"openSettings": "Settings"
+	}
+};
+var dashboard = {
+	"title": "Dashboard",
+	"stats": {
+		"totalContent": "Total Content",
+		"published": "Published",
+		"drafts": "Drafts",
+		"mediaFiles": "Media Files",
+		"users": "Users"
+	},
+	"recent": {
+		"title": "Recent Content",
+		"viewAll": "View All",
+		"empty": "No content yet — create your first!",
+		"columns": {
+			"title": "Title",
+			"type": "Type",
+			"status": "Status",
+			"updated": "Updated"
+		}
+	},
+	"widgets": {
+		"atGlance": "At a Glance",
+		"posts": "Posts",
+		"postsDesc": "Published / Drafts / Trash",
+		"pages": "Pages",
+		"pagesDesc": "Published / Drafts / Trash",
+		"media": "Media",
+		"mediaDesc": "Files in the library",
+		"users": "Users",
+		"usersDesc": "Total / Active / Inactive",
+		"version": "Version",
+		"storage": "Storage",
+		"quickDraft": {
+			"title": "Quick Draft",
+			"heading": "Title",
+			"headingPlaceholder": "Give your draft a title",
+			"content": "Content",
+			"contentPlaceholder": "What's on your mind?",
+			"save": "Save Draft",
+			"yourDrafts": "Your Drafts",
+			"noDrafts": "No drafts yet."
+		},
+		"activity": {
+			"title": "Activity",
+			"empty": "No activity yet."
+		}
+	}
+};
+var content = {
+	"list": {
+		"title": "Content",
+		"description": "Search, filter, edit and publish your content.",
+		"columns": {
+			"title": "Title",
+			"type": "Type",
+			"status": "Status",
+			"updated": "Updated"
+		},
+		"actions": {
+			"edit": "Edit",
+			"publish": "Publish",
+			"unpublish": "Unpublish",
+			"delete": "Delete"
+		},
+		"filters": {
+			"search": "Search content…",
+			"allTypes": "All types",
+			"allStatus": "All status"
+		},
+		"buttons": {
+			"new": "+ New content",
+			"search": "Search"
+		},
+		"empty": "No content found.",
+		"statuses": {
+			"draft": "Draft",
+			"published": "Published",
+			"archived": "Archived"
+		},
+		"confirmDelete": "Delete \"{title}\"?",
+		"toasts": {
+			"published": "Content published ✓",
+			"unpublished": "Content unpublished ✓"
+		}
+	},
+	"editor": {
+		"type": "Type",
+		"title": "Title",
+		"slug": "Slug",
+		"excerpt": "Excerpt",
+		"featuredImage": "Featured Image (media ID)",
+		"status": "Status",
+		"statusOptions": {
+			"draft": "Draft",
+			"published": "Published",
+			"archived": "Archived"
+		},
+		"layout": "Layout",
+		"layoutAuto": "Automatic (theme hierarchy)",
+		"customFields": "Custom Fields",
+		"inspectTypes": "Inspect available types",
+		"save": "Save",
+		"saved": "Content saved successfully."
+	}
+};
+var media = {
+	"title": "Media Library",
+	"description": "Upload and manage images, videos and documents. Files are stored in `uploads/` and served publicly.",
+	"upload": {
+		"dropzone": "Drop files here or",
+		"select": "Select files",
+		"uploading": "Uploading…",
+		"hint": "Images, videos, audio and documents · up to 25MB per file"
+	},
+	"toolbar": {
+		"search": "Search by name or alt…",
+		"allTypes": "All types",
+		"searchBtn": "Search"
+	},
+	"mimeTypes": {
+		"png": "PNG",
+		"jpeg": "JPEG",
+		"gif": "GIF",
+		"webp": "WebP",
+		"svg": "SVG",
+		"pdf": "PDF",
+		"mp4": "MP4",
+		"mp3": "MP3"
+	},
+	"empty": "No files yet. Upload the first one!",
+	"details": {
+		"title": "Details",
+		"file": "File",
+		"type": "Type",
+		"size": "Size",
+		"url": "URL",
+		"copy": "Copy",
+		"alt": "Alt text",
+		"caption": "Caption",
+		"save": "Save details",
+		"delete": "Delete",
+		"close": "Close",
+		"confirmDelete": "Delete \"{filename}\"? The file will be removed from disk.",
+		"saved": "Details saved ✓",
+		"copied": "URL copied ✓",
+		"copyError": "Could not copy URL"
+	},
+	"toasts": { "uploaded": "{count} file(s) uploaded ✓" }
+};
+var users = {
+	"title": "Users",
+	"description": "Manage accounts, roles and project access.",
+	"new": "New User",
+	"toolbar": {
+		"search": "Search by name or email…",
+		"allStatus": "All status",
+		"active": "Active",
+		"inactive": "Inactive",
+		"newBtn": "+ New user",
+		"searchBtn": "Search"
+	},
+	"table": {
+		"name": "Name",
+		"email": "Email",
+		"role": "Role",
+		"status": "Status",
+		"lastAccess": "Last access",
+		"actions": {
+			"manage": "Manage",
+			"delete": "Delete"
+		}
+	},
+	"empty": "No users found.",
+	"noRole": "No role",
+	"detail": {
+		"title": "Manage user",
+		"fields": {
+			"name": "Name",
+			"email": "Email",
+			"status": "Status",
+			"role": "Role",
+			"password": "Password"
+		},
+		"statusOptions": {
+			"active": "Active",
+			"inactive": "Inactive"
+		},
+		"rolePlaceholder": "— no role —",
+		"meta": "Created on {created} · last access {lastAccess}",
+		"actions": {
+			"save": "Save",
+			"resetPassword": "Reset password",
+			"close": "Close"
+		},
+		"passwordPrompt": "New password for {email} (minimum 8 chars):",
+		"passwordError": "Password must be at least 8 characters",
+		"toasts": {
+			"roleUpdated": "Role for {name} updated ✓",
+			"passwordChanged": "Password for {name} changed ✓",
+			"saved": "User {name} saved ✓",
+			"deleted": "User {name} deleted ✓"
+		},
+		"confirmDelete": "Delete user {email}?"
+	}
+};
+var settings = {
+	"general": {
+		"title": "General",
+		"description": "Basic information displayed on the site.",
+		"back": "← All settings",
+		"fields": {
+			"siteTitle": "Site Title",
+			"siteTitlePlaceholder": "My Site",
+			"siteDescription": "Description",
+			"siteDescriptionPlaceholder": "A new site built with OkCMS",
+			"language": "Language",
+			"timezone": "Timezone",
+			"timezonePlaceholder": "America/Sao_Paulo"
+		},
+		"saved": "Settings saved ✓",
+		"loading": "Loading…",
+		"save": "Save"
+	},
+	"postTypes": {
+		"title": "Content Types",
+		"description": "Create custom content types (CPTs) beyond Posts and Pages.",
+		"form": {
+			"title": "Create Content Type",
+			"slug": "Slug (singular, e.g.: portfolio)",
+			"slugHint": "Only lowercase letters, numbers and underscore",
+			"singular": "Singular name",
+			"plural": "Plural name",
+			"supports": "Supports",
+			"supportsOptions": {
+				"title": "Title",
+				"editor": "Editor",
+				"thumbnail": "Featured Image",
+				"excerpt": "Excerpt",
+				"revisions": "Revisions"
+			},
+			"hasArchive": "Has public archive (/slug)",
+			"create": "Create"
+		},
+		"table": {
+			"slug": "Slug",
+			"singular": "Singular",
+			"plural": "Plural",
+			"source": "Source",
+			"supports": "Supports",
+			"archive": "Archive",
+			"actions": { "remove": "Remove" }
+		},
+		"sources": {
+			"admin": "Admin",
+			"core": "Core"
+		}
+	},
+	"taxonomies": {
+		"title": "Taxonomies",
+		"description": "Create custom taxonomies and link them to content types.",
+		"form": {
+			"title": "Create Taxonomy",
+			"name": "Name (e.g.: Genre)",
+			"slug": "Slug (optional, generated from name)",
+			"slugHint": "Only lowercase letters, numbers and underscore",
+			"hierarchical": "Hierarchical (allows parent/child terms)",
+			"attachTo": "Link to content types",
+			"create": "Create"
+		},
+		"table": {
+			"taxonomy": "Taxonomy",
+			"hierarchical": "Hierarchical",
+			"attachedTypes": "Linked content types",
+			"actions": { "remove": "Remove" }
+		}
+	},
+	"customFields": {
+		"title": "Custom Fields",
+		"description": "Create field groups, arrange fields and choose which standard fields are visible for each content type.",
+		"contentType": "Content type",
+		"location": {
+			"title": "Location rules",
+			"description": "Choose where this field group appears. Rules in the same group use AND; groups use OR.",
+			"parameter": "Location parameter",
+			"operator": "Operator",
+			"chooseValue": "Choose a value",
+			"valuePlaceholder": "Enter a value or slug",
+			"required": "Add a value to every location rule.",
+			"addRule": "Add condition",
+			"addGroup": "Add OR group",
+			"remove": "Remove",
+			"and": "AND",
+			"or": "OR",
+			"params": {
+				"content_type": "Post type",
+				"content_slug": "Post slug",
+				"taxonomy": "Taxonomy",
+				"term": "Term slug",
+				"user_role": "User role",
+				"page_template": "Page template",
+				"post_status": "Post status"
+			},
+			"operators": {
+				"eq": "is",
+				"neq": "is not"
+			}
+		},
+		"standard": {
+			"title": "Standard fields",
+			"description": "Title and slug are required. The other standard fields can be enabled or disabled.",
+			"enabled": "Enabled",
+			"locked": "Required",
+			"fields": {
+				"title": "Title",
+				"slug": "Slug",
+				"content": "Content",
+				"excerpt": "Excerpt",
+				"featured_image": "Featured image",
+				"seo_title": "SEO title",
+				"seo_description": "SEO description",
+				"status": "Status",
+				"author": "Author"
+			}
+		},
+		"groups": {
+			"title": "Field groups",
+			"new": "New field group",
+			"empty": "No custom field groups yet.",
+			"fields": "fields",
+			"edit": "Edit",
+			"active": "Active",
+			"inactive": "Inactive"
+		},
+		"form": {
+			"createTitle": "Create field group",
+			"editTitle": "Edit field group",
+			"title": "Group name",
+			"titlePlaceholder": "Example: Product details",
+			"position": "Position",
+			"positions": {
+				"normal": "Normal",
+				"side": "Sidebar",
+				"acf_after_title": "After title"
+			},
+			"displayStyle": "Display style",
+			"displayStyles": {
+				"standard": "Standard",
+				"seamless": "Seamless",
+				"grouped": "Grouped"
+			},
+			"field": "Field",
+			"fieldName": "Name/key",
+			"fieldNamePlaceholder": "product_code",
+			"fieldLabel": "Label",
+			"fieldLabelPlaceholder": "Product code",
+			"fieldType": "Type",
+			"instructions": "Instructions",
+			"instructionsPlaceholder": "Optional help text for editors",
+			"required": "Required",
+			"options": "Options",
+			"optionsHint": "One option per line: value|Label",
+			"addField": "Add field",
+			"removeField": "Remove",
+			"dragHint": "Drag to reorder",
+			"save": "Save group",
+			"cancel": "Cancel",
+			"newFieldDefault": "New field",
+			"saved": "Field group saved.",
+			"deleted": "Field group deleted."
+		},
+		"actions": {
+			"delete": "Delete",
+			"confirmDelete": "Delete this field group?"
+		},
+		"loading": "Loading custom fields…",
+		"loadError": "Could not load custom fields."
+	}
+};
+var resources = {
+	"title": "Content Resources",
+	"description": "Description",
+	"tabs": {
+		"category": "Categories",
+		"tag": "Tags",
+		"menu": "Menus"
+	},
+	"new": "New resource",
+	"name": "Name",
+	"slug": "Slug",
+	"items": "Menu items (JSON)",
+	"saved": "Resource saved.",
+	"confirmDelete": "Delete this resource?",
+	"form": {
+		"new": "Create resource",
+		"edit": "Edit resource"
+	},
+	"terms": {
+		"title": "Taxonomy terms",
+		"choose": "Choose a taxonomy",
+		"new": "New term"
+	}
+};
+var access = {
+	"title": "Access",
+	"description": "Manage roles, permissions and tenants.",
+	"roles": "Roles",
+	"tenants": "Tenants",
+	"permissions": "Permissions (comma separated)",
+	"domain": "Domain"
+};
+var operations = {
+	"title": "Operations",
+	"description": "Manage webhooks, builds, deployments and events.",
+	"webhooks": "Webhooks",
+	"events": "Events",
+	"secret": "Secret",
+	"builds": "Builds",
+	"deployments": "Deployments",
+	"createBuild": "Create build",
+	"deploy": "Deploy"
+};
+var plugins = {
+	"title": "Plugins",
+	"description": "Manage installed plugins.",
+	"columns": {
+		"name": "Name",
+		"version": "Version",
+		"status": "Status",
+		"actions": "Actions"
+	},
+	"status": {
+		"active": "Active",
+		"installed": "Installed",
+		"inactive": "Inactive"
+	},
+	"activate": "Activate",
+	"deactivate": "Deactivate",
+	"install": "Install plugin",
+	"uninstall": "Uninstall",
+	"confirmUninstall": "Uninstall {name}?",
+	"name": "Plugin name",
+	"version": "Version",
+	"manifest": "Manifest (JSON)",
+	"loadError": "Could not load plugins.",
+	"activateError": "Could not activate the plugin.",
+	"deactivateError": "Could not deactivate the plugin.",
+	"installError": "Could not install the plugin.",
+	"uninstallError": "Could not uninstall the plugin.",
+	"empty": "No plugins installed."
+};
+var themes = {
+	"title": "Themes",
+	"description": "Manage installed themes.",
+	"version": "Version",
+	"active": "Active",
+	"status": {
+		"active": "Active",
+		"installed": "Installed",
+		"inactive": "Inactive"
+	},
+	"activate": "Activate",
+	"deactivate": "Deactivate",
+	"install": "Install theme",
+	"uninstall": "Uninstall",
+	"confirmUninstall": "Uninstall {name}?",
+	"name": "Theme name",
+	"manifest": "Manifest (JSON)",
+	"loadError": "Could not load themes.",
+	"activateError": "Could not activate the theme.",
+	"deactivateError": "Could not deactivate the theme.",
+	"installError": "Could not install the theme.",
+	"uninstallError": "Could not uninstall the theme.",
+	"empty": "No themes installed."
+};
+var login = {
+	"title": "Login",
+	"subtitle": "Sign in to your account",
+	"email": "Email",
+	"password": "Password",
+	"submit": "Sign In",
+	"failed": "Invalid email or password"
+};
+var common = {
+	"save": "Save",
+	"cancel": "Cancel",
+	"delete": "Delete",
+	"edit": "Edit",
+	"close": "Close",
+	"confirm": "Confirm",
+	"loading": "Loading…",
+	"yes": "Yes",
+	"no": "No",
+	"search": "Search",
+	"filter": "Filter",
+	"create": "Create",
+	"update": "Update",
+	"remove": "Remove",
+	"viewAll": "View All",
+	"back": "Back",
+	"next": "Next",
+	"previous": "Previous",
+	"page": "Page",
+	"of": "of",
+	"items": "items",
+	"item": "item",
+	"empty": "No {items} found.",
+	"toast": {
+		"success": "✓",
+		"error": "Error: {message}"
+	},
+	"status": {
+		"active": "Active",
+		"inactive": "Inactive",
+		"draft": "Draft",
+		"published": "Published",
+		"archived": "Archived",
+		"locked": "Locked"
+	},
+	"language": "Language"
+};
+var activity = {
+	"justNow": "just now",
+	"minAgo": "minutes ago",
+	"ago": "ago",
+	"published": "Published",
+	"updated": "Updated",
+	"newUser": "New user: {name}"
+};
+var adminBar = {
+	"mainMenu": "Main menu",
+	"notifications": "Notifications",
+	"notificationsEmpty": "No recent activity",
+	"settings": "Settings",
+	"toggleSidebar": "Toggle sidebar",
+	"userMenu": "User menu"
+};
+var footer = {
+	"copyright": "© 2026 OkCMS. All rights reserved.",
+	"links": "Links",
+	"website": "Website",
+	"github": "GitHub",
+	"docs": "Documentation",
+	"community": "Community",
+	"poweredBy": "Powered by OkCMS"
+};
+var helpTabs = {
+	"title": "Help",
+	"label": "Help",
+	"tabs": "Help topics",
+	"topics": {
+		"overview": {
+			"label": "Overview",
+			"content": "<h4>Welcome to the OkCMS Dashboard</h4><p>This dashboard gives you an overview of your site's content and activity.</p><h4>Available Widgets</h4><ul><li><strong>At a Glance:</strong> overview of posts, pages, media, and users</li><li><strong>Quick Draft:</strong> save drafts quickly from the dashboard</li><li><strong>Activity:</strong> recent site activity and updates</li></ul>"
+		},
+		"content": {
+			"label": "Content Management",
+			"content": "<h4>Managing Content</h4><p>Create, edit, and publish content from the Content section.</p><h4>Quick Actions</h4><ul><li>Click \"New Content\" to create a new post or page</li><li>Use filters to find specific content</li><li>Bulk actions available for multiple items</li></ul>"
+		},
+		"media": {
+			"label": "Media Library",
+			"content": "<h4>Managing Media</h4><p>Upload and manage images, videos, and documents.</p><h4>Tips</h4><ul><li>Drag and drop files to upload</li><li>Add alt text for accessibility</li><li>Organize with folders (coming soon)</li></ul>"
+		}
+	}
+};
+var screenOptions = {
+	"title": "Screen Options",
+	"label": "Screen Options",
+	"showOnScreen": "Show on screen"
+};
+var en_default = {
+	layout,
+	dashboard,
+	content,
+	media,
+	users,
+	settings,
+	resources,
+	access,
+	operations,
+	plugins,
+	themes,
+	login,
+	common,
+	activity,
+	adminBar,
+	footer,
+	helpTabs,
+	screenOptions
+};
+//#endregion
+//#region src/i18n/index.ts
+var tFunctionCache = /* @__PURE__ */ new Map();
+var initialTranslations = en_default;
+var [translationVersion, notifyTranslationChange] = createSignal(0);
+var translationLoadPromise = null;
+function humanizeKey(key) {
+	return (key.split(".").at(-1) ?? key).replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/^\w/, (letter) => letter.toUpperCase());
+}
+/** Cria função de tradução para um locale */
+function createTFunction(translations, fallback) {
+	return function t(key, params) {
+		const keys = key.split(".");
+		let value = translations;
+		for (const k of keys) if (value && typeof value === "object" && k in value) value = value[k];
+		else {
+			value = fallback;
+			for (const k of keys) if (value && typeof value === "object" && k in value) value = value[k];
+			else return humanizeKey(key);
+			break;
+		}
+		if (typeof value !== "string") return humanizeKey(key);
+		if (params) return value.replace(/\{(\w+)\}/g, (_, param) => String(params[param] ?? ""));
+		return value;
+	};
+}
+/** Obtém ou cria função de tradução para locale */
+async function getTFunction(locale) {
+	if (tFunctionCache.has(locale)) return tFunctionCache.get(locale);
+	const [translations, fallback] = await Promise.all([loadLocale(locale), loadLocale("en")]);
+	const fn = createTFunction(translations, fallback);
+	tFunctionCache.set(locale, fn);
+	return fn;
+}
+var currentTFunction = createTFunction(initialTranslations, initialTranslations);
+var currentLocale = "en";
+var isLoading = true;
+/** Hook Solid para usar traduções em componentes */
+function useTranslation(initialLocale) {
+	onMount(async () => {
+		if (!isLoading) return;
+		if (!translationLoadPromise) translationLoadPromise = (async () => {
+			const resolvedLocale = initialLocale ?? await resolveLocale();
+			currentLocale = resolvedLocale;
+			currentTFunction = await getTFunction(resolvedLocale);
+			isLoading = false;
+			notifyTranslationChange((version) => version + 1);
+		})();
+		await translationLoadPromise;
+	});
+	const changeLocaleFn = async (newLocale) => {
+		isLoading = true;
+		await changeLocale(newLocale);
+		currentLocale = newLocale;
+		currentTFunction = await getTFunction(newLocale);
+		isLoading = false;
+		notifyTranslationChange((version) => version + 1);
+	};
+	const translate = (key, params) => {
+		translationVersion();
+		return currentTFunction(key, params);
+	};
+	return {
+		t: translate,
+		get locale() {
+			return currentLocale;
+		},
+		changeLocale: changeLocaleFn,
+		get loading() {
+			return isLoading;
+		}
+	};
+}
+/** Carrega traduções para uso em Astro middleware/pages */
+async function getTranslationsForLocale(locale) {
+	return loadLocale(locale);
+}
+//#endregion
+export { LOCALE_LABELS as a, LOCALE_FLAGS as i, useTranslation as n, SUPPORTED_LOCALES as o, apiClient as r, isRTLLocale as s, getTranslationsForLocale as t };