@questpie/admin 1.1.1 → 3.0.0

package/dist/client/i18n/hooks.mjs

@@ -0,0 +1,284 @@
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+import { createContext, useContext } from "react";
+import { DEFAULT_LOCALE } from "questpie/shared";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/client/i18n/hooks.tsx
+/**
+* I18n React Hooks
+*
+* React context and hooks for i18n in the admin UI.
+*/
+const I18nContext = createContext(null);
+/**
+* I18n Provider Component
+*
+* Provides i18n to all child components.
+* The adapter is the source of truth for UI locale.
+*
+* @example
+* ```tsx
+* import { I18nProvider, createSimpleI18n } from "@questpie/admin/i18n";
+*
+* const i18n = createSimpleI18n({ ... });
+*
+* <I18nProvider adapter={i18n}>
+*   <App />
+* </I18nProvider>
+* ```
+*/
+function I18nProvider(t0) {
+	const $ = c(35);
+	const { adapter, children } = t0;
+	const [, forceUpdate] = React.useReducer(_temp, 0);
+	let t1;
+	if ($[0] !== adapter || $[1] !== forceUpdate) {
+		t1 = () => adapter.onLocaleChange(() => {
+			forceUpdate();
+		});
+		$[0] = adapter;
+		$[1] = forceUpdate;
+		$[2] = t1;
+	} else t1 = $[2];
+	let t2;
+	if ($[3] !== adapter) {
+		t2 = [adapter];
+		$[3] = adapter;
+		$[4] = t2;
+	} else t2 = $[4];
+	React.useEffect(t1, t2);
+	const t3 = adapter.locale;
+	const t4 = adapter.locales;
+	let t5;
+	if ($[5] !== adapter) {
+		t5 = adapter.t.bind(adapter);
+		$[5] = adapter;
+		$[6] = t5;
+	} else t5 = $[6];
+	let t6;
+	if ($[7] !== adapter) {
+		t6 = adapter.setLocale.bind(adapter);
+		$[7] = adapter;
+		$[8] = t6;
+	} else t6 = $[8];
+	let t7;
+	if ($[9] !== adapter) {
+		t7 = adapter.onLocaleChange.bind(adapter);
+		$[9] = adapter;
+		$[10] = t7;
+	} else t7 = $[10];
+	let t8;
+	if ($[11] !== adapter) {
+		t8 = adapter.formatDate.bind(adapter);
+		$[11] = adapter;
+		$[12] = t8;
+	} else t8 = $[12];
+	let t9;
+	if ($[13] !== adapter) {
+		t9 = adapter.formatNumber.bind(adapter);
+		$[13] = adapter;
+		$[14] = t9;
+	} else t9 = $[14];
+	let t10;
+	if ($[15] !== adapter) {
+		t10 = adapter.formatRelative?.bind(adapter);
+		$[15] = adapter;
+		$[16] = t10;
+	} else t10 = $[16];
+	let t11;
+	if ($[17] !== adapter) {
+		t11 = adapter.getLocaleName.bind(adapter);
+		$[17] = adapter;
+		$[18] = t11;
+	} else t11 = $[18];
+	let t12;
+	if ($[19] !== adapter) {
+		t12 = adapter.isRTL.bind(adapter);
+		$[19] = adapter;
+		$[20] = t12;
+	} else t12 = $[20];
+	let t13;
+	if ($[21] !== adapter.locale || $[22] !== adapter.locales || $[23] !== t10 || $[24] !== t11 || $[25] !== t12 || $[26] !== t5 || $[27] !== t6 || $[28] !== t7 || $[29] !== t8 || $[30] !== t9) {
+		t13 = {
+			locale: t3,
+			locales: t4,
+			t: t5,
+			setLocale: t6,
+			onLocaleChange: t7,
+			formatDate: t8,
+			formatNumber: t9,
+			formatRelative: t10,
+			getLocaleName: t11,
+			isRTL: t12
+		};
+		$[21] = adapter.locale;
+		$[22] = adapter.locales;
+		$[23] = t10;
+		$[24] = t11;
+		$[25] = t12;
+		$[26] = t5;
+		$[27] = t6;
+		$[28] = t7;
+		$[29] = t8;
+		$[30] = t9;
+		$[31] = t13;
+	} else t13 = $[31];
+	const contextValue = t13;
+	let t14;
+	if ($[32] !== children || $[33] !== contextValue) {
+		t14 = /* @__PURE__ */ jsx(I18nContext.Provider, {
+			value: contextValue,
+			children
+		});
+		$[32] = children;
+		$[33] = contextValue;
+		$[34] = t14;
+	} else t14 = $[34];
+	return t14;
+}
+/**
+* Get the i18n adapter (throws if not in provider)
+*/
+function _temp(x) {
+	return x + 1;
+}
+function useI18n() {
+	const adapter = useContext(I18nContext);
+	if (!adapter) throw new Error("useI18n must be used within I18nProvider");
+	return adapter;
+}
+/**
+* Get i18n adapter or null (safe version)
+*/
+function useSafeI18n() {
+	return useContext(I18nContext);
+}
+/**
+* Main translation hook
+*
+* @example
+* ```tsx
+* function MyComponent() {
+*   const { t, locale, formatDate } = useTranslation();
+*   return <h1>{t("dashboard.title")}</h1>;
+* }
+* ```
+*/
+function useTranslation() {
+	const $ = c(11);
+	const adapter = useI18n();
+	const t0 = adapter.locale;
+	const t1 = adapter.locales;
+	const t2 = adapter.t;
+	const t3 = adapter.setLocale;
+	const t4 = adapter.formatDate;
+	const t5 = adapter.formatNumber;
+	const t6 = adapter.getLocaleName;
+	let t7;
+	if ($[0] !== adapter) {
+		t7 = adapter.isRTL();
+		$[0] = adapter;
+		$[1] = t7;
+	} else t7 = $[1];
+	let t8;
+	if ($[2] !== adapter.formatDate || $[3] !== adapter.formatNumber || $[4] !== adapter.getLocaleName || $[5] !== adapter.locale || $[6] !== adapter.locales || $[7] !== adapter.setLocale || $[8] !== adapter.t || $[9] !== t7) {
+		t8 = {
+			locale: t0,
+			locales: t1,
+			t: t2,
+			setLocale: t3,
+			formatDate: t4,
+			formatNumber: t5,
+			getLocaleName: t6,
+			isRTL: t7
+		};
+		$[2] = adapter.formatDate;
+		$[3] = adapter.formatNumber;
+		$[4] = adapter.getLocaleName;
+		$[5] = adapter.locale;
+		$[6] = adapter.locales;
+		$[7] = adapter.setLocale;
+		$[8] = adapter.t;
+		$[9] = t7;
+		$[10] = t8;
+	} else t8 = $[10];
+	return t8;
+}
+/**
+* Check if an object is a locale map (has locale codes as keys)
+*/
+function isLocaleMap(obj) {
+	if ("key" in obj) return false;
+	return Object.values(obj).every((v) => typeof v === "string");
+}
+/**
+* Resolve locale map to string for given locale
+*/
+function resolveLocaleMap(map, locale, fallback) {
+	if (map[locale]) return map[locale];
+	const lang = locale.split("-")[0];
+	if (lang && map[lang]) return map[lang];
+	if (map[DEFAULT_LOCALE]) return map[DEFAULT_LOCALE];
+	return Object.values(map)[0] ?? fallback;
+}
+/**
+* Resolve I18nText to string
+*
+* @example
+* ```tsx
+* function Label({ text }: { text: I18nText }) {
+*   const resolve = useResolveText();
+*   return <span>{resolve(text)}</span>;
+* }
+* ```
+*/
+function useResolveText() {
+	const $ = c(2);
+	const adapter = useSafeI18n();
+	let t0;
+	if ($[0] !== adapter) {
+		t0 = (text, t1, contextValues) => {
+			const fallback = t1 === void 0 ? "" : t1;
+			const resolveValue = (value) => {
+				if (value === void 0 || value === null) return fallback;
+				if (typeof value === "string") return value;
+				if (typeof value === "function") {
+					if (!adapter && !contextValues) return fallback;
+					const i18nCtx = adapter ? {
+						locale: adapter.locale,
+						t: adapter.t,
+						formatDate: adapter.formatDate,
+						formatNumber: adapter.formatNumber
+					} : void 0;
+					const ctx = {
+						...contextValues ?? {},
+						...i18nCtx ?? {}
+					};
+					try {
+						return resolveValue(value(ctx));
+					} catch (t2) {
+						const error = t2;
+						console.error("Failed to resolve dynamic text:", error);
+						return fallback;
+					}
+				}
+				if (typeof value === "object" && "key" in value && typeof value.key === "string") {
+					const keyObj = value;
+					if (!adapter) return keyObj.fallback ?? fallback;
+					const result_0 = adapter.t(keyObj.key, keyObj.params);
+					return result_0 === keyObj.key ? keyObj.fallback ?? result_0 : result_0;
+				}
+				if (typeof value === "object" && isLocaleMap(value)) return resolveLocaleMap(value, adapter?.locale ?? DEFAULT_LOCALE, fallback);
+				return fallback;
+			};
+			return resolveValue(text);
+		};
+		$[0] = adapter;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
+}
+
+//#endregion
+export { I18nProvider, useResolveText, useSafeI18n, useTranslation };

package/dist/client/i18n/intl-cache.mjs

@@ -0,0 +1,64 @@
+//#region src/client/i18n/intl-cache.ts
+/**
+* Intl Formatters Cache
+*
+* Caches Intl formatter instances to avoid creating new ones on every call.
+* Intl formatters are expensive to create but cheap to reuse.
+*/
+function getCacheKey(locale, options) {
+	if (!options || Object.keys(options).length === 0) return locale;
+	return `${locale}:${JSON.stringify(options)}`;
+}
+const dateTimeFormatCache = /* @__PURE__ */ new Map();
+function getDateTimeFormat(locale, options) {
+	const key = getCacheKey(locale, options);
+	let formatter = dateTimeFormatCache.get(key);
+	if (!formatter) {
+		formatter = new Intl.DateTimeFormat(locale, options);
+		dateTimeFormatCache.set(key, formatter);
+	}
+	return formatter;
+}
+const numberFormatCache = /* @__PURE__ */ new Map();
+function getNumberFormat(locale, options) {
+	const key = getCacheKey(locale, options);
+	let formatter = numberFormatCache.get(key);
+	if (!formatter) {
+		formatter = new Intl.NumberFormat(locale, options);
+		numberFormatCache.set(key, formatter);
+	}
+	return formatter;
+}
+const pluralRulesCache = /* @__PURE__ */ new Map();
+function getPluralRules(locale, options) {
+	const key = getCacheKey(locale, options);
+	let rules = pluralRulesCache.get(key);
+	if (!rules) {
+		rules = new Intl.PluralRules(locale, options);
+		pluralRulesCache.set(key, rules);
+	}
+	return rules;
+}
+const relativeTimeFormatCache = /* @__PURE__ */ new Map();
+function getRelativeTimeFormat(locale, options) {
+	const key = getCacheKey(locale, options);
+	let formatter = relativeTimeFormatCache.get(key);
+	if (!formatter) {
+		formatter = new Intl.RelativeTimeFormat(locale, options);
+		relativeTimeFormatCache.set(key, formatter);
+	}
+	return formatter;
+}
+const displayNamesCache = /* @__PURE__ */ new Map();
+function getDisplayNames(locale, options) {
+	const key = getCacheKey(locale, options);
+	let displayNames = displayNamesCache.get(key);
+	if (!displayNames) {
+		displayNames = new Intl.DisplayNames([locale], options);
+		displayNamesCache.set(key, displayNames);
+	}
+	return displayNames;
+}
+
+//#endregion
+export { getDateTimeFormat, getDisplayNames, getNumberFormat, getPluralRules, getRelativeTimeFormat };

package/dist/client/i18n/messages.mjs

@@ -0,0 +1,6 @@
+//#region src/client/i18n/messages.ts
+/** @deprecated Bundled messages removed. Use server-fetched translations. */
+const adminMessages = {};
+
+//#endregion
+export { adminMessages };

package/dist/client/i18n/simple.d.mts

@@ -0,0 +1,21 @@
+import "./types.mjs";
+
+//#region src/client/i18n/simple.d.ts
+
+/**
+ * Simple messages format
+ */
+type SimpleMessages = Record<string, string | PluralMessages>;
+/**
+ * Plural messages (using Intl.PluralRules categories)
+ */
+type PluralMessages = {
+  zero?: string;
+  one: string;
+  two?: string;
+  few?: string;
+  many?: string;
+  other: string;
+};
+//#endregion
+export { SimpleMessages };

package/dist/client/i18n/simple.mjs

@@ -0,0 +1,156 @@
+import { getDateTimeFormat, getDisplayNames, getNumberFormat, getPluralRules, getRelativeTimeFormat } from "./intl-cache.mjs";
+
+//#region src/client/i18n/simple.ts
+/**
+* Simple I18n Implementation
+*
+* A minimal i18n implementation for basic use cases.
+* For full i18n features (pluralization, ICU, etc.), use i18next or react-intl.
+*
+* Features:
+* - Basic key-value translation
+* - Simple interpolation ({{key}})
+* - Uses Intl APIs for formatting
+* - Basic pluralization via Intl.PluralRules
+*/
+const RTL_LOCALES = new Set([
+	"ar",
+	"he",
+	"fa",
+	"ur",
+	"ps",
+	"sd",
+	"yi"
+]);
+/**
+* Create a simple i18n adapter
+*
+* @example
+* ```ts
+* const i18n = createSimpleI18n({
+*   locale: "en",
+*   locales: ["en", "de"],
+*   messages: {
+*     en: {
+*       "common.save": "Save",
+*       "items.count": { one: "{{count}} item", other: "{{count}} items" }
+*     },
+*     de: {
+*       "common.save": "Speichern",
+*       "items.count": { one: "{{count}} Artikel", other: "{{count}} Artikel" }
+*     }
+*   }
+* });
+* ```
+*/
+function createSimpleI18n(options) {
+	let currentLocale = options.locale;
+	const { locales, messages, fallbackLocale = locales[0], onLocaleChange: onLocaleChangeCallback } = options;
+	const listeners = /* @__PURE__ */ new Set();
+	/**
+	* Notify all listeners about locale change
+	*/
+	function notifyListeners(locale) {
+		onLocaleChangeCallback?.(locale);
+		for (const listener of listeners) listener(locale);
+	}
+	/**
+	* Get message for key in locale
+	*/
+	function getMessage(key, locale) {
+		return messages[locale]?.[key];
+	}
+	/**
+	* Interpolate values into string
+	*/
+	function interpolate(str, params) {
+		if (!params) return str;
+		return str.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+			const value = params[key];
+			return value !== void 0 ? String(value) : `{{${key}}}`;
+		});
+	}
+	/**
+	* Check if value is plural messages
+	*/
+	function isPluralMessages(value) {
+		return typeof value === "object" && value !== null && "one" in value && "other" in value;
+	}
+	/**
+	* Get plural form
+	*/
+	function getPluralForm(forms, count, locale) {
+		switch (getPluralRules(locale).select(count)) {
+			case "zero": return forms.zero ?? forms.other;
+			case "one": return forms.one;
+			case "two": return forms.two ?? forms.other;
+			case "few": return forms.few ?? forms.other;
+			case "many": return forms.many ?? forms.other;
+			default: return forms.other;
+		}
+	}
+	return {
+		get locale() {
+			return currentLocale;
+		},
+		get locales() {
+			return locales;
+		},
+		t(key, params) {
+			let value = getMessage(key, currentLocale);
+			if (value === void 0 && currentLocale !== fallbackLocale) value = getMessage(key, fallbackLocale);
+			if (value === void 0) return key;
+			if (isPluralMessages(value)) {
+				const count = typeof params?.count === "number" ? params.count : 1;
+				return interpolate(getPluralForm(value, count, currentLocale), params);
+			}
+			return interpolate(value, params);
+		},
+		setLocale(locale) {
+			if (locales.includes(locale) && locale !== currentLocale) {
+				currentLocale = locale;
+				notifyListeners(locale);
+			}
+		},
+		onLocaleChange(callback) {
+			listeners.add(callback);
+			return () => {
+				listeners.delete(callback);
+			};
+		},
+		formatDate(date, opts) {
+			const d = typeof date === "number" ? new Date(date) : date;
+			return getDateTimeFormat(currentLocale, opts).format(d);
+		},
+		formatNumber(value, opts) {
+			return getNumberFormat(currentLocale, opts).format(value);
+		},
+		formatRelative(date) {
+			const d = typeof date === "number" ? new Date(date) : date;
+			const now = Date.now();
+			const diff = d.getTime() - now;
+			const diffSeconds = Math.round(diff / 1e3);
+			const diffMinutes = Math.round(diff / 6e4);
+			const diffHours = Math.round(diff / 36e5);
+			const diffDays = Math.round(diff / 864e5);
+			const rtf = getRelativeTimeFormat(currentLocale, { numeric: "auto" });
+			if (Math.abs(diffSeconds) < 60) return rtf.format(diffSeconds, "second");
+			if (Math.abs(diffMinutes) < 60) return rtf.format(diffMinutes, "minute");
+			if (Math.abs(diffHours) < 24) return rtf.format(diffHours, "hour");
+			return rtf.format(diffDays, "day");
+		},
+		getLocaleName(locale) {
+			try {
+				return getDisplayNames(currentLocale, { type: "language" }).of(locale) ?? locale;
+			} catch {
+				return locale;
+			}
+		},
+		isRTL() {
+			return RTL_LOCALES.has(currentLocale);
+		}
+	};
+}
+
+//#endregion
+export { createSimpleI18n };

