@ozdao/martyrs 0.2.551 → 0.2.553

package/src/modules/core/views/classes/core.app.js

@@ -11,29 +11,46 @@ export function createUniversalApp({
 }) {
   // Lazy imports to avoid circular dependencies
   const getLayoutApp = () => import('../components/layouts/App.vue').then(m => m.default);
-  const getModuleRegistry = () => import('./module-registry.js').then(m => m.moduleRegistry);
-  const getWebsockets = () => import('./core.websocket.js').then(m => m.default);
+  const getModuleRegistry = () => import('./module.manager.js').then(m => m.moduleManager);
+  const getWebsockets = () => import('./ws.manager.js').then(m => m.default);
   const getAppRenderer = () => import('../utils/vue-app-renderer.js');
   
   // Асинхронная инициализация для избежания циклических зависимостей
   async function initializeApp() {
+    // [LOADING 14] Starting initializeApp
+    performance.mark('loading-14-start');
+    console.log('[LOADING 14] Starting application initialization...');
+
     // Создаем конфигурацию
     const config = await getConfig();
     const hooks = getHooks;
-    
-    const [layoutApp, moduleRegistry, globalWebSocket, appRenderer] = await Promise.all([
+
+    // [LOADING 15] Loading core dependencies
+    performance.mark('loading-15-start');
+    console.log('[LOADING 15] Loading core dependencies via Promise.all...');
+
+    const [layoutApp, moduleManager, wsManager, appRenderer] = await Promise.all([
       getLayoutApp(),
       getModuleRegistry(),
       getWebsockets(),
       getAppRenderer()
     ]);
+
+    performance.mark('loading-15-end');
+    performance.measure('loading-15', 'loading-15-start', 'loading-15-end');
+    const measure15 = performance.getEntriesByName('loading-15')[0];
+    console.log(`[LOADING 15] Core dependencies loaded in ${measure15?.duration?.toFixed(2)}ms`);
     
-    // Core module is always loaded - no need to register in moduleRegistry
-    
+    // Core module is always loaded - no need to register in moduleManager
+
+    // [LOADING 16] Registering modules in registry
+    performance.mark('loading-16-start');
+    console.log('[LOADING 16] Registering modules in registry...');
+
     // Регистрация модулей из config
     Object.entries(config.modules).forEach(([name, module]) => {
       if (module.loader) {
-        moduleRegistry.register(name, {
+        moduleManager.register(name, {
           loader: module.loader,
           routes: module.routes || [],
           priority: module.priority || 'normal',
@@ -43,6 +60,11 @@ export function createUniversalApp({
         });
       }
     });
+
+    performance.mark('loading-16-end');
+    performance.measure('loading-16', 'loading-16-start', 'loading-16-end');
+    const measure16 = performance.getEntriesByName('loading-16')[0];
+    console.log(`[LOADING 16] Modules registered in ${measure16?.duration?.toFixed(2)}ms`);
     
     // Основная функция создания приложения
     function createApp() {
@@ -97,75 +119,42 @@ export function createUniversalApp({
       
       // Router guard для загрузки модулей ДО навигации (только на клиенте)
       if (typeof window !== 'undefined') {
-        // const originalPush = router.push.bind(router);
-        // const originalReplace = router.replace.bind(router);
-
-        // async function paintNow() {
-        //   await nextTick();                           // flush реактивки в DOM
-        //   await new Promise(requestAnimationFrame);   // кадр layout/style
-        //   await new Promise(requestAnimationFrame);   // кадр отрисовки
-        //   // иногда в WebView помогает ещё макротаск
-        //   await new Promise(r => setTimeout(r, 0));
-        // }
-
-        // router.push = async (...args) => {
-        //   // Включаем лоадер
-        //   store.core.state.loading = true;
-          
-        //   // Даем браузеру отрисовать лоадер
-        //   await paintNow();
-          
-        //   // Запускаем навигацию асинхронно, чтобы не блокировать UI
-        //   setTimeout(() => {
-        //     originalPush(...args);
-        //   }, 0);
-          
-        //   // Возвращаем промис для совместимости
-        //   return Promise.resolve();
-        // };
-
-        // router.replace = async (...args) => {
-        //   // Включаем лоадер
-        //   store.core.state.loading = true;
-          
-        //   // Даем браузеру отрисовать лоадер
-        //   await paintNow();
-          
-        //   // Запускаем навигацию асинхронно
-        //   setTimeout(() => {
-        //     originalReplace(...args);
-        //   }, 0);
-          
-        //   return Promise.resolve();
-        // };
-
         router.beforeEach(async (to, from) => {
           // Получаем оригинальный путь ДО fallback редиректа на 404
           // Это критически важно для SSR гидратации вложенных роутов!
           const target = to.redirectedFrom || to;
           
           // Используем оригинальный путь для определения нужных модулей
-          const requiredModules = moduleRegistry.getModulesForRoute(target.path);
+          const requiredModules = moduleManager.getModulesForRoute(target.path);
           
           // Проверяем, какие модули еще не загружены
-          const modulesToLoad = requiredModules.filter(m => !moduleRegistry.initialized.has(m.name));
+          const modulesToLoad = requiredModules.filter(m => !moduleManager.initialized.has(m.name));
           
           if (modulesToLoad.length > 0) {
             // Логируем если это редирект с 404 (для отладки)
             if (to.redirectedFrom) {
               console.log('[Router] Loading modules for redirected path:', target.path, 'modules:', modulesToLoad.map(m => m.name));
             }
-            
+
+            // [LOADING 18] Loading modules for route
+            performance.mark('loading-18-start');
+            console.log(`[LOADING 18] Loading ${modulesToLoad.length} modules for route...`);
+
             // Загружаем и инициализируем модули
             for (const module of modulesToLoad) {
               try {
-                await moduleRegistry.load(module.name, context);
-                await moduleRegistry.initialize(module.name, context);
+                await moduleManager.load(module.name, context);
+                await moduleManager.initialize(module.name, context);
               } catch (error) {
                 console.error(`Failed to load module ${module.name}:`, error);
               }
             }
-            
+
+            performance.mark('loading-18-end');
+            performance.measure('loading-18', 'loading-18-start', 'loading-18-end');
+            const measure18 = performance.getEntriesByName('loading-18')[0];
+            console.log(`[LOADING 18] Modules loaded for route in ${measure18?.duration?.toFixed(2)}ms`);
+
             // После загрузки модулей и регистрации их роутов,
             // возвращаем объект с оригинальным путем и replace: true
             // Это заставит роутер заново резолвить маршрут с новыми роутами
@@ -195,17 +184,26 @@ export function createUniversalApp({
         if (hooks.beforeInitialize) {
           await hooks.beforeInitialize(context);
         }
+        // [LOADING 17] Initializing Core module
+        performance.mark('loading-17-start');
+        console.log('[LOADING 17] Initializing Core module...');
+
         // Core module must ALWAYS be initialized
         const ModuleCore = await import('../../core.client.js');
         await ModuleCore.default.initialize(app, store, router, config);
 
+        performance.mark('loading-17-end');
+        performance.measure('loading-17', 'loading-17-start', 'loading-17-end');
+        const measure17 = performance.getEntriesByName('loading-17')[0];
+        console.log(`[LOADING 17] Core module initialized in ${measure17?.duration?.toFixed(2)}ms`);
+
         // 2. WebSocket (отложим после гидратации, только если включен)
         const useWebsocket = config.globals?.websocket !== false; // по умолчанию false
 
         if (useWebsocket && typeof window !== 'undefined') {
           // Откладываем инициализацию WebSocket после гидратации
           requestIdleCallback(() => {
-            globalWebSocket.initialize({
+            wsManager.initialize({
               wsUrl: process.env.WSS_URL || undefined,
               maxReconnectAttempts: 5,
               reconnectDelay: 3000,
@@ -217,7 +215,7 @@ export function createUniversalApp({
         // 3. Предзагрузка важных модулей в фоне
         if (typeof window !== 'undefined') {
           requestIdleCallback(() => {
-            moduleRegistry.preloadModules(context);
+            moduleManager.preloadModules(context);
           });
         }
         
@@ -233,14 +231,20 @@ export function createUniversalApp({
         if (hooks.afterInitialize) {
           await hooks.afterInitialize(context);
         }
-        
+
+        // [LOADING 19] Application initialization completed
+        performance.mark('loading-19-end');
+        performance.measure('loading-19', 'loading-14-start', 'loading-19-end');
+        const measure19 = performance.getEntriesByName('loading-19')[0];
+        console.log(`[LOADING 19] Application initialization completed in ${measure19?.duration?.toFixed(2)}ms`);
+
         return {
           app,
           router,
           store,
           i18n,
           meta,
-          moduleRegistry,
+          moduleManager,
           config,
         };
       };
@@ -256,7 +260,7 @@ export function createUniversalApp({
     
     // FOR SSR / SERVER ENTRY
     async function renderApp({ url, cookies, languages, ssrContext }) {
-      const { app, router, store, i18n, meta, moduleRegistry } = await createApp();
+      const { app, router, store, i18n, meta, moduleManager } = await createApp();
       
       // Set SSR store for useStore calls
       if (typeof window === 'undefined') {
@@ -264,19 +268,16 @@ export function createUniversalApp({
         setSSRStore(store);
       }
       
-      
+
       if (typeof window === 'undefined') {
-        moduleRegistry.initialized.clear();
-        moduleRegistry.modules.clear();
-        moduleRegistry.loadingPromises.clear();
+        moduleManager.initialized.clear();
+        moduleManager.modules.clear();
+        moduleManager.loadingPromises.clear();
+
+        // Очистить SSR store для следующего запроса
+        const { clearSSRStore } = await import('../store/core.store.js');
+        clearSSRStore();
       }
-      //   // На сервере загружаем auth для SSR рендеринга (vue-app-renderer требует его)
-      //   const context = { app, store, router, config };
-      //   await moduleRegistry.load('globals', context);
-      //   await moduleRegistry.initialize('globals', context);
-      //   await moduleRegistry.load('auth', context);
-      //   await moduleRegistry.initialize('auth', context);
-      // }
       
       const context = {
         app,
@@ -286,22 +287,27 @@ export function createUniversalApp({
         ssr: true,
       };
 
-      // Core module must ALWAYS be initialized on SSR
-      const ModuleCore = await import('../../core.client.js');
-      await ModuleCore.default.initialize(app, store, router, config);
+      // [LOADING 20] SSR renderApp starting and loading modules
+      performance.mark('loading-20-start');
+      console.log('[LOADING 20] SSR renderApp starting and loading modules...');
 
       // Для SSR загружаем модули для текущего маршрута
-      const requiredModules = moduleRegistry.getModulesForRoute(url);
-      
+      const requiredModules = moduleManager.getModulesForRoute(url);
+
       // Собираем имена модулей которые нужны для текущего роута
       const currentRouteModules = [];
-      
+
       // Загружаем необходимые модули для SSR
       for (const module of requiredModules) {
-        await moduleRegistry.load(module.name, context);
-        await moduleRegistry.initialize(module.name, context);
+        await moduleManager.load(module.name, context);
+        await moduleManager.initialize(module.name, context);
         currentRouteModules.push(module.name);
       }
+
+      performance.mark('loading-20-end');
+      performance.measure('loading-20', 'loading-20-start', 'loading-20-end');
+      const measure20 = performance.getEntriesByName('loading-20')[0];
+      console.log(`[LOADING 20] SSR modules loaded in ${measure20?.duration?.toFixed(2)}ms`);
       
       // После загрузки модулей и регистрации роутов, выполняем навигацию
       await router.push(url);
@@ -320,7 +326,13 @@ export function createUniversalApp({
       
       // Передаем только модули текущего роута (без критических)
       result.loadedModules = currentRouteModules;
-      
+
+      // [LOADING 21] SSR render completed
+      performance.mark('loading-21-end');
+      performance.measure('loading-21', 'loading-20-start', 'loading-21-end');
+      const measure21 = performance.getEntriesByName('loading-21')[0];
+      console.log(`[LOADING 21] SSR render completed in ${measure21?.duration?.toFixed(2)}ms`);
+
       return result;
     }
     
@@ -332,10 +344,10 @@ export function createUniversalApp({
     // FOR SSR / CLIENT ENTRY
     if (typeof window !== 'undefined' && !process.env.MOBILE_APP) {
       // Используем renderAndMountApp для правильной гидратации со state
-      appRenderer.renderAndMountApp({ createApp, hooks }).then(({ app, router, store, moduleRegistry }) => {
+      appRenderer.renderAndMountApp({ createApp, hooks }).then(({ app, router, store, moduleManager }) => {
         // Хук ПОСЛЕ гидратации
         if (hooks.afterHydration) {
-          hooks.afterHydration({ app, router, store, moduleRegistry });
+          hooks.afterHydration({ app, router, store, moduleManager });
         }
         
         // Модули уже загружены в renderAndMountApp, просто ставим маркер

package/src/modules/core/views/classes/{module-registry.js → module.manager.js}

@@ -1,7 +1,7 @@
-// module-registry.js - централизованный регистр модулей
+// module.manager.js - централизованный регистр модулей
 import { ref, readonly } from 'vue';
 
-export class ModuleRegistry {
+export class ModuleManager {
   constructor() {
     this.modules = new Map();
     this.loaders = new Map();
@@ -55,17 +55,38 @@ export class ModuleRegistry {
 
   // Внутренний метод для загрузки модуля
   async _loadModule(name, context, config) {
+    // [LOADING 29] Starting module loading with dependencies
+    performance.mark(`loading-29-${name}-start`);
+    console.log(`[LOADING 29] Starting to load module "${name}" with dependencies...`);
+
     const loadStart = Date.now();
 
-    // Загружаем зависимости
+    // [LOADING 30] Loading module dependencies
     if (config.dependencies.length > 0) {
+      performance.mark(`loading-30-${name}-deps-start`);
+      console.log(`[LOADING 30] Loading ${config.dependencies.length} dependencies for module "${name}"...`);
+
       await Promise.all(
         config.dependencies.map(dep => this.load(dep, context))
       );
+
+      performance.mark(`loading-30-${name}-deps-end`);
+      performance.measure(`loading-30-${name}-deps`, `loading-30-${name}-deps-start`, `loading-30-${name}-deps-end`);
+      const measure30 = performance.getEntriesByName(`loading-30-${name}-deps`)[0];
+      console.log(`[LOADING 30] Dependencies for "${name}" loaded in ${measure30?.duration?.toFixed(2)}ms`);
     }
 
+    // [LOADING 31] Loading the module itself
+    performance.mark(`loading-31-${name}-start`);
+    console.log(`[LOADING 31] Loading module "${name}" via loader...`);
+
     // Загружаем сам модуль
     const module = await config.loader();
+
+    performance.mark(`loading-31-${name}-end`);
+    performance.measure(`loading-31-${name}`, `loading-31-${name}-start`, `loading-31-${name}-end`);
+    const measure31 = performance.getEntriesByName(`loading-31-${name}`)[0];
+    console.log(`[LOADING 31] Module "${name}" loaded in ${measure31?.duration?.toFixed(2)}ms`);
     
     const mod = module.default || module;
     
@@ -76,6 +97,12 @@ export class ModuleRegistry {
       await this.initialize(name, context);
     }
 
+    // [LOADING 29] Module loading completed
+    performance.mark(`loading-29-${name}-end`);
+    performance.measure(`loading-29-${name}`, `loading-29-${name}-start`, `loading-29-${name}-end`);
+    const measure29 = performance.getEntriesByName(`loading-29-${name}`)[0];
+    console.log(`[LOADING 29] Module "${name}" fully loaded and initialized in ${measure29?.duration?.toFixed(2)}ms`);
+
     return mod;
   }
 
@@ -86,6 +113,10 @@ export class ModuleRegistry {
       return;
     }
 
+    // [LOADING 32] Module initialization
+    performance.mark(`loading-32-${name}-start`);
+    console.log(`[LOADING 32] Initializing module "${name}"...`);
+
     // Инициализируем зависимости
     const moduleConfig = this.loaders.get(name);
     if (moduleConfig.dependencies.length > 0) {
@@ -100,8 +131,13 @@ export class ModuleRegistry {
     if (initFunc) {
       await initFunc(app, store, router, config);
     }
-    
+
     this.initialized.set(name, true);
+
+    performance.mark(`loading-32-${name}-end`);
+    performance.measure(`loading-32-${name}`, `loading-32-${name}-start`, `loading-32-${name}-end`);
+    const measure32 = performance.getEntriesByName(`loading-32-${name}`)[0];
+    console.log(`[LOADING 32] Module "${name}" initialized in ${measure32?.duration?.toFixed(2)}ms`);
   }
 
   // Вспомогательная функция для матчинга Vue Router паттернов
@@ -117,6 +153,10 @@ export class ModuleRegistry {
 
   // Получить модули для маршрута
   getModulesForRoute(path) {
+    // [LOADING 34] Finding modules for route
+    performance.mark(`loading-34-route-start`);
+    console.log(`[LOADING 34] Finding modules for route: ${path}...`);
+
     const modules = [];
 
     // Нормализуем путь - убираем trailing slash если это не корень
@@ -151,10 +191,17 @@ export class ModuleRegistry {
     }
 
     // Сортируем по приоритету
-    return modules.sort((a, b) => {
+    const sortedModules = modules.sort((a, b) => {
       const priorities = { critical: 0, high: 1, normal: 2, low: 3 };
       return (priorities[a.priority] || 2) - (priorities[b.priority] || 2);
     });
+
+    performance.mark(`loading-34-route-end`);
+    performance.measure(`loading-34-route`, `loading-34-route-start`, `loading-34-route-end`);
+    const measure34 = performance.getEntriesByName(`loading-34-route`)[0];
+    console.log(`[LOADING 34] Found ${modules.length} modules for route in ${measure34?.duration?.toFixed(2)}ms`);
+
+    return sortedModules;
   }
   
   // Получить критические модули для маршрута (для SSR)
@@ -201,10 +248,20 @@ export class ModuleRegistry {
       return (priorities[a.priority] || 2) - (priorities[b.priority] || 2);
     });
 
-    // Загружаем критические синхронно
+    // [LOADING 33] Preload critical modules
     const critical = toPreload.filter(m => m.critical);
-    for (const module of critical) {
-      await this.load(module.name, context);
+    if (critical.length > 0) {
+      performance.mark('loading-33-start');
+      console.log(`[LOADING 33] Preloading ${critical.length} critical modules...`);
+
+      for (const module of critical) {
+        await this.load(module.name, context);
+      }
+
+      performance.mark('loading-33-end');
+      performance.measure('loading-33', 'loading-33-start', 'loading-33-end');
+      const measure33 = performance.getEntriesByName('loading-33')[0];
+      console.log(`[LOADING 33] Critical modules preloaded in ${measure33?.duration?.toFixed(2)}ms`);
     }
 
     // Остальные в фоне
@@ -222,12 +279,12 @@ export class ModuleRegistry {
 
 }
 
-// Создаем глобальный регистр
-export const moduleRegistry = new ModuleRegistry();
+// Создаем глобальный менеджер
+export const moduleManager = new ModuleManager();
 
 // Утилита для использования в компонентах
 export async function useModule(name) {
-  return moduleRegistry.load(name);
+  return moduleManager.load(name);
 }
 
 // Composable для Vue
@@ -238,9 +295,9 @@ export function useModuleLoader() {
   const loadModule = async (name) => {
     loading.value = true;
     error.value = null;
-    
+
     try {
-      const module = await moduleRegistry.load(name);
+      const module = await moduleManager.load(name);
       return module;
     } catch (e) {
       error.value = e;

package/src/modules/core/views/classes/{session.js → session.manager.js}

@@ -1,4 +1,4 @@
-class Session {
+class SessionManager {
   constructor(sessionState) {
     this.sessionState = sessionState;
     this.listeners = [];
@@ -54,4 +54,4 @@ class Session {
   }
 }
 
-export default Session;
+export default SessionManager;

package/src/modules/core/views/classes/{core.store.js → store.manager.js}

@@ -3,7 +3,7 @@ import { reactive } from 'vue';
 import { setError } from '@martyrs/src/modules/core/views/store/core.store.js';
 import { buildURL } from '../utils/query-serializer.js';
 
-class Store {
+class StoreManager {
   constructor(apiUrl) {
     this.state = reactive({
       items: [],
@@ -175,4 +175,4 @@ class Store {
   }
 }
 
-export default Store;
+export default StoreManager;

package/src/modules/core/views/classes/{core.websocket.js → ws.manager.js}

@@ -1,4 +1,4 @@
-class GlobalWebSocket {
+class WebSocketManager {
   constructor() {
     this.socket = null;
     this.isConnected = false;
@@ -365,5 +365,6 @@ class GlobalWebSocket {
   }
 }
 
-const globalWebSocket = new GlobalWebSocket();
-export default globalWebSocket;
+const wsManager = new WebSocketManager();
+export { wsManager };
+export default wsManager;

package/src/modules/core/views/components/blocks/HelpCard.vue

@@ -13,9 +13,11 @@
 </template>
 
 <script setup>
-import * as core from '@martyrs/src/modules/core/views/store/core.store.js';
+import { useStore } from '@martyrs/src/modules/core/views/store/core.store.js';
 import { computed } from 'vue';
 
+const store = useStore()
+
 defineProps({
   theme: {
     type: String,
@@ -23,7 +25,7 @@ defineProps({
   }
 });
 
-const supportUrl = computed(() => core.state.config?.app?.support?.url);
+const supportUrl = computed(() => store.core.state.config?.app?.support?.url);
 </script>
 
 <style scoped>

package/src/modules/core/views/components/layouts/App.vue

@@ -21,9 +21,11 @@
   import { useI18n } from 'vue-i18n'
   import { useRoute } from 'vue-router'
 
-  import * as core from '@martyrs/src/modules/core/views/store/core.store.js'
+  import { useStore } from '@martyrs/src/modules/core/views/store/core.store.js'
   import * as auth from '@martyrs/src/modules/auth/views/store/auth.js'
 
+  const store = useStore()
+
   const props = defineProps({
     env: {
       type: Object,
@@ -107,12 +109,12 @@
   useHead(metadata)
 
   onBeforeMount(async()=>{
-    if (process.env.MOBILE_APP === 'ios') Keyboard.setAccessoryBarVisible({ isVisible: false }) 
+    if (process.env.MOBILE_APP === 'ios') Keyboard.setAccessoryBarVisible({ isVisible: false })
 
     const { value } = await Preferences.get({ key: 'darkmode' });
 
     const isDarkMode = value ? JSON.parse(value) : false;
-    
-    core.actions.setTheme(isDarkMode);
+
+    store.core.actions.setTheme(isDarkMode);
   })
 </script>