@ibdop/platform-kit 1.0.0

package/src/hooks/useInfoData.ts

@@ -0,0 +1,124 @@
+/**
+ * useInfoData - Хук для загрузки информации о версии MF
+ * 
+ * Загружает info.json с информацией о версии, Git commit, CI/CD данные
+ */
+
+import { useState, useEffect, useCallback } from 'react'
+import type { InfoData } from '../types'
+
+// Development mode flag
+const isDev = import.meta.env?.DEV === true || import.meta.env?.MODE === 'development'
+
+/**
+ * Logger for useInfoData
+ */
+const logger = {
+  log: (...args: unknown[]) => {
+    if (isDev) console.log('[useInfoData]', ...args)
+  },
+  warn: (...args: unknown[]) => {
+    if (isDev) console.warn('[useInfoData]', ...args)
+  },
+  error: (...args: unknown[]) => {
+    console.error('[useInfoData]', ...args)
+  },
+}
+
+/**
+ * Interface для props useInfoData
+ */
+interface UseInfoDataProps {
+  mfeName?: string
+}
+
+/**
+ * Interface для результата useInfoData
+ */
+interface UseInfoDataResult {
+  data: InfoData | null
+  isLoading: boolean
+  error: string | null
+  refetch: () => void
+}
+
+/**
+ * Получить mfeName из props или window
+ */
+function getMfeName(propsMfeName?: string): string {
+  if (propsMfeName) return propsMfeName
+  
+  // Try window.__MF_NAME__
+  if (typeof window !== 'undefined') {
+    const win = window as unknown as { __MF_NAME__?: string }
+    if (win.__MF_NAME__) return win.__MF_NAME__
+  }
+  
+  return 'unknown-mfe'
+}
+
+/**
+ * Централизованный хук для загрузки информации о версии MF
+ * 
+ * @param props - { mfeName?: string } - опционально имя MF
+ * @returns { data, isLoading, error, refetch }
+ * 
+ * @example
+ * ```tsx
+ * const { data, isLoading, error } = useInfoData({ mfeName: '@ib-dop/mf-home' })
+ * 
+ * if (isLoading) return <Loading />
+ * if (error) return <Error>{error}</Error>
+ * 
+ * return <Badge>{data?.BUILD_VERSION}</Badge>
+ * ```
+ */
+export function useInfoData(props?: UseInfoDataProps): UseInfoDataResult {
+  const [data, setData] = useState<InfoData | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  const fetchInfo = useCallback(() => {
+    const mfeName = getMfeName(props?.mfeName)
+    
+    // Normalize mfeName (remove @ib-dop/ prefix)
+    const normalizedName = mfeName.replace('@ib-dop/', '')
+    
+    logger.log('Fetching info for:', normalizedName)
+    setIsLoading(true)
+    setError(null)
+
+    fetch(`/svc/${normalizedName}/info.json`)
+      .then((response) => {
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+        }
+        return response.json()
+      })
+      .then((result) => {
+        logger.log('Info loaded successfully')
+        setData(result as InfoData)
+      })
+      .catch((err) => {
+        logger.error('Failed to load info:', err)
+        setError(err instanceof Error ? err.message : String(err))
+      })
+      .finally(() => {
+        setIsLoading(false)
+      })
+  }, [props?.mfeName])
+
+  useEffect(() => {
+    fetchInfo()
+  }, [fetchInfo])
+
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchInfo,
+  }
+}
+
+// Named exports
+export type { UseInfoDataProps, UseInfoDataResult }

package/src/hooks/usePermissions.ts