package/dist/client/i18n/types.d.mts

@@ -0,0 +1,109 @@
+import "react";
+
+//#region src/client/i18n/types.d.ts
+
+/**
+ * I18n Adapter Interface
+ *
+ * This is the contract that any i18n implementation must fulfill.
+ * Designed to be easily implemented by wrapping i18next, react-intl, etc.
+ */
+interface I18nAdapter {
+  /**
+   * Current UI locale (e.g., "en", "de", "sk")
+   */
+  readonly locale: string;
+  /**
+   * Available locales
+   */
+  readonly locales: string[];
+  /**
+   * Translate a key
+   *
+   * @param key - Translation key (e.g., "common.save")
+   * @param params - Interpolation values (e.g., { count: 5 })
+   */
+  t(key: string, params?: Record<string, unknown>): string;
+  /**
+   * Change the current locale
+   */
+  setLocale(locale: string): void | Promise<void>;
+  /**
+   * Subscribe to locale changes
+   *
+   * @param callback - Called when locale changes
+   * @returns Unsubscribe function
+   */
+  onLocaleChange(callback: (locale: string) => void): () => void;
+  /**
+   * Format a date (uses Intl.DateTimeFormat)
+   */
+  formatDate(date: Date | number, options?: Intl.DateTimeFormatOptions): string;
+  /**
+   * Format a number (uses Intl.NumberFormat)
+   */
+  formatNumber(value: number, options?: Intl.NumberFormatOptions): string;
+  /**
+   * Format relative time (e.g., "2 days ago")
+   */
+  formatRelative?(date: Date | number): string;
+  /**
+   * Get display name for a locale (e.g., "en" -> "English")
+   */
+  getLocaleName(locale: string): string;
+  /**
+   * Check if current locale is RTL
+   */
+  isRTL(): boolean;
+}
+/**
+ * Inline translations object - maps locale codes to translated strings
+ *
+ * @example
+ * ```ts
+ * { en: "Barbers", sk: "Holiči", cz: "Holiči" }
+ * ```
+ */
+type I18nLocaleMap = {
+  [locale: string]: string;
+};
+/**
+ * I18nText - A value that can be translated
+ *
+ * Used in admin config for labels, descriptions, etc.
+ * Supports multiple formats for flexibility.
+ *
+ * @example
+ * ```ts
+ * // Simple string (no translation)
+ * label: "Posts"
+ *
+ * // Translation key
+ * label: { key: "nav.posts" }
+ *
+ * // Translation key with fallback
+ * label: { key: "nav.posts", fallback: "Posts" }
+ *
+ * // Inline translations (recommended for collection/global labels)
+ * label: { en: "Barbers", sk: "Holiči", cz: "Holiči" }
+ *
+ * // Dynamic function
+ * label: (ctx) => ctx.t("nav.posts")
+ * ```
+ */
+type I18nText = string | {
+  key: string;
+  fallback?: string;
+  params?: Record<string, unknown>;
+} | I18nLocaleMap | ((ctx: I18nContext) => string);
+/**
+ * Context passed to I18nText functions
+ */
+interface I18nContext {
+  locale: string;
+  t: I18nAdapter["t"];
+  formatDate: I18nAdapter["formatDate"];
+  formatNumber: I18nAdapter["formatNumber"];
+}
+//#endregion
+export { I18nAdapter, I18nContext, I18nText };

