@nsxbet/admin-sdk 0.5.1 → 0.7.0

package/dist/shell/hooks/useCspViolations.js

@@ -0,0 +1,34 @@
+import { useState, useEffect, useCallback } from "react";
+const MAX_VIOLATIONS = 50;
+export function useCspViolations(environment) {
+    const [violations, setViolations] = useState([]);
+    const [unseenCount, setUnseenCount] = useState(0);
+    const isProduction = environment === "production";
+    const resetUnseenCount = useCallback(() => {
+        setUnseenCount(0);
+    }, []);
+    useEffect(() => {
+        if (isProduction)
+            return;
+        const handler = (event) => {
+            const violation = {
+                blockedURI: event.blockedURI,
+                violatedDirective: event.violatedDirective,
+                effectiveDirective: event.effectiveDirective,
+                documentURI: event.documentURI,
+                timestamp: new Date().toISOString(),
+            };
+            setViolations((prev) => [violation, ...prev].slice(0, MAX_VIOLATIONS));
+            setUnseenCount((prev) => prev + 1);
+        };
+        document.addEventListener("securitypolicyviolation", handler);
+        return () => {
+            document.removeEventListener("securitypolicyviolation", handler);
+        };
+    }, [isProduction]);
+    return {
+        violations: isProduction ? [] : violations,
+        unseenCount: isProduction ? 0 : unseenCount,
+        resetUnseenCount,
+    };
+}

package/dist/shell/index.d.ts

@@ -2,8 +2,7 @@ export { AdminShell } from "./AdminShell";
 export type { AdminShellProps } from "./AdminShell";
 export { TopBar, LeftNav, MainContent, CommandPalette, ThemeProvider, useTheme, } from "./components";
 export type { TopBarProps, CommandPaletteProps } from "./components";
-export type { Module, ModuleCommand, ModuleStatus, Catalog, ImportMap, SearchableItem, SearchResult, } from "./types";
+export type { Module, ModuleCommand, ModuleStatus, NavigationSection, ModuleNavigation, Catalog, ImportMap, SearchableItem, SearchResult, } from "./types";
 export { initTelemetry, track, trackError } from "./telemetry";
 export { fuzzySearch } from "./search/fuzzy";
 export type { SearchOptions } from "./search/fuzzy";
-//# sourceMappingURL=index.d.ts.map

package/dist/shell/polling-config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Resolve the registry polling interval in milliseconds.
+ *
+ * Priority:
+ * 1. Explicit `REGISTRY_POLL_INTERVAL` from `window.__ENV__` or `import.meta.env`
+ * 2. Environment-based default (local: 60s, staging: 5min, production: 15min)
+ *
+ * Returns 0 (disabled) when the explicit value is "0".
+ */
+export declare function resolvePollingInterval(environment: string): number;

package/dist/shell/polling-config.js