@@ -0,0 +1,88 @@
+/**
+ * usePermissions - Хук для проверки прав доступа
+ * 
+ * Предоставляет API для проверки прав пользователя на основе ролей
+ */
+
+import { useMemo } from 'react'
+import { useShellAuth } from './useShellAuth'
+import type { MfPermissionsConfig, MfPermissions } from '../types'
+
+// Development mode flag
+const isDev = import.meta.env?.DEV === true || import.meta.env?.MODE === 'development'
+
+/**
+ * Logger for usePermissions
+ */
+const logger = {
+  log: (...args: unknown[]) => {
+    if (isDev) console.log('[usePermissions]', ...args)
+  },
+  warn: (...args: unknown[]) => {
+    if (isDev) console.warn('[usePermissions]', ...args)
+  },
+}
+
+/**
+ * Default permissions configuration
+ */
+export const DEFAULT_PERMISSIONS_CONFIG: MfPermissionsConfig = {
+  canView: ['all'] as string[],
+  canEdit: ['ibdop-user', 'ibdop-admin', 'ibdop-devops'] as string[],
+  canDelete: ['ibdop-admin', 'ibdop-devops'] as string[],
+  canAdmin: ['ibdop-admin'] as string[],
+  canViewSensitiveData: ['ibdop-admin', 'ibdop-devops'] as string[],
+  canExportData: ['ibdop-user'] as string[],
+  canManageUsers: ['ibdop-admin'] as string[],
+}
+
+/**
+ * Централизованный хук для проверки прав доступа
+ * 
+ * @param config - конфигурация прав доступа (опционально)
+ * @returns MfPermissions - объект с правами доступа
+ * 
+ * @example
+ * ```tsx
+ * const permissions = usePermissions()
+ * 
+ * if (permissions.canAdmin) {
+ *   return <AdminPanel />
+ * }
+ * ```
+ */
+export function usePermissions(config: Partial<MfPermissionsConfig> = {}): MfPermissions {
+  const auth = useShellAuth()
+  
+  const mergedConfig = useMemo(() => ({
+    ...DEFAULT_PERMISSIONS_CONFIG,
+    ...config,
+  }), [config])
+
+  // Extract user roles
+  const userRoles = useMemo(() => {
+    const roles = auth.user?.profile?.realm_roles || auth.user?.profile?.roles || []
+    return Array.isArray(roles) ? roles : [roles]
+  }, [auth.user])
+
+  logger.log('User roles:', userRoles)
+
+  // Check if user has permission
+  const hasPermission = (requiredRoles: string[]): boolean => {
+    if (requiredRoles.includes('all')) return true
+    return requiredRoles.some(role => userRoles.includes(role))
+  }
+
+  return {
+    canView: hasPermission(mergedConfig.canView),
+    canEdit: hasPermission(mergedConfig.canEdit),
+    canDelete: hasPermission(mergedConfig.canDelete),
+    canAdmin: hasPermission(mergedConfig.canAdmin),
+    canViewSensitiveData: hasPermission(mergedConfig.canViewSensitiveData),
+    canExportData: hasPermission(mergedConfig.canExportData),
+    canManageUsers: hasPermission(mergedConfig.canManageUsers),
+  }
+}
+
+// Named exports
+export type { MfPermissionsConfig }

package/src/hooks/useShellAuth.ts

@@ -0,0 +1,145 @@
+/**
+ * useShellAuth - Хук для получения состояния авторизации из shell
+ * 
+ * Паттерн: MF подключается к shell через window.__SHELL_AUTH_INSTANCE__
+ * и ожидает события 'shell-auth-ready' если auth ещё не готов.
+ */
+
+import { useEffect, useState, useCallback, useRef } from 'react'
+import type { ShellAuth } from '../types'
+
+// Development mode flag
+const isDev = import.meta.env?.DEV === true || import.meta.env?.MODE === 'development'
+
+/**
+ * Logger for useShellAuth
+ */
+const logger = {
+  log: (...args: unknown[]) => {
+    if (isDev) console.log('[useShellAuth]', ...args)
+  },
+  warn: (...args: unknown[]) => {
+    if (isDev) console.warn('[useShellAuth]', ...args)
+  },
+}
+
+/**
+ * Получить auth из window globals
+ */
+function getAuth(): ShellAuth | null {
+  if (typeof window === 'undefined') return null
+
+  // Try __SHELL_AUTH_INSTANCE__ first
+  const win = window as unknown as { __SHELL_AUTH_INSTANCE__?: ShellAuth }
+  if (win.__SHELL_AUTH_INSTANCE__) {
+    return win.__SHELL_AUTH_INSTANCE__
+  }
+
+  // Try __SHELL_AUTH__ format
+  const win2 = window as unknown as { __SHELL_AUTH__?: { authInstance?: ShellAuth } }
+  if (win2.__SHELL_AUTH__?.authInstance) {
+    return win2.__SHELL_AUTH__.authInstance
+  }
+
+  return null
+}
+
+/**
+ * Централизованный хук для получения состояния авторизации из shell
+ * 
+ * @returns ShellAuth - объект с состоянием авторизации
+ * 
+ * @example
+ * ```tsx
+ * const auth = useShellAuth()
+ * 
+ * if (auth.isLoading) return <Loading />
+ * if (!auth.isAuthenticated) return <Login />
+ * 
+ * return <div>{auth.user?.profile?.preferred_username}</div>
+ * ```
+ */
+export function useShellAuth(): ShellAuth {
+  const [auth, setAuth] = useState<ShellAuth | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const attemptsRef = useRef(0)
+  const maxAttempts = 20 // 10 seconds max wait (20 * 500ms)
+
+  const getAuthState = useCallback((): ShellAuth | null => {
+    return getAuth()
+  }, [])
+
+  useEffect(() => {
+    // Immediate check for auth
+    const immediateAuth = getAuthState()
+    if (immediateAuth) {
+      logger.log('Auth found immediately')
+      setAuth(immediateAuth)
+      setIsLoading(false)
+      return
+    }
+
+    // Subscribe to auth ready event
+    const handleAuthReady = (event: CustomEvent<ShellAuth>) => {
+      logger.log('Auth ready via event')
+      setAuth(event.detail)
+      setIsLoading(false)
+    }
+
+    // Fallback polling with limit
+    const interval = setInterval(() => {
+      attemptsRef.current++
+      const foundAuth = getAuthState()
+      
+      if (foundAuth) {
+        logger.log('Auth found via polling, attempts:', attemptsRef.current)
+        setAuth(foundAuth)
+        setIsLoading(false)
+        clearInterval(interval)
+      } else if (attemptsRef.current >= maxAttempts) {
+        logger.warn('Auth timeout after', maxAttempts, 'attempts')
+        setIsLoading(false)
+        clearInterval(interval)
+      }
+    }, 500)
+
+    window.addEventListener('shell-auth-ready', handleAuthReady as EventListener)
+
+    return () => {
+      clearInterval(interval)
+      window.removeEventListener('shell-auth-ready', handleAuthReady as EventListener)
+    }
+  }, [getAuthState])
+
+  // Fallback auth when shell auth is not available
+  const fallbackAuth: ShellAuth = {
+    user: null,
+    isAuthenticated: false,
+    isLoading: isLoading,
+    signinRedirect: async () => {
+      logger.log('Redirecting to login')
+      const shellAuth = getAuth()
+      if (shellAuth?.signinRedirect) {
+        await shellAuth.signinRedirect()
+      } else {
+        if (typeof window !== 'undefined') {
+          window.location.href = '/'
+        }
+      }
+    },
+    removeUser: async () => {
+      const shellAuth = getAuth()
+      if (shellAuth?.removeUser) {
+        await shellAuth.removeUser()
+      }
+    },
+  }
+
+  const result = auth || fallbackAuth
+  logger.log('Auth result:', { isAuthenticated: result.isAuthenticated, isLoading: result.isLoading })
+
+  return result
+}
+
+// Named exports for specific helpers
+export { getAuth }

