inicontent 1.0.0

package/app/composables/search.ts

@@ -0,0 +1,353 @@
+import { FormatObjectCriteriaValue, isArrayOfObjects } from "inibase/utils";
+
+function _generateSearchInOption(
+	schema: Schema,
+	{ id, key, type, children }: Field,
+	useIDasValue?: boolean,
+	path?: string,
+): any {
+	if ((type === "object" || type === "array") && isArrayOfObjects(children)) {
+		const _children = (children as Schema).filter(({ type }) =>
+			Array.isArray(type)
+				? type.some((t) => !["table", "array", "object"].includes(t))
+				: !["table", "array", "object"].includes(type),
+		);
+		if (!_children.length) return undefined;
+		return {
+			label: t(key),
+			value: useIDasValue ? id : (path ?? "") + key,
+			children: _children.map((field) =>
+				_generateSearchInOption(
+					schema,
+					field,
+					useIDasValue,
+					`${(path ?? "") + key}.`,
+				),
+			),
+		};
+	}
+
+	return {
+		label: t(key),
+		value: useIDasValue ? id : (path ?? "") + key,
+	};
+}
+
+export function generateSearchInOptions(
+	schema?: Schema,
+	excludedKeys?: string[],
+	useIDasValue?: boolean,
+) {
+	if (!schema) return [];
+	const RETURN = schema
+		.map((field) => _generateSearchInOption(schema, field, useIDasValue))
+		.filter(Boolean)
+		.flat(Number.POSITIVE_INFINITY);
+	if (excludedKeys)
+		return RETURN.filter(({ value }) => !excludedKeys.includes(value));
+	return RETURN;
+}
+
+// ==================== ENCODE/DECODE LOGIC ====================
+
+type RelativeUnit =
+	| "year"
+	| "month"
+	| "week"
+	| "day"
+	| "hour"
+	| "minute"
+	| "second";
+
+const relativeUnitMap: Record<string, RelativeUnit> = {
+	year: "year",
+	years: "year",
+	yr: "year",
+	yrs: "year",
+	month: "month",
+	months: "month",
+	mo: "month",
+	mos: "month",
+	week: "week",
+	weeks: "week",
+	wk: "week",
+	wks: "week",
+	day: "day",
+	days: "day",
+	d: "day",
+	hour: "hour",
+	hours: "hour",
+	hr: "hour",
+	hrs: "hour",
+	minute: "minute",
+	minutes: "minute",
+	min: "minute",
+	mins: "minute",
+	second: "second",
+	seconds: "second",
+	sec: "second",
+	secs: "second",
+};
+
+function resolveRelativeDate(rawValue: unknown): number | undefined {
+	if (rawValue === null || rawValue === undefined) return undefined;
+	const text = String(rawValue).trim();
+	if (!text) return undefined;
+	const lowered = text.toLowerCase();
+	if (lowered === "now") return Date.now();
+	if (lowered === "yesterday") return shiftDate(new Date(), -1, "day");
+	if (lowered === "tomorrow") return shiftDate(new Date(), 1, "day");
+	if (lowered === "last week") return shiftDate(new Date(), -1, "week");
+	if (lowered === "last month") return shiftDate(new Date(), -1, "month");
+	if (lowered === "last year") return shiftDate(new Date(), -1, "year");
+	if (lowered === "next week") return shiftDate(new Date(), 1, "week");
+	if (lowered === "next month") return shiftDate(new Date(), 1, "month");
+	if (lowered === "next year") return shiftDate(new Date(), 1, "year");
+
+	let expression = lowered.replace(/\s+/g, " ").trim();
+	let implicitFuture = false;
+	if (expression.startsWith("in ")) {
+		expression = expression.slice(3).trim();
+		implicitFuture = true;
+	}
+
+	const match = expression.match(
+		/^([+-]?\d+)\s*([a-z]+)(?:\s+(ago|from now|later|after|before|ahead))?$/,
+	);
+	if (match) {
+		const amountText = match[1];
+		const unitToken = match[2];
+		if (!amountText || !unitToken) return undefined;
+		let amount = Number.parseInt(amountText, 10);
+		if (!Number.isFinite(amount)) return undefined;
+		const directionToken =
+			match[3] ?? (implicitFuture ? "from now" : undefined);
+		if (directionToken === "ago") amount = -Math.abs(amount);
+		else if (directionToken) amount = Math.abs(amount);
+		const mappedUnit = relativeUnitMap[unitToken];
+		if (!mappedUnit) return undefined;
+		return shiftDate(new Date(), amount, mappedUnit);
+	}
+
+	const fallback = Date.parse(text);
+	return Number.isNaN(fallback) ? undefined : fallback;
+}
+
+function shiftDate(baseDate: Date, amount: number, unit: RelativeUnit) {
+	const date = new Date(baseDate.getTime());
+	switch (unit) {
+		case "year":
+			date.setFullYear(date.getFullYear() + amount);
+			break;
+		case "month":
+			date.setMonth(date.getMonth() + amount);
+			break;
+		case "week":
+			date.setDate(date.getDate() + amount * 7);
+			break;
+		case "day":
+			date.setDate(date.getDate() + amount);
+			break;
+		case "hour":
+			date.setHours(date.getHours() + amount);
+			break;
+		case "minute":
+			date.setMinutes(date.getMinutes() + amount);
+			break;
+		case "second":
+			date.setSeconds(date.getSeconds() + amount);
+			break;
+	}
+	return date.getTime();
+}
+
+function fieldHasType(field: unknown, expectedType: FieldType) {
+	if (!field || typeof field !== "object") return false;
+	const fieldType = (field as { type?: FieldType | FieldType[] }).type;
+	if (!fieldType) return false;
+	if (Array.isArray(fieldType)) return fieldType.includes(expectedType);
+	return fieldType === expectedType;
+}
+
+function resolveRelativeNumber(rawValue: unknown): number | undefined {
+	if (rawValue === null || rawValue === undefined) return undefined;
+	if (typeof rawValue === "number")
+		return Number.isFinite(rawValue) ? rawValue : undefined;
+
+	if (typeof rawValue === "string") {
+		const text = rawValue.trim();
+		if (!text) return undefined;
+		const normalized = text.replaceAll(",", "");
+		const parsed = Number(normalized);
+		return Number.isFinite(parsed) ? parsed : undefined;
+	}
+
+	return undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function appendCriterionValue(
+	conditionTarget: Record<string, unknown>,
+	condition: "and" | "or",
+	fieldKey: string,
+	criterionValue: string,
+) {
+	const existingValue = conditionTarget[fieldKey];
+	if (existingValue === undefined) {
+		conditionTarget[fieldKey] = criterionValue;
+		return;
+	}
+
+	if (isRecord(existingValue) && isRecord(existingValue[condition])) {
+		const logicalGroup = existingValue[condition] as Record<string, unknown>;
+		logicalGroup[Object.keys(logicalGroup).length.toString()] = criterionValue;
+		return;
+	}
+
+	conditionTarget[fieldKey] = {
+		[condition]: {
+			"0": String(existingValue),
+			"1": criterionValue,
+		},
+	};
+}
+
+function prepareCriterionForMode(
+	operator: string | undefined,
+	rawValue: any,
+	field: Field,
+	mode: "display" | "fetch",
+) {
+	const normalizedOperator =
+		typeof operator === "string" && operator ? operator : "=";
+	if (mode === "fetch" && normalizedOperator.startsWith("r")) {
+		const absoluteValue = fieldHasType(field, "number")
+			? resolveRelativeNumber(rawValue)
+			: resolveRelativeDate(rawValue);
+		if (absoluteValue === undefined)
+			return { operator: normalizedOperator, value: undefined };
+		const strippedOperator =
+			normalizedOperator.length > 1 ? normalizedOperator.slice(1) : "=";
+		return { operator: strippedOperator, value: absoluteValue };
+	}
+	return { operator: normalizedOperator, value: rawValue };
+}
+
+export function generateSearchString(
+	searchArray: any,
+	mode: "display" | "fetch" = "display",
+) {
+	const RETURN: Record<string, Record<string, unknown>> = {};
+	if (!searchArray) return undefined;
+	for (const condition in searchArray) {
+		const items = searchArray[condition];
+		if (!["and", "or"].includes(condition)) continue;
+		if (!Array.isArray(items)) continue;
+		for (const item of items) {
+			if (!Array.isArray(item)) continue;
+			const fieldKey = item[0];
+			if (!fieldKey) continue;
+			const field = item[3] as Field | undefined;
+			if (!RETURN[condition]) RETURN[condition] = {};
+			const { operator, value } = prepareCriterionForMode(
+				typeof item[1] === "string" ? item[1] : "=",
+				item[2],
+				field,
+				mode,
+			);
+			if (value === undefined) continue;
+			const finalValue = value === undefined ? "" : value;
+			appendCriterionValue(
+				RETURN[condition],
+				condition as "and" | "or",
+				fieldKey,
+				`${operator === "=" ? "" : operator}${finalValue}`,
+			);
+		}
+	}
+	function isDeepEmpty(obj: unknown): boolean {
+		if (typeof obj !== "object" || obj === null) return false;
+		const keys = Object.keys(obj);
+		if (keys.length === 0) return true;
+		return keys.every((k) => isDeepEmpty((obj as Record<string, unknown>)[k]));
+	}
+	return !isDeepEmpty(RETURN) ? RETURN : undefined;
+}
+
+function decodeStoredCriterion(value: unknown): [string, unknown] {
+	const RELATIVE_OPERATORS = ["r>=", "r<=", "r!=", "r>", "r<", "r="] as const;
+
+	if (typeof value === "string" && value.startsWith("r")) {
+		const matched = RELATIVE_OPERATORS.find((operator) =>
+			value.startsWith(operator),
+		);
+		if (matched)
+			return [matched, value.slice(matched.length)] as [string, unknown];
+	}
+	if (typeof value === "string") return FormatObjectCriteriaValue(value);
+	return ["=", value];
+}
+
+function extractGroupedCriteriaValues(
+	value: unknown,
+	condition: "and" | "or",
+): unknown[] | null {
+	if (!value) return null;
+
+	// Support payloads like: { and: { 0: ">10", 1: "<20" } }
+	if (isRecord(value)) {
+		const fromCondition = value[condition];
+		if (Array.isArray(fromCondition)) return fromCondition;
+		if (isRecord(fromCondition)) return Object.values(fromCondition);
+
+		// Support payloads like: { 0: ">10", 1: "<20" }
+		const objectValues = Object.values(value);
+		if (
+			objectValues.length &&
+			objectValues.every((entry) => typeof entry === "string")
+		)
+			return objectValues;
+	}
+
+	// Support payloads like: [">10", "<20"]
+	if (Array.isArray(value)) return value;
+
+	return null;
+}
+
+export function generateSearchArray(searchQuery: any): searchType {
+	const RETURN: searchType = {};
+	for (const [condition, items] of Object.entries(searchQuery)) {
+		if (!RETURN[condition as "and" | "or"])
+			RETURN[condition as "and" | "or"] = [];
+		for (const [key, value] of Object.entries(items)) {
+			if (["and", "or"].includes(key))
+				RETURN[condition as "and" | "or"]?.push({
+					[key]: generateSearchArray(value),
+				});
+			else {
+				const groupedValues = extractGroupedCriteriaValues(
+					value,
+					condition as "and" | "or",
+				);
+				if (groupedValues?.length) {
+					for (const nestedValue of groupedValues)
+						RETURN[condition as "and" | "or"]?.push([
+							key,
+							...decodeStoredCriterion(nestedValue),
+						]);
+					continue;
+				}
+
+				RETURN[condition as "and" | "or"]?.push([
+					key,
+					...decodeStoredCriterion(value),
+				]);
+			}
+		}
+	}
+	return RETURN;
+}

package/app/composables/setThemeConfig.ts

@@ -0,0 +1,48 @@
+import { hexToRGB } from "~/composables"
+
+function adjustColor(hex: string, factor: number) {
+	// Convert hex to RGB
+	let [r, g, b] = hexToRGB(hex)
+
+	// Adjust RGB values
+	r = Math.min(255, Math.max(0, Math.round(r * factor)))
+	g = Math.min(255, Math.max(0, Math.round(g * factor)))
+	b = Math.min(255, Math.max(0, Math.round(b * factor)))
+
+	// Convert back to hex
+	return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).toUpperCase()}`
+}
+
+export default function () {
+	const database = useState<Database>("database")
+	const Theme = useCookie<"light" | "dark">("theme", { sameSite: true })
+	const Language = useScopedCookie<LanguagesType>("language", database.value?.slug)
+	const ThemeConfig = useState<ThemeConfig>("ThemeConfig")
+
+	const mainColor =
+		(Theme.value === "light" || !database.value.primaryDarkColor
+			? database.value.primaryColor
+			: database.value.primaryDarkColor) ?? "#FF9800"
+	ThemeConfig.value = {
+		primaryColor: mainColor,
+		primaryColorHover: adjustColor(mainColor, 1.1),
+		primaryColorPressed: adjustColor(mainColor, 0.9),
+		primaryColorSuppl: adjustColor(mainColor, 0.8),
+	}
+
+	const supportedLanguages = [
+		database.value?.primaryLanguage,
+		...(database.value?.secondaryLanguages ?? []),
+	].filter(Boolean) as LanguagesType[]
+
+	// Keep user's language choice. Only fall back when no language exists,
+	// or when current language is not available for this database.
+	if (!Language.value) {
+		Language.value = database.value?.primaryLanguage ?? "en"
+	} else if (
+		supportedLanguages.length > 0
+		&& !supportedLanguages.includes(Language.value)
+	) {
+		Language.value = database.value?.primaryLanguage ?? "en"
+	}
+}

package/app/composables/translationValue.ts

@@ -0,0 +1,169 @@
+import { isObject } from "inibase/utils";
+import Inison from "inison";
+
+// Matches the translatable field rules used by the translation drawer
+// (app/components/Table/TranslateDrawer.vue).
+const NOT_TRANSLATABLE = new Set([
+	"password",
+	"email",
+	"color",
+	"icon",
+	"link",
+	"role",
+]);
+const TRANSLATABLE_TYPES = new Set(["string", "text", "textarea", "html"]);
+const EXTRA_TRANSLATABLE = new Set([
+	"url",
+	"table",
+	"asset",
+	"array-table",
+	"array-asset",
+]);
+
+/** Resolve the effective type of a field (subType wins, first type for unions). */
+export function fieldTypeOf(field: Field): string {
+	const type = Array.isArray(field.type) ? field.type[0] : field.type;
+	return (field.subType ?? type) as string;
+}
+
+/** True when the field value is an array (repeater, tags, multi-select, array refs…). */
+export function isArrayLikeField(field: Field): boolean {
+	const type = Array.isArray(field.type) ? field.type[0] : field.type;
+	const resolved = fieldTypeOf(field);
+	return (
+		field.isArray === true ||
+		type === "array" ||
+		resolved === "array-table" ||
+		resolved === "array-asset" ||
+		(type === "multiple" && field.subType !== "select")
+	);
+}
+
+/** True for table/asset references (single or array). */
+export function isReferenceField(field: Field): boolean {
+	const resolved = fieldTypeOf(field);
+	return (
+		["table", "asset", "array-table", "array-asset"].includes(resolved) ||
+		field.table === "assets"
+	);
+}
+
+/** True for array reference fields (array refs / asset folders). */
+export function isReferenceArrayField(field: Field): boolean {
+	return isArrayLikeField(field) && !!field.table;
+}
+
+/** Whether a field should be translated at all (mirrors the drawer rules). */
+export function isTranslatableField(field: Field): boolean {
+	const resolved = fieldTypeOf(field);
+	if (NOT_TRANSLATABLE.has(resolved)) return false;
+	if (["ids", "id"].includes(field.key)) return false;
+	if (TRANSLATABLE_TYPES.has(resolved)) return true;
+	if (EXTRA_TRANSLATABLE.has(resolved)) return true;
+	return isArrayLikeField(field);
+}
+
+/** True when the value should be treated as "no translation". */
+export function isEmptyTranslationValue(value: unknown): boolean {
+	if (value === undefined || value === null) return true;
+	if (typeof value === "string") return value.trim().length === 0;
+	if (Array.isArray(value)) return value.length === 0;
+	return false;
+}
+
+/** Extract the id from a reference value (object → id, otherwise the scalar). */
+export function extractReferenceId(value: unknown): string {
+	if (value === undefined || value === null) return "";
+	if (isObject(value) && !Array.isArray(value)) {
+		const id = (value as Item).id;
+		return id === undefined || id === null ? "" : String(id);
+	}
+	return String(value);
+}
+
+/**
+ * Serialize a draft value into the string stored on the translations table:
+ * - table/asset references are stored as their id / array of ids
+ * - arrays (and objects) are stored with Inison
+ * - scalars are stored as-is
+ */
+export function normalizeTranslationValue(
+	field: Field,
+	value: unknown,
+): string {
+	if (isEmptyTranslationValue(value)) return "";
+
+	// Reference arrays (array refs / asset folders) → Inison list of ids.
+	if (isReferenceArrayField(field)) {
+		const ids = (Array.isArray(value) ? value : [value])
+			.map((entry) => extractReferenceId(entry))
+			.filter((id) => id.length > 0);
+		return Inison.stringify(ids);
+	}
+
+	// Single table/asset reference → its id.
+	if (isReferenceField(field)) {
+		return extractReferenceId(value);
+	}
+
+	if (Array.isArray(value)) return Inison.stringify(value);
+	if (isObject(value)) return Inison.stringify(value);
+	return String(value);
+}
+
+function tryParseStored(value: string): unknown {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+		try {
+			return JSON.parse(trimmed);
+		} catch {
+			// fall through to Inison
+		}
+		try {
+			return Inison.unstringify(trimmed);
+		} catch {
+			return trimmed;
+		}
+	}
+	return trimmed;
+}
+
+/** Reduce a stored reference value (plain id, legacy object/array, …) to its id string. */
+function resolveReferenceId(value: string): string {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+		const parsed = tryParseStored(trimmed);
+		if (Array.isArray(parsed))
+			return parsed.length ? extractReferenceId(parsed[0]) : "";
+		return extractReferenceId(parsed);
+	}
+	return extractReferenceId(trimmed);
+}
+
+/**
+ * Convert a stored translation string back into the typed value expected by the
+ * field component (id string(s), array, or scalar string).
+ */
+export function parseTranslationValue(
+	field: Field | undefined,
+	stored: string | undefined | null,
+): unknown {
+	if (stored === undefined || stored === null || stored === "") {
+		return field && isArrayLikeField(field) ? [] : "";
+	}
+	const value = stored.trim();
+
+	// Array-like fields (array refs, tags, multi-select, repeaters, …)
+	if (field && isArrayLikeField(field)) {
+		const parsed = tryParseStored(value);
+		return Array.isArray(parsed) ? parsed : [parsed];
+	}
+
+	// Single reference field: the drawer stores plain ids; legacy records can
+	// hold a serialized object — reduce either form to the id string.
+	if (field && isReferenceField(field)) {
+		return resolveReferenceId(value);
+	}
+
+	return stored;
+}

package/app/composables/useAssetPreview.ts

@@ -0,0 +1,84 @@
+interface UseAssetPreviewOptions {
+	assets?: Asset[];
+	index?: number;
+}
+
+function filterPreviewAssets(assets: Asset[]): Asset[] {
+	return assets.filter((asset) => asset.type !== "dir" && !!asset.publicURL);
+}
+
+export function useAssetPreview() {
+	const Loading = useState<Record<string, boolean>>("Loading", () => ({}));
+	const currentPreviewAsset = useState<Asset | undefined>("currentPreviewAsset");
+	const previewAssetList = useState<Asset[]>("previewAssetList", () => []);
+	const previewAssetIndex = useState<number>("previewAssetIndex", () => 0);
+	const previewImageRotation = useState<number>("previewImageRotation", () => 0);
+
+	function openPreview(asset: Asset, options?: UseAssetPreviewOptions) {
+		const assets = options?.assets?.length
+			? filterPreviewAssets(options.assets)
+			: [asset];
+		if (!assets.length) return;
+
+		const requestedIndex =
+			typeof options?.index === "number"
+				? options.index
+				: assets.findIndex((value) => value.id === asset.id);
+		const resolvedIndex = requestedIndex > -1 ? requestedIndex : 0;
+
+		previewAssetList.value = assets;
+		previewAssetIndex.value = resolvedIndex;
+		currentPreviewAsset.value = assets[resolvedIndex];
+		previewImageRotation.value = 0;
+		Loading.value.previewModal = false;
+	}
+
+	function closePreview() {
+		currentPreviewAsset.value = undefined;
+		Loading.value.previewModal = false;
+		previewImageRotation.value = 0;
+	}
+
+	function showPrevPreviewAsset() {
+		if (!previewAssetList.value.length) return;
+		previewAssetIndex.value =
+			(previewAssetIndex.value - 1 + previewAssetList.value.length) %
+			previewAssetList.value.length;
+		currentPreviewAsset.value = previewAssetList.value[previewAssetIndex.value];
+		previewImageRotation.value = 0;
+	}
+
+	function showNextPreviewAsset() {
+		if (!previewAssetList.value.length) return;
+		previewAssetIndex.value =
+			(previewAssetIndex.value + 1) % previewAssetList.value.length;
+		currentPreviewAsset.value = previewAssetList.value[previewAssetIndex.value];
+		previewImageRotation.value = 0;
+	}
+
+	function rotatePreviewImageLeft() {
+		previewImageRotation.value -= 90;
+	}
+
+	function rotatePreviewImageRight() {
+		previewImageRotation.value += 90;
+	}
+
+	function resetPreviewImageRotation() {
+		previewImageRotation.value = 0;
+	}
+
+	return {
+		currentPreviewAsset,
+		previewAssetList,
+		previewAssetIndex,
+		previewImageRotation,
+		openPreview,
+		closePreview,
+		showPrevPreviewAsset,
+		showNextPreviewAsset,
+		rotatePreviewImageLeft,
+		rotatePreviewImageRight,
+		resetPreviewImageRotation,
+	};
+}

package/app/composables/useAssetUploader.ts

@@ -0,0 +1,56 @@
+import type { UploadCustomRequestOptions } from "naive-ui"
+
+interface UploadAssetWithProgressOptions {
+	url: string
+	method: "POST" | "PUT"
+	headers?: Record<string, string>
+	file?: File | null
+	onProgress?: UploadCustomRequestOptions["onProgress"]
+}
+
+export function useAssetUploader() {
+	async function uploadAssetWithProgress({
+		url,
+		method,
+		headers,
+		file,
+		onProgress,
+	}: UploadAssetWithProgressOptions) {
+		if (!file) return
+		if (typeof XMLHttpRequest === "undefined") {
+			await $fetch(url, {
+				method,
+				headers,
+				body: file,
+			})
+			onProgress?.({ percent: 100 })
+			return
+		}
+
+		await new Promise<void>((resolve, reject) => {
+			const xhr = new XMLHttpRequest()
+			xhr.open(method, url)
+			for (const [key, value] of Object.entries(headers ?? {})) {
+				if (value) xhr.setRequestHeader(key, value)
+			}
+			xhr.upload.onprogress = (event) => {
+				if (!event.lengthComputable) return
+				const percent = 10 + (event.loaded / event.total) * 90
+				onProgress?.({ percent })
+			}
+			xhr.onload = () => {
+				if (xhr.status >= 200 && xhr.status < 300) {
+					onProgress?.({ percent: 100 })
+					resolve()
+				} else reject(new Error(`Upload failed with status ${xhr.status}`))
+			}
+			xhr.onerror = () => reject(new Error("Upload failed"))
+			xhr.onabort = () => reject(new Error("Upload aborted"))
+			xhr.send(file)
+		})
+	}
+
+	return {
+		uploadAssetWithProgress,
+	}
+}