inicontent 1.0.0

package/app/composables/Translation/define.ts

@@ -0,0 +1,41 @@
+import { deepMerge } from "inibase/utils"
+
+// Cache for translation hashes to avoid unnecessary merges
+const translationCache = new Map<string, boolean>()
+
+/**
+ * Generate a simple hash for a translations object
+ */
+function hashTranslations(translations: TranslationsType): string {
+	return JSON.stringify(translations)
+}
+
+export default function (translations: TranslationsType) {
+	const translationsState = useState<TranslationsType>("translations")
+
+	// Generate hash of incoming translations
+	const hash = hashTranslations(translations)
+
+	// Check if we've already merged these exact translations
+	if (translationCache.has(hash)) {
+		return
+	}
+
+	// Mark this translation set as processed
+	translationCache.set(hash, true)
+
+	// Merge translations
+	if (translationsState.value) {
+		translationsState.value = deepMerge(translationsState.value, translations)
+	} else {
+		translationsState.value = translations
+	}
+
+	// Clean up cache if it gets too large (prevent memory leaks)
+	if (translationCache.size > 1000) {
+		const keysToDelete = Array.from(translationCache.keys()).slice(0, 500)
+		for (const key of keysToDelete) {
+			translationCache.delete(key)
+		}
+	}
+}

package/app/composables/Translation/fetch.ts

@@ -0,0 +1,107 @@
+import Inison from "inison";
+
+type TableTranslationOverlay = {
+	hadPrevious: boolean;
+	previous: unknown;
+	applied: string;
+};
+
+export default async function (onlyTableTranslations = false) {
+	const config = useRuntimeConfig();
+	const database = useState<Database>("database");
+	const Language = useScopedCookie<LanguagesType>("language", database.value?.slug);
+	const translationsState = useState<TranslationsType>("translations");
+	const tableOverlays = useState<
+		Record<string, Record<string, TableTranslationOverlay>>
+	>("tableTranslationOverlays", () => ({}));
+
+	const table = useState<Table>("table");
+	const sessionID = useScopedCookie<string>("sid", database.value?.slug);
+
+	if (!Language.value || !database.value) return;
+
+	const locale = Language.value;
+	const translationsByLocale = translationsState.value as unknown as Record<
+		string,
+		Record<string, string>
+	>;
+	const languageTranslations = () => translationsByLocale[locale] ?? {};
+
+	let fetchResult: Item[] = [];
+	let fetchSucceeded = false;
+	try {
+		const result = (
+			await $fetch<apiResponse<Item[]>>(
+				`${config.public.apiBase}${database.value.slug
+				}/translations`,
+				{
+					params: {
+						where: Inison.stringify({
+							locale,
+							original: "!=",
+							...(table.value ? (onlyTableTranslations ? {table: table.value.id, field: 0} : {
+								table: { or: [table.value.id, null] },
+								field: 0,
+							}) : { table: null }),
+						}),
+						[`${database.value.slug}_sid`]: sessionID.value,
+						options: Inison.stringify({
+							perPage: 500,
+							columns: ["original", "translation", "table"],
+						}),
+						credentials: "include",
+					},
+				},
+			)
+		).result;
+		fetchResult = result ?? [];
+		fetchSucceeded = true;
+	} catch (e) {
+		console.error("[Translation] fetch global translations error", e);
+	}
+
+	if (!translationsState.value) translationsState.value = {} as TranslationsType;
+	if (!translationsByLocale[locale]) translationsByLocale[locale] = {};
+	const currentTranslations = languageTranslations();
+
+	if (onlyTableTranslations && fetchSucceeded) {
+		const previousOverlays = tableOverlays.value[locale] ?? {};
+		for (const [key, overlay] of Object.entries(previousOverlays)) {
+			if (currentTranslations[key] !== overlay.applied) continue;
+			if (overlay.hadPrevious)
+				currentTranslations[key] = overlay.previous as string;
+			else delete currentTranslations[key];
+		}
+		delete tableOverlays.value[locale];
+	}
+
+	const merged: Record<string, string> = {};
+	for (const translation of fetchResult) {
+		if (
+			!onlyTableTranslations &&
+			(translation.table || translation.item || translation.field)
+		)
+			continue;
+		const original = translation.original;
+		const value = translation.translation;
+		if (!original || typeof value !== "string") continue;
+		merged[original] = value;
+	}
+
+	if (onlyTableTranslations) {
+		const overlays: Record<string, TableTranslationOverlay> = {};
+		for (const [key, value] of Object.entries(merged)) {
+			overlays[key] = {
+				hadPrevious: Object.prototype.hasOwnProperty.call(currentTranslations, key),
+				previous: currentTranslations[key],
+				applied: value,
+			};
+		}
+		tableOverlays.value[locale] = overlays;
+	}
+
+	translationsByLocale[locale] = {
+		...currentTranslations,
+		...merged,
+	};
+}

