@dbs-portal/tool-mock/dist/build/utils.js

API mocking toolkit using MSW for DBS Portal development workflows

/**
 * Build utilities for MSW integration
 */
/**
 * Build configuration utilities
 */
export const buildUtils = {
    /**
     * Create build configuration for MSW
     */
    createBuildConfig: (config = {}) => {
        const { outDir = 'dist', srcDir = 'src', sourcemap = true, minify = true, external = ['msw'], } = config;
        return {
            build: {
                outDir,
                sourcemap,
                minify,
                lib: {
                    entry: `${srcDir}/index.ts`,
                    formats: ['es', 'cjs'],
                    fileName: (format) => `index.${format === 'es' ? 'mjs' : 'js'}`,
                },
                rollupOptions: {
                    external,
                    output: {
                        globals: {
                            msw: 'msw',
                        },
                    },
                },
            },
        };
    },
    /**
     * Create library build configuration
     */
    createLibraryConfig: (config) => {
        const baseConfig = buildUtils.createBuildConfig(config);
        return {
            ...baseConfig,
            build: {
                ...baseConfig.build,
                lib: {
                    ...baseConfig.build.lib,
                    name: config.name,
                },
            },
        };
    },
    /**
     * Create development build configuration
     */
    createDevConfig: (config = {}) => {
        const baseConfig = buildUtils.createBuildConfig(config);
        return {
            ...baseConfig,
            build: {
                ...baseConfig.build,
                minify: false,
                sourcemap: true,
            },
        };
    },
};
/**
 * Mock module utilities
 */
export const mockModuleUtils = {
    /**
     * Create mock module configuration
     */
    createModuleConfig: (config) => {
        return {
            autoImport: true,
            condition: () => true,
            ...config,
        };
    },
    /**
     * Generate mock module imports
     */
    generateModuleImports: (modules) => {
        const imports = modules
            .filter(module => module.autoImport && (!module.condition || module.condition()))
            .map(module => `import ${module.name} from '${module.path}';`)
            .join('\n');
        const exports = modules
            .filter(module => module.autoImport && (!module.condition || module.condition()))
            .map(module => module.name)
            .join(', ');
        return `
${imports}

export { ${exports} };

export const mockModules = {
  ${modules.map(module => `${module.name}: ${module.name}`).join(',\n  ')}
};
`;
    },
    /**
     * Create conditional module loader
     */
    createConditionalLoader: (modules) => {
        return `
export async function loadMockModules() {
  const modules = {};
  
  ${modules.map(module => `
  if (${module.condition?.toString() || 'true'}) {
    try {
      const module = await import('${module.path}');
      modules['${module.name}'] = module;
    } catch (error) {
      console.warn('Failed to load mock module ${module.name}:', error);
    }
  }
  `).join('\n')}
  
  return modules;
}
`;
    },
};
/**
 * Hot reload utilities
 */
export const hotReloadUtils = {
    /**
     * Create hot reload configuration
     */
    createHotReloadConfig: (config = {}) => {
        return {
            enabled: true,
            watchPatterns: ['src/**/*mock*', 'src/**/*handler*'],
            debounceDelay: 300,
            strategy: 'handlers-only',
            ...config,
        };
    },
    /**
     * Generate hot reload code
     */
    generateHotReloadCode: (config) => {
        if (!config.enabled) {
            return '';
        }
        return `
if (import.meta.hot) {
  import.meta.hot.accept((newModule) => {
    if (newModule) {
      console.log('MSW: Hot reloading mock handlers');
      
      // Reload strategy: ${config.strategy}
      if ('${config.strategy}' === 'handlers-only') {
        // Reload only handlers
        if (typeof window !== 'undefined' && window.__MSW_RELOAD_HANDLERS__) {
          window.__MSW_RELOAD_HANDLERS__(newModule);
        }
      } else {
        // Full reload
        window.location.reload();
      }
    }
  });
}
`;
    },
    /**
     * Create file watcher patterns
     */
    createWatchPatterns: (patterns = []) => {
        const defaultPatterns = [
            'src/**/*mock*',
            'src/**/*handler*',
            'src/**/*.mock.*',
            'src/**/*.handler.*',
        ];
        return [...defaultPatterns, ...patterns];
    },
};
/**
 * Environment utilities
 */