package/src/hooks/useV1Config.ts

@@ -0,0 +1,112 @@
+/**
+ * useV1Config - Хук для загрузки конфигурации из sessionStorage
+ * 
+ * Загружает V1 конфигурацию, которая используется для OIDC и других настроек
+ */
+
+import { useState, useEffect } from 'react'
+import type { V1ConfigData } from '../types'
+
+// Development mode flag
+const isDev = import.meta.env?.DEV === true || import.meta.env?.MODE === 'development'
+
+/**
+ * Logger for useV1Config
+ */
+const logger = {
+  log: (...args: unknown[]) => {
+    if (isDev) console.log('[useV1Config]', ...args)
+  },
+  warn: (...args: unknown[]) => {
+    if (isDev) console.warn('[useV1Config]', ...args)
+  },
+  error: (...args: unknown[]) => {
+    console.error('[useV1Config]', ...args)
+  },
+}
+
+/**
+ * Default config for fallback
+ */
+const DEFAULT_CONFIG: V1ConfigData = {
+  authority: '',
+  client_id: '',
+  environment: 'development',
+}
+
+/**
+ * Interface для результата useV1Config
+ */
+interface UseV1ConfigResult {
+  data: V1ConfigData | null
+  isLoading: boolean
+  error: string | null
+}
+
+/**
+ * Централизованный хук для загрузки конфигурации из sessionStorage
+ * 
+ * @returns { data, isLoading, error }
+ * 
+ * @example
+ * ```tsx
+ * const { data, isLoading, error } = useV1Config()
+ * 
+ * if (isLoading) return null
+ * if (error || !data) return <Error>{error}</Error>
+ * 
+ * return <ConfigDisplay config={data} />
+ * ```
+ */
+export function useV1Config(): UseV1ConfigResult {
+  const [data, setData] = useState<V1ConfigData | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    const fetchConfig = () => {
+      // Check if sessionStorage is available
+      if (typeof sessionStorage === 'undefined') {
+        logger.warn('sessionStorage not available')
+        setError('sessionStorage not available')
+        setData(DEFAULT_CONFIG)
+        setIsLoading(false)
+        return
+      }
+
+      try {
+        const storedConfig = sessionStorage.getItem('config')
+        
+        if (storedConfig) {
+          const parsed = JSON.parse(storedConfig)
+          setData({ ...DEFAULT_CONFIG, ...parsed })
+          setError(null)
+          logger.log('Config loaded successfully')
+        } else {
+          // Config not found - use defaults instead of error
+          setData(DEFAULT_CONFIG)
+          setError('Config not found in sessionStorage')
+          logger.warn('Config not found in sessionStorage')
+        }
+      } catch (err) {
+        // Parse error - use defaults
+        logger.error('Error parsing config:', err)
+        setData(DEFAULT_CONFIG)
+        setError('Error parsing config')
+      } finally {
+        setIsLoading(false)
+      }
+    }
+
+    fetchConfig()
+  }, [])
+
+  return {
+    data,
+    isLoading,
+    error,
+  }
+}
+
+// Named exports
+export type { UseV1ConfigResult }

package/src/index.ts

@@ -0,0 +1,17 @@
+/**
+ * @ib-dop/platform-kit - Platform Development Kit for Microfrontends
+ * 
+ * Unified toolkit for all microfrontends in the IB DOP Platform
+ */
+
+// Types
+export * from './types'
+
+// Hooks
+export * from './hooks'
+
+// Components
+export * from './components'
+
+// Services
+export * from './services'