package/app/composables/Translation/languages.ts

@@ -0,0 +1 @@
+export default ["ar", "en", "fr", "es"] as const

package/app/composables/Translation/loadCoreTranslations.ts

@@ -0,0 +1,38 @@
+import defineTranslation from "./define"
+
+// Track which languages have been loaded
+const loadedLanguages = new Set<string>()
+
+const locales = import.meta.glob("../../locales/*.ts")
+
+/**
+ * Load centralized translation files
+ * This should be called once in app initialization
+ * @param lang - The initial language to load (default: 'en')
+ */
+export default async function (
+	lang: LanguagesType = "en",
+	prevLang?: LanguagesType,
+) {
+	// Skip if already loaded
+	if (loadedLanguages.has(lang)) return
+
+	try {
+		const loader = locales[`../../locales/${lang}.ts`]
+		if (!loader) throw new Error(`Locale ${lang} not found`)
+
+		// Dynamically import the language file
+		const translations = (await loader()) as any
+
+		// Register the translations
+		defineTranslation(translations.default)
+
+		// Mark as loaded
+		loadedLanguages.add(lang)
+
+		if (prevLang && loadedLanguages.has(prevLang))
+			loadedLanguages.delete(prevLang)
+	} catch (error) {
+		console.error(`Failed to load ${lang} translations:`, error)
+	}
+}

package/app/composables/Translation/translate.ts