export const envUtils = {
    /**
     * Create environment-specific configuration
     */
    createEnvConfig: (env) => {
        switch (env) {
            case 'development':
                return {
                    mswEnabled: true,
                    mswLogging: true,
                    mswDelay: [100, 300],
                    hotReload: true,
                    sourcemap: true,
                    minify: false,
                };
            case 'test':
                return {
                    mswEnabled: true,
                    mswLogging: false,
                    mswDelay: 0,
                    hotReload: false,
                    sourcemap: true,
                    minify: false,
                };
            case 'production':
                return {
                    mswEnabled: false,
                    mswLogging: false,
                    mswDelay: 0,
                    hotReload: false,
                    sourcemap: false,
                    minify: true,
                };
            default:
                return {};
        }
    },
    /**
     * Generate environment variables
     */
    generateEnvVars: (config) => {
        return {
            VITE_MSW_ENABLED: String(config.mswEnabled || false),
            VITE_MSW_LOGGING: String(config.mswLogging || false),
            VITE_MSW_DELAY: String(config.mswDelay || 0),
            VITE_HOT_RELOAD: String(config.hotReload || false),
        };
    },
};
/**
 * Bundle analysis utilities
 */
export const bundleUtils = {
    /**
     * Analyze MSW bundle impact
     */
    analyzeMSWImpact: (bundleStats) => {
        const mswModules = bundleStats.modules?.filter((module) => module.name?.includes('msw') ||
            module.name?.includes('mock')) || [];
        const totalSize = mswModules.reduce((sum, module) => sum + (module.size || 0), 0);
        return {
            moduleCount: mswModules.length,
            totalSize,
            modules: mswModules,
            impact: {
                percentage: bundleStats.totalSize ? (totalSize / bundleStats.totalSize) * 100 : 0,
                recommendation: totalSize > 100000 ? 'Consider code splitting' : 'Size is acceptable',
            },
        };
    },
    /**
     * Generate bundle report
     */
    generateBundleReport: (analysis) => {
        return `
# MSW Bundle Analysis Report

## Summary
- Mock modules: ${analysis.moduleCount}
- Total size: ${(analysis.totalSize / 1024).toFixed(2)} KB
- Bundle impact: ${analysis.impact.percentage.toFixed(2)}%

## Recommendation
${analysis.impact.recommendation}

## Modules
${analysis.modules.map((module) => `- ${module.name}: ${(module.size / 1024).toFixed(2)} KB`).join('\n')}
`;
    },
};
/**
 * Performance utilities
 */
export const performanceUtils = {
    /**
     * Create performance monitoring
     */
    createPerformanceMonitor: () => {
        const metrics = {
            mswSetupTime: 0,
            handlerRegistrationTime: 0,
            requestInterceptionTime: 0,
        };
        return {
            startTimer: (metric) => {
                const start = performance.now();
                return () => {
                    metrics[metric] = performance.now() - start;
                };
            },
            getMetrics: () => ({ ...metrics }),
            reset: () => {
                Object.keys(metrics).forEach(key => {
                    metrics[key] = 0;
                });
            },
        };
    },
    /**
     * Generate performance report
     */
    generatePerformanceReport: (metrics) => {
        return `
# MSW Performance Report

## Setup Performance
- MSW Setup: ${metrics.mswSetupTime.toFixed(2)}ms
- Handler Registration: ${metrics.handlerRegistrationTime.toFixed(2)}ms
- Request Interception: ${metrics.requestInterceptionTime.toFixed(2)}ms

## Total Overhead
${(metrics.mswSetupTime + metrics.handlerRegistrationTime).toFixed(2)}ms
`;
    },
};
//# sourceMappingURL=utils.js.map