@nsxbet/admin-sdk 0.1.0

package/dist/auth/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/auth/components/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/auth/components/index.js

@@ -0,0 +1,4 @@
+/**
+ * Auth components exports
+ */
+export { UserSelector } from './UserSelector';

package/dist/auth/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Authentication module exports
+ */
+export type { AuthClient, InMemoryAuthClient, MockUser, AuthState, AuthStateCallback, } from './client';
+export { createInMemoryAuthClient, clearInMemoryAuth, createKeycloakAuthClient, type InMemoryAuthClientOptions, type KeycloakAuthClientOptions, } from './client';
+export { UserSelector } from './components';
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,YAAY,EACV,UAAU,EACV,kBAAkB,EAClB,QAAQ,EACR,SAAS,EACT,iBAAiB,GAClB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,wBAAwB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,GAC/B,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}

package/dist/auth/index.js

@@ -0,0 +1,7 @@
+/**
+ * Authentication module exports
+ */
+// Auth client factories
+export { createInMemoryAuthClient, clearInMemoryAuth, createKeycloakAuthClient, } from './client';
+// Auth components
+export { UserSelector } from './components';

package/dist/components/AuthProvider.d.ts

@@ -0,0 +1,48 @@
+/**
+ * AuthProvider - Manages authentication state using AuthClient
+ *
+ * Works with both in-memory (mock) and Keycloak auth clients.
+ * Shows user selection screen when in-memory client has no selected user.
+ */
+import React from 'react';
+import type { AuthClient } from '../auth/client/interface';
+import type { User } from '../types/platform';
+/**
+ * Auth context value
+ */
+interface AuthContextValue {
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Current user (null if not authenticated) */
+    user: User | null;
+    /** Get access token for API calls */
+    getAccessToken: () => Promise<string>;
+    /** Check if user has a permission */
+    hasPermission: (permission: string) => boolean;
+    /** Log out current user */
+    logout: () => void;
+    /** The underlying auth client */
+    authClient: AuthClient;
+}
+/**
+ * AuthProvider props
+ */
+interface AuthProviderProps {
+    children: React.ReactNode;
+    /** The auth client to use */
+    authClient: AuthClient;
+}
+/**
+ * AuthProvider manages authentication state and renders appropriate UI
+ */
+export declare function AuthProvider({ children, authClient }: AuthProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access auth context
+ */
+export declare function useAuthContext(): AuthContextValue;
+/**
+ * Check if component is within AuthProvider
+ */
+export declare function useOptionalAuthContext(): AuthContextValue | null;
+export {};
+//# sourceMappingURL=AuthProvider.d.ts.map

package/dist/components/AuthProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthProvider.d.ts","sourceRoot":"","sources":["../../src/components/AuthProvider.tsx"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAsE,MAAM,OAAO,CAAC;AAC3F,OAAO,KAAK,EAAE,UAAU,EAAiC,MAAM,0BAA0B,CAAC;AAE1F,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C;;GAEG;AACH,UAAU,gBAAgB;IACxB,oCAAoC;IACpC,eAAe,EAAE,OAAO,CAAC;IACzB,+CAA+C;IAC/C,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAClB,qCAAqC;IACrC,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACtC,qCAAqC;IACrC,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/C,2BAA2B;IAC3B,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,iCAAiC;IACjC,UAAU,EAAE,UAAU,CAAC;CACxB;AAID;;GAEG;AACH,UAAU,iBAAiB;IACzB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,6BAA6B;IAC7B,UAAU,EAAE,UAAU,CAAC;CACxB;AAqBD;;GAEG;AACH,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,iBAAiB,2CAiGvE;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,gBAAgB,CAMjD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,GAAG,IAAI,CAEhE"}

package/dist/components/AuthProvider.js