@@ -0,0 +1,250 @@
+import { getProperty, hasProperty, setProperty } from "inidot";
+
+function formatUnfoundTranslation(
+	input: string,
+	language: LanguagesType,
+): string {
+	input = decodeURI(input);
+	if (input.includes(".")) {
+		if (input.includes("..")) return input;
+		input = input.split(".").pop() ?? "";
+	}
+
+	const formatSupportedLanguages: LanguagesType[] = ["en", "es", "fr"];
+	if (
+		!formatSupportedLanguages.includes(language) ||
+		input.toUpperCase() === input
+	)
+		return input;
+
+	const lowercaseWordsMap: Record<LanguagesType, string[]> = {
+		ar: [],
+		en: [
+			"is",
+			"and",
+			"or",
+			"but",
+			"the",
+			"an",
+			"a",
+			"as",
+			"at",
+			"to",
+			"in",
+			"on",
+		],
+		es: [
+			"y",
+			"o",
+			"pero",
+			"el",
+			"la",
+			"los",
+			"las",
+			"un",
+			"una",
+			"de",
+			"del",
+			"al",
+			"en",
+			"con",
+			"por",
+			"para",
+			"sin",
+			"sobre",
+		],
+		fr: [
+			"et",
+			"ou",
+			"mais",
+			"le",
+			"la",
+			"les",
+			"un",
+			"une",
+			"des",
+			"du",
+			"de",
+			"dans",
+			"en",
+			"sur",
+			"avec",
+			"pour",
+			"sans",
+			"chez",
+			"par",
+		],
+	};
+
+	const lowercaseWords = lowercaseWordsMap[language] ?? lowercaseWordsMap.en;
+
+	if (input.length === 2)
+		return lowercaseWords.includes(input.toLowerCase())
+			? input.toLowerCase()
+			: input.toUpperCase();
+
+	// Split by capital letters and underscores
+	const words = input.split(/_(?![A-Z]+)|(?<=[a-z])(?=[A-Z])/);
+
+	// Process each word
+	const formattedWords = words.map((word, index) => {
+		if (word.charAt(0) === "_") word = word.slice(1);
+
+		if (word.toUpperCase() === word) return word.trim();
+
+		// Capitalize the first character
+		if (index === 0 || !lowercaseWords.includes(word.toLowerCase()))
+			return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+
+		// Check if the word is in the linking or lowercase words and convert to lowercase
+		if (lowercaseWords.includes(word.toLowerCase())) return word.toLowerCase();
+
+		// Replace underscores with space
+		const wordWithoutUnderscore = word.replace("_", " ");
+
+		// Add space before each capitalized character
+		return wordWithoutUnderscore
+			.replace(/([A-Z])/g, " $1")
+			.trim()
+			.toLowerCase();
+	});
+
+	// Join the formatted words with spaces
+	return formattedWords.join(" ");
+}
+
+/**
+ * Interpolate variables into a translation string
+ * Supports both {{variable}} and {variable} syntax
+ */
+function interpolate(text: string, params: Record<string, unknown>): string {
+	return text.replace(/\{\{?\s*(\w+)\s*\}?\}/g, (_, key) => {
+		return params[key] !== undefined ? String(params[key]) : `{${key}}`;
+	});
+}
+
+/**
+ * Get plural form based on count and language rules
+ */
+function getPluralForm(
+	count: number,
+	language: LanguagesType,
+): "zero" | "one" | "two" | "few" | "many" | "other" {
+	// English pluralization rules
+	if (language === "en") {
+		if (count === 0) return "zero";
+		if (count === 1) return "one";
+		return "other";
+	}
+
+	// Arabic pluralization rules
+	if (language === "ar") {
+		if (count === 0) return "zero";
+		if (count === 1) return "one";
+		if (count === 2) return "two";
+		const mod100 = count % 100;
+		if (mod100 >= 3 && mod100 <= 10) return "few";
+		if (mod100 >= 11 && mod100 <= 99) return "many";
+		return "other";
+	}
+
+	// French pluralization rules
+	if (language === "fr") {
+		if (count === 0 || count === 1) return "one";
+		return "other";
+	}
+
+	// Spanish pluralization rules
+	if (language === "es") {
+		if (count === 1) return "one";
+		return "other";
+	}
+
+	// Default
+	return count === 1 ? "one" : "other";
+}
+
+/**
+ * Handle plural translations
+ */
+function handlePlural(
+	translation: unknown,
+	count: number,
+	language: LanguagesType,
+	params?: Record<string, unknown>,
+): string {
+	if (typeof translation === "string")
+		return interpolate(translation, { ...params, count });
+
+	const pluralForm = getPluralForm(count, language);
+	const translationRecord =
+		translation && typeof translation === "object"
+			? (translation as Record<string, unknown>)
+			: {};
+
+	// Try to find the exact form, then fallback to more general forms
+	for (const form of [pluralForm, "other", "one"]) {
+		const value = translationRecord[form];
+		if (typeof value === "string") {
+			let result = value;
+			if (params) {
+				result = interpolate(result, { ...params, count });
+			}
+			return result;
+		}
+	}
+
+	return String(translation);
+}
+
+type TranslationParams = Record<string, unknown> & {
+	count?: number;
+	returnObjects?: boolean;
+};
+
+export default function (
+	key: string | number | null | undefined,
+	params?: TranslationParams,
+): string {
+	if (!key) return "";
+	if (typeof key !== "string") return String(key);
+
+	const translationsState = useState<TranslationsType>("translations");
+	const database = useState<Database>("database");
+	const Language = useScopedCookie<LanguagesType>("language", database.value?.slug);
+
+	if (!hasProperty(translationsState.value ?? {}, `${Language.value}.${key}`)) {
+		const unfoundTranslationsState = useState<TranslationsType>(
+			"unfoundTranslations",
+		);
+		if (!unfoundTranslationsState.value) unfoundTranslationsState.value = {};
+		setProperty(unfoundTranslationsState.value, key, null);
+	}
+
+	let translation =
+		getProperty(translationsState.value ?? {}, `${Language.value}.${key}`) ??
+		formatUnfoundTranslation(key, Language.value);
+
+	if (params?.returnObjects) return translation;
+
+	// Handle pluralization if count is provided
+	if (params?.count !== undefined) {
+		translation = handlePlural(
+			translation,
+			params.count,
+			Language.value,
+			params,
+		);
+	}
+	// Handle interpolation if params are provided
+	else if (params && typeof translation === "string") {
+		translation = interpolate(translation, params);
+	}
+
+	// If the value is still not a string (e.g. the key is a parent node with
+	// nested translations, like t("form")), return just the key instead of the
+	// object it resolved to.
+	if (typeof translation !== "string") return key;
+
+	return translation;
+}

package/app/composables/databaseCookies.ts