package/dist/client/lib/cookies.mjs

@@ -0,0 +1,9 @@
+//#region src/client/lib/cookies.ts
+function getCookie(name) {
+	if (typeof document === "undefined") return null;
+	const match = document.cookie.match(/* @__PURE__ */ new RegExp(`${name}=([^;]+)`));
+	return match ? match[1] : null;
+}
+
+//#endregion
+export { getCookie };

package/dist/client/lib/events.mjs

@@ -0,0 +1,5 @@
+//#region src/client/lib/events.ts
+const SEARCH_PARAMS_EVENT = "questpie:searchparamschange";
+
+//#endregion
+export { SEARCH_PARAMS_EVENT };

package/dist/client/lib/render-profiler.mjs

@@ -0,0 +1,51 @@
+import { c } from "react/compiler-runtime";
+import * as React from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+
+//#region src/client/lib/render-profiler.tsx
+const LOG_MIN_INTERVAL_MS = 800;
+const lastLogAtById = /* @__PURE__ */ new Map();
+function RenderProfiler(t0) {
+	const $ = c(9);
+	const { id, children, minDurationMs: t1 } = t0;
+	const minDurationMs = t1 === void 0 ? 8 : t1;
+	let t2;
+	if ($[0] !== id || $[1] !== minDurationMs) {
+		t2 = (_profileId, phase, actualDuration, baseDuration, startTime, commitTime) => {
+			if (actualDuration < minDurationMs) return;
+			const now = commitTime || globalThis.performance?.now?.() || Date.now();
+			if (now - (lastLogAtById.get(id) ?? 0) < LOG_MIN_INTERVAL_MS) return;
+			lastLogAtById.set(id, now);
+			console.debug(`[RenderProfiler] ${id} phase=${phase} actual=${actualDuration.toFixed(1)}ms base=${baseDuration.toFixed(1)}ms start=${startTime.toFixed(1)}ms commit=${commitTime.toFixed(1)}ms`);
+		};
+		$[0] = id;
+		$[1] = minDurationMs;
+		$[2] = t2;
+	} else t2 = $[2];
+	const onRender = t2;
+	if (process.env.NODE_ENV !== "development") {
+		let t3$1;
+		if ($[3] !== children) {
+			t3$1 = /* @__PURE__ */ jsx(Fragment, { children });
+			$[3] = children;
+			$[4] = t3$1;
+		} else t3$1 = $[4];
+		return t3$1;
+	}
+	let t3;
+	if ($[5] !== children || $[6] !== id || $[7] !== onRender) {
+		t3 = /* @__PURE__ */ jsx(React.Profiler, {
+			id,
+			onRender,
+			children
+		});
+		$[5] = children;
+		$[6] = id;
+		$[7] = onRender;
+		$[8] = t3;
+	} else t3 = $[8];
+	return t3;
+}
+
+//#endregion
+export { RenderProfiler };