@@ -0,0 +1,117 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * AuthProvider - Manages authentication state using AuthClient
+ *
+ * Works with both in-memory (mock) and Keycloak auth clients.
+ * Shows user selection screen when in-memory client has no selected user.
+ */
+import { createContext, useContext, useEffect, useState, useCallback } from 'react';
+import { UserSelector } from '../auth/components/UserSelector';
+const AuthContext = createContext(null);
+/**
+ * Loading screen component - uses Brasa Design System tokens
+ */
+function LoadingScreen() {
+    return (_jsx("div", { className: "min-h-screen bg-background flex items-center justify-center", children: _jsxs("div", { className: "text-center", children: [_jsx("div", { className: "inline-flex items-center justify-center w-12 h-12 rounded-xl bg-primary/20 mb-4 animate-pulse", children: _jsxs("svg", { className: "w-6 h-6 text-primary animate-spin", fill: "none", viewBox: "0 0 24 24", children: [_jsx("circle", { className: "opacity-25", cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "4" }), _jsx("path", { className: "opacity-75", fill: "currentColor", d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z" })] }) }), _jsx("p", { className: "text-muted-foreground", children: "Loading..." })] }) }));
+}
+/**
+ * AuthProvider manages authentication state and renders appropriate UI
+ */
+export function AuthProvider({ children, authClient }) {
+    const [authState, setAuthState] = useState({
+        isAuthenticated: false,
+        user: null,
+    });
+    const [isInitializing, setIsInitializing] = useState(true);
+    const [needsUserSelection, setNeedsUserSelection] = useState(false);
+    // Initialize auth client
+    useEffect(() => {
+        let mounted = true;
+        const initialize = async () => {
+            try {
+                const isAuthenticated = await authClient.initialize();
+                if (!mounted)
+                    return;
+                if (isAuthenticated) {
+                    setAuthState({
+                        isAuthenticated: true,
+                        user: authClient.getUser(),
+                    });
+                    setNeedsUserSelection(false);
+                }
+                else if (authClient.type === 'in-memory') {
+                    // In-memory client needs user selection
+                    setNeedsUserSelection(true);
+                }
+                // Keycloak will redirect to login page, so we don't need to handle it here
+            }
+            catch (error) {
+                console.error('[AuthProvider] Initialization failed:', error);
+            }
+            finally {
+                if (mounted) {
+                    setIsInitializing(false);
+                }
+            }
+        };
+        initialize();
+        // Subscribe to auth state changes
+        const unsubscribe = authClient.subscribe((state) => {
+            if (mounted) {
+                setAuthState(state);
+                if (!state.isAuthenticated && authClient.type === 'in-memory') {
+                    setNeedsUserSelection(true);
+                }
+                else {
+                    setNeedsUserSelection(false);
+                }
+            }
+        });
+        return () => {
+            mounted = false;
+            unsubscribe();
+        };
+    }, [authClient]);
+    // Handle user selection
+    const handleUserSelected = useCallback(() => {
+        setAuthState({
+            isAuthenticated: authClient.isAuthenticated(),
+            user: authClient.getUser(),
+        });
+        setNeedsUserSelection(false);
+    }, [authClient]);
+    // Context value
+    const contextValue = {
+        isAuthenticated: authState.isAuthenticated,
+        user: authState.user,
+        getAccessToken: () => authClient.getAccessToken(),
+        hasPermission: (permission) => authClient.hasPermission(permission),
+        logout: () => authClient.logout(),
+        authClient,
+    };
+    // Show loading during initialization
+    if (isInitializing) {
+        return _jsx(LoadingScreen, {});
+    }
+    // Show user selector for in-memory auth when no user selected
+    if (needsUserSelection && authClient.type === 'in-memory') {
+        return (_jsx(UserSelector, { authClient: authClient, onUserSelected: handleUserSelected }));
+    }
+    return (_jsx(AuthContext.Provider, { value: contextValue, children: children }));
+}
+/**
+ * Hook to access auth context
+ */
+export function useAuthContext() {
+    const context = useContext(AuthContext);
+    if (!context) {
+        throw new Error('useAuthContext must be used within AuthProvider');
+    }
+    return context;
+}
+/**
+ * Check if component is within AuthProvider
+ */
+export function useOptionalAuthContext() {
+    return useContext(AuthContext);
+}

package/dist/hooks/useAuth.d.ts

@@ -0,0 +1,21 @@
+import type { User } from '../types/platform';
+/**
+ * Authentication methods available in all modes
+ */
+export interface UseAuthResult {
+    /** Get the current access token */
+    getAccessToken: () => Promise<string>;
+    /** Check if user has a specific permission */
+    hasPermission: (permission: string) => boolean;
+    /** Get current user information */
+    getUser: () => User;
+    /** Log out the current user */
+    logout: () => void;
+}
+/**
+ * useAuth provides authentication methods that work seamlessly across:
+ * - Shell mode (using platform API)
+ * - Standalone mode with AuthClient (Keycloak or in-memory)
+ */
+export declare function useAuth(): UseAuthResult;
+//# sourceMappingURL=useAuth.d.ts.map

package/dist/hooks/useAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,mCAAmC;IACnC,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAEtC,8CAA8C;IAC9C,aAAa,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IAE/C,mCAAmC;IACnC,OAAO,EAAE,MAAM,IAAI,CAAC;IAEpB,+BAA+B;IAC/B,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,OAAO,IAAI,aAAa,CA4BvC"}

package/dist/hooks/useAuth.js

@@ -0,0 +1,34 @@
+/**
+ * Unified authentication hook that works in shell, standalone, and mock modes
+ */
+import { usePlatformAPI } from './usePlatformAPI';
+import { useOptionalAuthContext } from '../components/AuthProvider';
+/**
+ * useAuth provides authentication methods that work seamlessly across:
+ * - Shell mode (using platform API)
+ * - Standalone mode with AuthClient (Keycloak or in-memory)
+ */
+export function useAuth() {
+    const { isShellMode, api } = usePlatformAPI();
+    const authContext = useOptionalAuthContext();
+    // In shell mode, use the platform API
+    if (isShellMode && api) {
+        return {
+            getAccessToken: api.auth.getAccessToken,
+            hasPermission: api.auth.hasPermission,
+            getUser: api.auth.getUser,
+            logout: api.auth.logout,
+        };
+    }
+    // Use AuthProvider context (new AuthClient-based system)
+    if (authContext) {
+        return {
+            getAccessToken: authContext.getAccessToken,
+            hasPermission: authContext.hasPermission,
+            getUser: () => authContext.user || { id: '', email: '', displayName: '' },
+            logout: authContext.logout,
+        };
+    }
+    throw new Error('useAuth must be used within AuthProvider. ' +
+        'Wrap your app with <AuthProvider authClient={...}> from @nsxbet/admin-sdk');
+}

package/dist/hooks/useFetch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * useFetch provides an authenticated fetch function
+ *
+ * In shell mode: Uses platform API's fetch (automatically includes auth)
+ * In standalone mode: Manually adds Authorization header with token
+ */
+export declare function useFetch(): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+//# sourceMappingURL=useFetch.d.ts.map

package/dist/hooks/useFetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetch.d.ts","sourceRoot":"","sources":["../../src/hooks/useFetch.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wBAAgB,QAAQ,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAqB9F"}

package/dist/hooks/useFetch.js

@@ -0,0 +1,31 @@
+/**
+ * Authenticated fetch hook that works in both shell and standalone modes
+ */
+import { useCallback } from 'react';
+import { usePlatformAPI } from './usePlatformAPI';
+import { useAuth } from './useAuth';
+/**
+ * useFetch provides an authenticated fetch function
+ *
+ * In shell mode: Uses platform API's fetch (automatically includes auth)
+ * In standalone mode: Manually adds Authorization header with token
+ */
+export function useFetch() {
+    const { isShellMode, api } = usePlatformAPI();
+    const { getAccessToken } = useAuth();
+    return useCallback(async (input, init) => {
+        if (isShellMode && api) {
+            // In shell mode, use platform fetch (handles auth automatically)
+            return api.fetch(input, init);
+        }
+        // In standalone mode, add auth header manually
+        const token = await getAccessToken();
+        return fetch(input, {
+            ...init,
+            headers: {
+                ...init?.headers,
+                Authorization: `Bearer ${token}`,
+            },
+        });
+    }, [isShellMode, api, getAccessToken]);
+}

package/dist/hooks/useI18n.d.ts

@@ -0,0 +1,46 @@
+import type { TFunction, i18n as I18nInstance } from 'i18next';
+/**
+ * i18n methods and translation utilities
+ */
+export interface UseI18nResult {
+    /** Current locale */
+    locale: string;
+    /** Change the locale */
+    setLocale: (locale: string) => void;
+    /** Translation function - use t('key') or t('namespace:key') */
+    t: TFunction;
+    /** i18next instance for advanced use cases */
+    i18n: I18nInstance;
+}
+/**
+ * useI18n provides internationalization methods and translation access
+ *
+ * In shell mode: Uses platform API's i18n and subscribes to changes
+ * In standalone mode: Manages locale in local state
+ *
+ * @param namespace - Optional namespace for translations (default: 'shell')
+ * @returns Object with locale, setLocale, t (translation function), and i18n instance
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * const { locale, setLocale, t } = useI18n();
+ *
+ * return (
+ *   <div>
+ *     <p>{t('common.loading')}</p>
+ *     <button onClick={() => setLocale('en-US')}>English</button>
+ *   </div>
+ * );
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With custom namespace (for modules)
+ * const { t } = useI18n('@admin/tasks');
+ *
+ * return <h1>{t('listTitle')}</h1>;
+ * ```
+ */
+export declare function useI18n(namespace?: string): UseI18nResult;
+//# sourceMappingURL=useI18n.d.ts.map

package/dist/hooks/useI18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useI18n.d.ts","sourceRoot":"","sources":["../../src/hooks/useI18n.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,IAAI,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AAI/D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,qBAAqB;IACrB,MAAM,EAAE,MAAM,CAAC;IAEf,wBAAwB;IACxB,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAEpC,gEAAgE;IAChE,CAAC,EAAE,SAAS,CAAC;IAEb,8CAA8C;IAC9C,IAAI,EAAE,YAAY,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,OAAO,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAmEzD"}

package/dist/hooks/useI18n.js

@@ -0,0 +1,95 @@
+/**
+ * Internationalization hook for locale management and translations
+ */
+import { useEffect, useState, useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import { usePlatformAPI } from './usePlatformAPI';
+import { saveLocale, isSupportedLocale, i18n } from '../i18n';
+/**
+ * useI18n provides internationalization methods and translation access
+ *
+ * In shell mode: Uses platform API's i18n and subscribes to changes
+ * In standalone mode: Manages locale in local state
+ *
+ * @param namespace - Optional namespace for translations (default: 'shell')
+ * @returns Object with locale, setLocale, t (translation function), and i18n instance
+ *
+ * @example
+ * ```tsx
+ * // Basic usage
+ * const { locale, setLocale, t } = useI18n();
+ *
+ * return (
+ *   <div>
+ *     <p>{t('common.loading')}</p>
+ *     <button onClick={() => setLocale('en-US')}>English</button>
+ *   </div>
+ * );
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With custom namespace (for modules)
+ * const { t } = useI18n('@admin/tasks');
+ *
+ * return <h1>{t('listTitle')}</h1>;
+ * ```
+ */
+export function useI18n(namespace) {
+    const { isShellMode, api } = usePlatformAPI();
+    const [standaloneLocale, setStandaloneLocale] = useState(i18n.language || 'pt-BR');
+    // Use react-i18next's useTranslation for reactive updates
+    const { t, i18n: i18nInstance } = useTranslation(namespace || 'shell');
+    // Subscribe to platform locale changes in shell mode
+    useEffect(() => {
+        if (isShellMode && api) {
+            // Sync initial locale
+            const platformLocale = api.i18n.locale;
+            if (platformLocale !== i18nInstance.language) {
+                i18nInstance.changeLanguage(platformLocale);
+            }
+            setStandaloneLocale(platformLocale);
+            // Subscribe to changes
+            const unsubscribe = api.i18n.onLocaleChange((newLocale) => {
+                if (isSupportedLocale(newLocale)) {
+                    i18nInstance.changeLanguage(newLocale);
+                    setStandaloneLocale(newLocale);
+                }
+            });
+            return unsubscribe;
+        }
+    }, [isShellMode, api, i18nInstance]);
+    // Sync standalone mode with i18n language changes
+    useEffect(() => {
+        const handleLanguageChanged = (lng) => {
+            setStandaloneLocale(lng);
+        };
+        i18nInstance.on('languageChanged', handleLanguageChanged);
+        return () => {
+            i18nInstance.off('languageChanged', handleLanguageChanged);
+        };
+    }, [i18nInstance]);
+    const setLocale = useCallback((locale) => {
+        if (!isSupportedLocale(locale)) {
+            console.warn(`[useI18n] Unsupported locale: ${locale}`);
+            return;
+        }
+        // Always update i18next
+        i18nInstance.changeLanguage(locale);
+        // Persist to localStorage
+        saveLocale(locale);
+        if (isShellMode && api) {
+            // Notify platform API
+            api.i18n.setLocale(locale);
+        }
+        else {
+            setStandaloneLocale(locale);
+        }
+    }, [isShellMode, api, i18nInstance]);
+    return {
+        locale: isShellMode && api ? api.i18n.locale : standaloneLocale,
+        setLocale,
+        t,
+        i18n: i18nInstance,
+    };
+}

package/dist/hooks/usePlatformAPI.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Hook to access the platform API
+ */
+import type { PlatformAPI } from '../types/platform';
+/**
+ * Returns the platform API and whether the module is running in shell mode
+ */
+export declare function usePlatformAPI(): {
+    isShellMode: boolean;
+    api: PlatformAPI | undefined;
+};
+//# sourceMappingURL=usePlatformAPI.d.ts.map

package/dist/hooks/usePlatformAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePlatformAPI.d.ts","sourceRoot":"","sources":["../../src/hooks/usePlatformAPI.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;GAEG;AACH,wBAAgB,cAAc,IAAI;IAChC,WAAW,EAAE,OAAO,CAAC;IACrB,GAAG,EAAE,WAAW,GAAG,SAAS,CAAC;CAC9B,CAOA"}

package/dist/hooks/usePlatformAPI.js

@@ -0,0 +1,10 @@
+/**
+ * Returns the platform API and whether the module is running in shell mode
+ */
+export function usePlatformAPI() {
+    const isShellMode = typeof window !== 'undefined' && window.__ADMIN_PLATFORM_API__ !== undefined;
+    return {
+        isShellMode,
+        api: isShellMode ? window.__ADMIN_PLATFORM_API__ : undefined,
+    };
+}

package/dist/hooks/useTelemetry.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Telemetry methods
+ */
+export interface UseTelemetryResult {
+    /** Track an event */
+    track: (event: string, props?: Record<string, unknown>) => void;
+    /** Track an error */
+    trackError: (err: unknown, props?: Record<string, unknown>) => void;
+}
+/**
+ * useTelemetry provides telemetry methods
+ *
+ * In shell mode: Uses platform API's telemetry
+ * In standalone mode: Logs to console (or could send to local analytics)
+ */
+export declare function useTelemetry(): UseTelemetryResult;
+//# sourceMappingURL=useTelemetry.d.ts.map

package/dist/hooks/useTelemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTelemetry.d.ts","sourceRoot":"","sources":["../../src/hooks/useTelemetry.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,qBAAqB;IACrB,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAEhE,qBAAqB;IACrB,UAAU,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;CACrE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,kBAAkB,CAyBjD"}

package/dist/hooks/useTelemetry.js

@@ -0,0 +1,36 @@
+/**
+ * Telemetry hook for tracking events and errors
+ */
+import { useCallback } from 'react';
+import { usePlatformAPI } from './usePlatformAPI';
+/**
+ * useTelemetry provides telemetry methods
+ *
+ * In shell mode: Uses platform API's telemetry
+ * In standalone mode: Logs to console (or could send to local analytics)
+ */
+export function useTelemetry() {
+    const { isShellMode, api } = usePlatformAPI();
+    const track = useCallback((event, props) => {
+        if (isShellMode && api) {
+            api.telemetry.track(event, props);
+        }
+        else {
+            // In standalone mode, log to console
+            console.log('[Telemetry]', event, props);
+        }
+    }, [isShellMode, api]);
+    const trackError = useCallback((err, props) => {
+        if (isShellMode && api) {
+            api.telemetry.trackError(err, props);
+        }
+        else {
+            // In standalone mode, log to console
+            console.error('[Telemetry Error]', err, props);
+        }
+    }, [isShellMode, api]);
+    return {
+        track,
+        trackError,
+    };
+}

package/dist/i18n/config.d.ts

@@ -0,0 +1,26 @@
+/**
+ * i18n Configuration for the Admin Platform
+ *
+ * Supports: Portuguese (Brazil), Spanish, English (US), Romanian
+ */
+import i18n from 'i18next';
+export declare const SUPPORTED_LOCALES: readonly ["pt-BR", "es", "en-US", "ro"];
+export type SupportedLocale = typeof SUPPORTED_LOCALES[number];
+export declare const LOCALE_FLAGS: Record<SupportedLocale, string>;
+export declare const LOCALE_NAMES: Record<SupportedLocale, string>;
+/**
+ * Save locale to localStorage
+ */
+export declare function saveLocale(locale: SupportedLocale): void;
+/**
+ * Initialize i18next with the shell namespace
+ * Call this once in AdminShell before rendering
+ */
+export declare function initI18n(): typeof i18n;
+/**
+ * Check if a locale is supported
+ */
+export declare function isSupportedLocale(locale: string): locale is SupportedLocale;
+export { i18n };
+export default i18n;
+//# sourceMappingURL=config.d.ts.map

package/dist/i18n/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/i18n/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,IAAI,MAAM,SAAS,CAAC;AAQ3B,eAAO,MAAM,iBAAiB,yCAA0C,CAAC;AACzE,MAAM,MAAM,eAAe,GAAG,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAE/D,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAKxD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CAKxD,CAAC;AAiBF;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAIxD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,IAAI,OAAO,IAAI,CAoCtC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,eAAe,CAE3E;AAED,OAAO,EAAE,IAAI,EAAE,CAAC;AAChB,eAAe,IAAI,CAAC"}

package/dist/i18n/config.js

@@ -0,0 +1,92 @@
+/**
+ * i18n Configuration for the Admin Platform
+ *
+ * Supports: Portuguese (Brazil), Spanish, English (US), Romanian
+ */
+import i18n from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import ptBR from './locales/pt-BR.json';
+import es from './locales/es.json';
+import enUS from './locales/en-US.json';
+import ro from './locales/ro.json';
+export const SUPPORTED_LOCALES = ['pt-BR', 'es', 'en-US', 'ro'];
+export const LOCALE_FLAGS = {
+    'pt-BR': '🇧🇷',
+    'es': '🇪🇸',
+    'en-US': '🇺🇸',
+    'ro': '🇷🇴',
+};
+export const LOCALE_NAMES = {
+    'pt-BR': 'Português (Brasil)',
+    'es': 'Español',
+    'en-US': 'English',
+    'ro': 'Română',
+};
+const STORAGE_KEY = 'adminPlatform.locale';
+/**
+ * Get the saved locale from localStorage, or return default
+ */
+function getSavedLocale() {
+    if (typeof window === 'undefined')
+        return 'pt-BR';
+    const saved = localStorage.getItem(STORAGE_KEY);
+    if (saved && SUPPORTED_LOCALES.includes(saved)) {
+        return saved;
+    }
+    return 'pt-BR';
+}
+/**
+ * Save locale to localStorage
+ */
+export function saveLocale(locale) {
+    if (typeof window !== 'undefined') {
+        localStorage.setItem(STORAGE_KEY, locale);
+    }
+}
+/**
+ * Initialize i18next with the shell namespace
+ * Call this once in AdminShell before rendering
+ */
+export function initI18n() {
+    if (i18n.isInitialized) {
+        return i18n;
+    }
+    i18n
+        .use(initReactI18next)
+        .init({
+        resources: {
+            'pt-BR': { shell: ptBR },
+            'es': { shell: es },
+            'en-US': { shell: enUS },
+            'ro': { shell: ro },
+        },
+        lng: getSavedLocale(),
+        fallbackLng: 'en-US',
+        defaultNS: 'shell',
+        ns: ['shell'],
+        interpolation: {
+            escapeValue: false, // React already escapes
+        },
+        react: {
+            useSuspense: false, // Avoid suspense issues with microfrontends
+        },
+        // Debug mode in development
+        debug: import.meta.env?.DEV ?? false,
+        // Missing key handler
+        saveMissing: false,
+        missingKeyHandler: (lngs, ns, key) => {
+            if (import.meta.env?.DEV) {
+                console.warn(`[i18n] Missing translation: ${ns}:${key} for ${lngs.join(', ')}`);
+            }
+        },
+    });
+    return i18n;
+}
+/**
+ * Check if a locale is supported
+ */
+export function isSupportedLocale(locale) {
+    return SUPPORTED_LOCALES.includes(locale);
+}
+export { i18n };
+export default i18n;