@@ -0,0 +1,79 @@
+const syncedCookieKeys = ["language", "theme", "sid", "redirectTo"] as const;
+// Only theme is shared globally across all databases. language, sid and
+// redirectTo are scoped per database so each database keeps its own value.
+const globalOnlyKeys = new Set(["theme"]);
+
+function isSet(value: string | null | undefined) {
+	return value !== null && value !== undefined && value !== "";
+}
+
+function resolveDatabaseSlug(databaseSlug?: string) {
+	if (databaseSlug) return databaseSlug;
+
+	const config = useRuntimeConfig();
+	if (config.public.database && config.public.database !== "inicontent") {
+		return String(config.public.database);
+	}
+
+	const database = useState<Database | null>("database", () => null);
+	if (database.value?.slug) return database.value.slug;
+
+	const route = useRoute();
+	const routeDatabase = route.params.database;
+	if (Array.isArray(routeDatabase)) return routeDatabase[0] || "inicontent";
+	if (routeDatabase) return String(routeDatabase);
+
+	return "inicontent";
+}
+
+export function useScopedCookie<T>(key: string, databaseSlug?: string) {
+	return useCookie<T>(
+		`${resolveDatabaseSlug(databaseSlug)}_${key}`,
+		{ sameSite: true },
+	);
+}
+
+export function syncCookiesFromDatabase(databaseSlug?: string) {
+	for (const key of syncedCookieKeys) {
+		const globalCookie = useCookie<string | null>(key, { sameSite: true });
+		const scopedCookie = useCookie<string | null>(
+			`${resolveDatabaseSlug(databaseSlug)}_${key}`,
+			{
+				sameSite: true,
+			},
+		);
+
+		if (isSet(scopedCookie.value)) {
+			// Always keep global in sync so components reading useCookie(key) work.
+			if (!globalOnlyKeys.has(key)) {
+				globalCookie.value = null;
+			} else {
+				globalCookie.value = scopedCookie.value;
+			}
+		} else if (isSet(globalCookie.value)) {
+			scopedCookie.value = globalCookie.value;
+		}
+	}
+}
+
+export function syncCookiesToDatabase(databaseSlug?: string) {
+	for (const key of syncedCookieKeys) {
+		const globalCookie = useCookie<string | null>(key, { sameSite: true });
+		const scopedCookie = useCookie<string | null>(
+			`${resolveDatabaseSlug(databaseSlug)}_${key}`,
+			{
+				sameSite: true,
+			},
+		);
+
+		if (isSet(globalCookie.value)) {
+			scopedCookie.value = globalCookie.value;
+			// For sid, wipe the global so the token is only in the scoped cookie.
+			if (!globalOnlyKeys.has(key)) {
+				globalCookie.value = null;
+			}
+		} else if (isSet(scopedCookie.value) && globalOnlyKeys.has(key)) {
+			globalCookie.value = scopedCookie.value;
+		}
+	}
+}

package/app/composables/fieldValidator.ts

@@ -0,0 +1,72 @@
+import { isArrayOfObjects } from "inibase/utils"
+import Inison from "inison"
+
+function applyRegex(field: Field, value?: string | (string | number)[]) {
+	if (field.regex && value) {
+		try {
+			const regex = new RegExp(field.regex)
+			const isValid = (() => {
+				let result = false
+				const timeout = setTimeout(() => {
+					throw new Error("Regex evaluation timeout")
+				}, 1000) // 1-second timeout
+				if (Array.isArray(value))
+					result = value.every((v) => regex.test(String(v)))
+				else result = regex.test(String(value))
+				clearTimeout(timeout)
+				return result
+			})()
+			if (!isValid) {
+				return new Error(`${t(field.key)} ${t("isInvalidFormat")}`)
+			}
+		} catch (error) {
+			return new Error(`${t(field.key)} ${t("isInvalidFormat")}`)
+		}
+	}
+	return true
+}
+
+export default function (
+	field: Field,
+	value: any,
+	extraValidator?: CallableFunction,
+): Promise<void> {
+	return new Promise<void>((resolve, reject) => {
+		if (field.isArray || Array.isArray(value)) {
+			if (!value || (Array.isArray(value) && value.length === 0))
+				if (field.required)
+					reject(new Error(`${t(field.key)} ${t("isRequired")}`))
+				else resolve()
+
+			if (Array.isArray(value) && field.min && value.length < field.min)
+				reject(new Error(`${t(field.key)} ${t("isNotValid")}`))
+
+			if (Array.isArray(value) && field.max && value.length > field.max)
+				reject(new Error(`${t(field.key)} ${t("isNotValid")}`))
+
+			const regex = applyRegex(
+				field,
+				isArrayOfObjects(value) ? Inison.stringify(value) : value,
+			)
+			if (regex instanceof Error) reject(regex)
+		} else {
+			if (
+				value === undefined ||
+				value === null ||
+				(typeof value === "string" && value.trim().length === 0)
+			)
+				if (field.required)
+					reject(new Error(`${t(field.key)} ${t("isRequired")}`))
+				else resolve()
+
+			const regex = applyRegex(field, value)
+			if (regex instanceof Error) reject(regex)
+		}
+
+		if (extraValidator)
+			if (!extraValidator(value, field))
+				reject(new Error(`${t(field.key)} ${t("isNotValid")}`))
+
+		resolve()
+	})
+}