@@ -0,0 +1,26 @@
+const ENVIRONMENT_DEFAULTS = {
+    local: 60000,
+    development: 60000,
+    e2e: 300000,
+    staging: 300000,
+    production: 900000,
+};
+/**
+ * Resolve the registry polling interval in milliseconds.
+ *
+ * Priority:
+ * 1. Explicit `REGISTRY_POLL_INTERVAL` from `window.__ENV__` or `import.meta.env`
+ * 2. Environment-based default (local: 60s, staging: 5min, production: 15min)
+ *
+ * Returns 0 (disabled) when the explicit value is "0".
+ */
+export function resolvePollingInterval(environment) {
+    const raw = (typeof window !== 'undefined' && window.__ENV__?.REGISTRY_POLL_INTERVAL) ||
+        (typeof import.meta !== 'undefined' && import.meta.env?.VITE_REGISTRY_POLL_INTERVAL);
+    if (raw !== undefined && raw !== null && raw !== '') {
+        const parsed = Number(raw);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return ENVIRONMENT_DEFAULTS[environment] ?? ENVIRONMENT_DEFAULTS.local;
+}

package/dist/shell/search/fuzzy.d.ts

@@ -15,4 +15,3 @@ export interface SearchOptions {
  * @returns Sorted array of search results with scores
  */
 export declare function fuzzySearch(items: SearchableItem[], query: string, options?: SearchOptions): SearchResult[];
-//# sourceMappingURL=fuzzy.d.ts.map

package/dist/shell/search/index.d.ts

@@ -1,3 +1,2 @@
 export { fuzzySearch } from "./fuzzy";
 export type { SearchOptions } from "./fuzzy";
-//# sourceMappingURL=index.d.ts.map

package/dist/shell/telemetry.d.ts

@@ -4,4 +4,3 @@
 export declare function initTelemetry(env: string): void;
 export declare function track(event: string, props?: Record<string, unknown>): void;
 export declare function trackError(err: unknown, props?: Record<string, unknown>): void;
-//# sourceMappingURL=telemetry.d.ts.map

package/dist/shell/types.d.ts

@@ -1,6 +1,7 @@
 /**
  * Shell Type Definitions
  */
+import type { LocalizedField } from "../i18n/config.js";
 /**
  * Module status in the registry
  */
@@ -10,12 +11,31 @@ export type ModuleStatus = "active" | "deprecated" | "disabled";
  */
 export interface ModuleCommand {
     id: string;
-    title: string;
-    /** i18n key for translated title (optional) */
-    titleKey?: string;
+    /** Human-readable title (localized per locale) */
+    title: LocalizedField;
     keywords?: string[];
     route: string;
     icon?: string;
+    /** Section ID for grouping in stacked navigation */
+    section?: string;
+}
+/**
+ * Section within a stacked navigation panel
+ */
+export interface NavigationSection {
+    /** Unique identifier for the section */
+    id: string;
+    /** Human-readable label (localized per locale) */
+    label: LocalizedField;
+}
+/**
+ * Navigation configuration for a module
+ */
+export interface ModuleNavigation {
+    /** Navigation style: "collapsible" (default inline expand) or "stacked" (dedicated panel) */
+    style: "collapsible" | "stacked";
+    /** Sections for grouping commands in stacked mode */
+    sections?: NavigationSection[];
 }
 /**
  * Module information as defined in the catalog
@@ -24,14 +44,10 @@ export interface ModuleCommand {
 export interface Module {
     /** Unique identifier for the module (e.g., "@admin/users") */
     id: string;
-    /** Human-readable title */
-    title: string;
-    /** i18n key for translated title (optional) */
-    titleKey?: string;
-    /** Description of what the module does */
-    description: string;
-    /** i18n key for translated description (optional) */
-    descriptionKey?: string;
+    /** Human-readable title (localized per locale) */
+    title: LocalizedField;
+    /** Description of what the module does (localized per locale) */
+    description: LocalizedField;
     /** Category for navigation grouping */
     category: string;
     /** Base route where module is mounted (e.g., "/admin/users") */
@@ -53,9 +69,11 @@ export interface Module {
     /** Module status */
     status: ModuleStatus;
     /** Optional navigation order */
-    navOrder?: number;
+    navigationOrder?: number;
     /** Optional icon name */
     icon?: string;
+    /** Navigation configuration (stacked or collapsible) */
+    navigation?: ModuleNavigation;
     /** Optional commands */
     commands?: ModuleCommand[];
 }
@@ -80,22 +98,21 @@ export interface ImportMap {
     };
 }
 /**
- * Searchable item for command palette
+ * Searchable item for command palette.
+ * Title and moduleTitle are resolved for the current locale at index time.
  */
 export interface SearchableItem {
     type: "module" | "command";
     id: string;
+    /** Resolved title for current locale */
     title: string;
-    /** i18n key for the title */
-    titleKey?: string;
     category?: string;
     keywords?: string[];
     description?: string;
     route: string;
     moduleId?: string;
+    /** Resolved module title for current locale */
     moduleTitle?: string;
-    /** i18n key for the module title */
-    moduleTitleKey?: string;
     /** Icon name (Lucide icon in kebab-case) */
     icon?: string;
 }
@@ -107,4 +124,3 @@ export interface SearchResult {
     score: number;
     matchedFields: string[];
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/tailwind/index.d.ts

@@ -17,4 +17,3 @@ export declare function getAdminContentPaths(): string[];
  * ```
  */
 export declare function withAdminSdk(config?: Partial<Config>): Config;
-//# sourceMappingURL=index.d.ts.map

package/dist/types/keycloak.d.ts

@@ -23,4 +23,3 @@ export interface KeycloakTokenParsed {
         roles?: string[];
     };
 }
-//# sourceMappingURL=keycloak.d.ts.map

package/dist/types/platform.d.ts

@@ -2,6 +2,8 @@
  * Platform API type definitions
  * These types define the global API exposed by the admin shell
  */
+export type TimezoneMode = "utc" | "local";
+export type TimestampFormat = "datetime" | "date" | "time" | "relative";
 /**
  * Breadcrumb item for navigation
  */
@@ -16,6 +18,7 @@ export interface User {
     id: string;
     email: string;
     displayName: string;
+    roles: string[];
 }
 /**
  * Platform API exposed by the admin shell at window.__ADMIN_PLATFORM_API__
@@ -59,6 +62,15 @@ export interface PlatformAPI {
         /** Track an error */
         trackError: (err: unknown, props?: Record<string, unknown>) => void;
     };
+    /** Timestamp timezone preference */
+    timestamp: {
+        /** Current timezone mode */
+        mode: TimezoneMode;
+        /** Change the timezone mode */
+        setMode: (mode: TimezoneMode) => void;
+        /** Subscribe to mode changes, returns unsubscribe function */
+        onModeChange: (callback: (mode: TimezoneMode) => void) => () => void;
+    };
     /** Authenticated fetch wrapper */
     fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 }
@@ -80,4 +92,3 @@ declare global {
     }
 }
 export {};
-//# sourceMappingURL=platform.d.ts.map

package/dist/vite/AdminShellSharedDeps.d.ts

@@ -0,0 +1,64 @@
+import type { Plugin } from "vite";
+/**
+ * Configuration for a shared dependency exposed to dynamically loaded modules.
+ */
+export interface SharedDepConfig {
+    /** npm package specifier (e.g., "react") */
+    specifier: string;
+    /** Name of the window global where the shell exposes this dependency */
+    globalName: string;
+    /** Use `import X from` (true) vs `import * as X from` (false/default) */
+    importDefault?: boolean;
+    /**
+     * Additional specifiers that resolve to the same shim file.
+     * Their exports are merged into the shim alongside the main specifier.
+     * Useful for subpath exports like "react-dom/client".
+     */
+    mergedSpecifiers?: {
+        specifier: string;
+        globalName: string;
+        importDefault?: boolean;
+    }[];
+}
+/**
+ * Single source of truth for shared dependencies between shell and modules.
+ *
+ * - Module builds externalize these via SHARED_EXTERNALS.
+ * - The shell plugin auto-injects a globals script, import map, and shim files.
+ * - Adding a dep here is all that's needed — no manual shim files, import map
+ *   entries, or window assignments.
+ */
+export declare const SHARED_DEPS_CONFIG: SharedDepConfig[];
+/**
+ * Flat list of all specifiers that should be externalized in module builds.
+ * Derived from SHARED_DEPS_CONFIG.
+ */
+export declare function getSharedExternals(): string[];
+export type AdminShellSharedDeps = ReturnType<typeof AdminShellSharedDeps.create>;
+/**
+ * Vite plugin for the admin shell that auto-manages shared dependency resolution.
+ *
+ * What it does:
+ * 1. **Globals injection** — prepends `window.React = ...` assignments into the
+ *    shell's entry file via the `transform` hook. This runs through Vite's full
+ *    pipeline so imports resolve to pre-bundled deps (bypassing the import map).
+ * 2. **Import map** — injects `<script type="importmap">` so dynamically loaded
+ *    modules can resolve bare specifiers like `"react"` to shim files.
+ * 3. **Shim files** — auto-generated ES modules that re-export from window globals.
+ *    (dev: served via middleware, build: emitted as assets)
+ *
+ * With this plugin, main.tsx needs no awareness of the shared deps mechanism.
+ *
+ * @example
+ * ```ts
+ * // apps/admin-shell/vite.config.ts
+ * import { AdminShellSharedDeps } from "@nsxbet/admin-sdk/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [react(), AdminShellSharedDeps.create()],
+ * });
+ * ```
+ */
+export declare const AdminShellSharedDeps: {
+    create(): Plugin;
+};

package/dist/vite/AdminShellSharedDeps.js

@@ -0,0 +1,215 @@
+import { createHash } from "node:crypto";
+/**
+ * Single source of truth for shared dependencies between shell and modules.
+ *
+ * - Module builds externalize these via SHARED_EXTERNALS.
+ * - The shell plugin auto-injects a globals script, import map, and shim files.
+ * - Adding a dep here is all that's needed — no manual shim files, import map
+ *   entries, or window assignments.
+ */
+export const SHARED_DEPS_CONFIG = [
+    { specifier: "react", globalName: "React", importDefault: true },
+    {
+        specifier: "react-dom",
+        globalName: "ReactDOM",
+        importDefault: true,
+        mergedSpecifiers: [
+            { specifier: "react-dom/client", globalName: "ReactDOMClient" },
+        ],
+    },
+    { specifier: "react-router-dom", globalName: "ReactRouterDOM" },
+    { specifier: "i18next", globalName: "i18next" },
+    { specifier: "react-i18next", globalName: "reactI18next" },
+];
+/**
+ * Flat list of all specifiers that should be externalized in module builds.
+ * Derived from SHARED_DEPS_CONFIG.
+ */
+export function getSharedExternals() {
+    return SHARED_DEPS_CONFIG.flatMap((dep) => [
+        dep.specifier,
+        ...(dep.mergedSpecifiers?.map((m) => m.specifier) ?? []),
+    ]);
+}
+function buildGlobalsScript() {
+    const lines = [];
+    for (const dep of SHARED_DEPS_CONFIG) {
+        const binding = `__${dep.globalName}`;
+        lines.push(dep.importDefault
+            ? `import ${binding} from "${dep.specifier}";`
+            : `import * as ${binding} from "${dep.specifier}";`);
+        lines.push(`window.${dep.globalName} = ${binding};`);
+        for (const merged of dep.mergedSpecifiers ?? []) {
+            const mBinding = `__${merged.globalName}`;
+            lines.push(merged.importDefault
+                ? `import ${mBinding} from "${merged.specifier}";`
+                : `import * as ${mBinding} from "${merged.specifier}";`);
+            lines.push(`window.${merged.globalName} = ${mBinding};`);
+        }
+    }
+    return lines.join("\n");
+}
+const VALID_JS_IDENT = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+function isValidExportName(name) {
+    return VALID_JS_IDENT.test(name) && name !== "default" && name !== "__esModule";
+}
+async function enumerateNamedExports(specifier) {
+    const mod = await import(specifier);
+    return Object.keys(mod).filter(isValidExportName);
+}
+async function enumerateDefaultExportKeys(specifier) {
+    const mod = await import(specifier);
+    if (mod.default && typeof mod.default === "object") {
+        return Object.keys(mod.default).filter(isValidExportName);
+    }
+    return [];
+}
+async function generateShimContent(dep) {
+    const mainExports = dep.importDefault
+        ? await enumerateDefaultExportKeys(dep.specifier)
+        : await enumerateNamedExports(dep.specifier);
+    const lines = [
+        `const _mod = window.${dep.globalName};`,
+        `export default _mod.default ?? _mod;`,
+    ];
+    if (mainExports.length > 0) {
+        lines.push(`export const { ${mainExports.join(", ")} } = _mod;`);
+    }
+    for (const merged of dep.mergedSpecifiers ?? []) {
+        const mergedExports = await enumerateNamedExports(merged.specifier);
+        const unique = mergedExports.filter((e) => !mainExports.includes(e));
+        if (unique.length > 0) {
+            lines.push(`const _${merged.globalName} = window.${merged.globalName};`);
+            for (const name of unique) {
+                lines.push(`export const ${name} = _${merged.globalName}?.${name};`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+async function generateAllShims() {
+    const shims = new Map();
+    for (const dep of SHARED_DEPS_CONFIG) {
+        shims.set(dep.specifier, await generateShimContent(dep));
+    }
+    return shims;
+}
+function contentHash(content) {
+    return createHash("sha256").update(content).digest("hex").slice(0, 8);
+}
+async function generateHashedShims() {
+    const raw = await generateAllShims();
+    const hashed = new Map();
+    for (const [specifier, content] of raw) {
+        const hash = contentHash(content);
+        hashed.set(specifier, { content, fileName: `shims/${specifier}-${hash}.js` });
+    }
+    return hashed;
+}
+function buildHashedImportMapEntries(hashed, base) {
+    const imports = {};
+    for (const dep of SHARED_DEPS_CONFIG) {
+        const shimInfo = hashed.get(dep.specifier);
+        imports[dep.specifier] = `${base}${shimInfo.fileName}`;
+        for (const merged of dep.mergedSpecifiers ?? []) {
+            imports[merged.specifier] = `${base}${shimInfo.fileName}`;
+        }
+    }
+    return imports;
+}
+/**
+ * Vite plugin for the admin shell that auto-manages shared dependency resolution.
+ *
+ * What it does:
+ * 1. **Globals injection** — prepends `window.React = ...` assignments into the
+ *    shell's entry file via the `transform` hook. This runs through Vite's full
+ *    pipeline so imports resolve to pre-bundled deps (bypassing the import map).
+ * 2. **Import map** — injects `<script type="importmap">` so dynamically loaded
+ *    modules can resolve bare specifiers like `"react"` to shim files.
+ * 3. **Shim files** — auto-generated ES modules that re-export from window globals.
+ *    (dev: served via middleware, build: emitted as assets)
+ *
+ * With this plugin, main.tsx needs no awareness of the shared deps mechanism.
+ *
+ * @example
+ * ```ts
+ * // apps/admin-shell/vite.config.ts
+ * import { AdminShellSharedDeps } from "@nsxbet/admin-sdk/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [react(), AdminShellSharedDeps.create()],
+ * });
+ * ```
+ */
+export const AdminShellSharedDeps = {
+    create() {
+        let hashedShimsPromise = null;
+        let resolvedBase = "/";
+        let entryPattern;
+        function getHashedShims() {
+            if (!hashedShimsPromise) {
+                hashedShimsPromise = generateHashedShims();
+            }
+            return hashedShimsPromise;
+        }
+        return {
+            name: "admin-shell-shared-deps",
+            configResolved(config) {
+                resolvedBase = config.base;
+                entryPattern = config.build?.rollupOptions?.input;
+            },
+            transform(code, id) {
+                if (id.includes("node_modules"))
+                    return;
+                const isEntry = entryPattern
+                    ? id.endsWith(entryPattern)
+                    : /\/src\/main\.[tj]sx?$/.test(id);
+                if (!isEntry)
+                    return;
+                return buildGlobalsScript() + "\n" + code;
+            },
+            configureServer(server) {
+                server.middlewares.use((req, res, next) => {
+                    const match = req.url?.match(/^\/shims\/(.+?)(?:-[a-f0-9]+)?\.js$/);
+                    if (!match)
+                        return next();
+                    const specifier = match[1];
+                    getHashedShims()
+                        .then((shims) => {
+                        const shimInfo = shims.get(specifier);
+                        if (shimInfo) {
+                            res.setHeader("Content-Type", "application/javascript");
+                            res.end(shimInfo.content);
+                        }
+                        else {
+                            next();
+                        }
+                    })
+                        .catch(next);
+                });
+            },
+            async transformIndexHtml() {
+                const hashed = await getHashedShims();
+                const imports = buildHashedImportMapEntries(hashed, resolvedBase);
+                return [
+                    {
+                        tag: "script",
+                        attrs: { type: "importmap" },
+                        children: JSON.stringify({ imports }, null, 6),
+                        injectTo: "head-prepend",
+                    },
+                ];
+            },
+            async generateBundle() {
+                const hashed = await getHashedShims();
+                for (const [, shimInfo] of hashed) {
+                    this.emitFile({
+                        type: "asset",
+                        fileName: shimInfo.fileName,
+                        source: shimInfo.content,
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/vite/config.d.ts

@@ -1,9 +1,15 @@
-import type { Plugin } from "vite";
+import { type Plugin } from "vite";
+/**
+ * Default admin gateway URL (staging environment).
+ * Used by the env injection plugin when no explicit value is configured.
+ */
+export declare const ADMIN_GATEWAY_STAGING_URL = "https://admin-bff-stg.nsx.dev";
 /**
  * Shared dependencies that are externalized in module builds.
  * These are provided by the shell via import maps.
+ * Derived from SHARED_DEPS_CONFIG — the single source of truth.
  */
-export declare const SHARED_EXTERNALS: readonly ["react", "react-dom", "react-router-dom", "i18next", "react-i18next"];
+export declare const SHARED_EXTERNALS: readonly string[];
 export interface AdminModuleOptions {
     /**
      * Entry file for the module SPA
@@ -27,6 +33,15 @@ export interface AdminModuleOptions {
      * - "always": Always apply during `vite build`. Used by defineModuleConfig().
      */
     buildMode?: "auto" | "always";
+    /**
+     * Admin gateway URL for BFF token integration (InMemory auth).
+     * - `undefined` (default): auto-inject staging URL (`https://admin-bff-stg.nsx.dev`)
+     * - `string`: inject the provided URL
+     * - `null`: disable automatic injection entirely
+     *
+     * Explicit env vars (`.env` files, shell env) always take precedence over this option.
+     */
+    gatewayUrl?: string | null;
 }
 export interface ModuleConfigOptions extends AdminModuleOptions {
     /**
@@ -110,4 +125,3 @@ export declare function adminModule(options?: AdminModuleOptions): Plugin[];
  * ```
  */
 export declare function defineModuleConfig(options: ModuleConfigOptions): any;
-//# sourceMappingURL=config.d.ts.map

package/dist/vite/config.js

@@ -1,15 +1,19 @@
+import { loadEnv } from "vite";
 import { generateModuleManifestPlugin, serveDistPlugin } from "./plugins.js";
+import { adminModuleI18nPlugin } from "./i18n-plugin.js";
+import { getSharedExternals } from "./AdminShellSharedDeps.js";
+const ENV_KEY = "VITE_ADMIN_GATEWAY_URL";
+/**
+ * Default admin gateway URL (staging environment).
+ * Used by the env injection plugin when no explicit value is configured.
+ */
+export const ADMIN_GATEWAY_STAGING_URL = "https://admin-bff-stg.nsx.dev";
 /**
  * Shared dependencies that are externalized in module builds.
  * These are provided by the shell via import maps.
+ * Derived from SHARED_DEPS_CONFIG — the single source of truth.
  */
-export const SHARED_EXTERNALS = [
-    "react",
-    "react-dom",
-    "react-router-dom",
-    "i18next",
-    "react-i18next",
-];
+export const SHARED_EXTERNALS = getSharedExternals();
 /**
  * Composable Vite plugin array for admin modules.
  * Returns plugins that handle build-time lib config, dist serving, and manifest generation.
@@ -43,13 +47,33 @@ export const SHARED_EXTERNALS = [
  * ```
  */
 export function adminModule(options = {}) {
-    const { entry = "./src/spa.tsx", outDir = "dist", additionalExternals = [], buildMode = "auto", } = options;
+    const { entry = "./src/spa.tsx", outDir = "dist", additionalExternals = [], buildMode = "auto", gatewayUrl, } = options;
     const externals = [...SHARED_EXTERNALS, ...additionalExternals];
     function isModuleBuild() {
         if (buildMode === "always")
             return true;
         return process.env.ADMIN_MODULE === "true";
     }
+    const envPlugin = {
+        name: "admin-module-env",
+        config(_config, { mode }) {
+            if (gatewayUrl === null)
+                return;
+            const env = loadEnv(mode, process.cwd(), "VITE_");
+            const fromEnv = process.env[ENV_KEY] || env[ENV_KEY];
+            if (fromEnv) {
+                console.log(`[admin-module-env] ${ENV_KEY} → ${fromEnv} (from env)`);
+                return;
+            }
+            const url = gatewayUrl ?? ADMIN_GATEWAY_STAGING_URL;
+            console.log(`[admin-module-env] ${ENV_KEY} → ${url} (auto-injected)`);
+            return {
+                define: {
+                    [`import.meta.env.${ENV_KEY}`]: JSON.stringify(url),
+                },
+            };
+        },
+    };
     const buildConfigPlugin = {
         name: "admin-module-build-config",
         config(_config, { command }) {
@@ -76,6 +100,8 @@ export function adminModule(options = {}) {
         },
     };
     return [
+        envPlugin,
+        adminModuleI18nPlugin(),
         serveDistPlugin({ distDir: outDir }),
         generateModuleManifestPlugin(),
         buildConfigPlugin,

package/dist/vite/i18n-plugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Vite plugin for admin module i18n:
+ * - Validates all 4 locale files exist at build start
+ * - Auto-injects registerModuleTranslations into spa.tsx and main.tsx entry points
+ */
+import type { Plugin } from "vite";
+export interface AdminModuleI18nPluginOptions {
+    /** Path to admin.module.json */
+    manifestPath?: string;
+    /** Root directory (project root) */
+    root?: string;
+}
+export declare function adminModuleI18nPlugin(options?: AdminModuleI18nPluginOptions): Plugin;