Build Tools & Configuration

/**
 * Returns current worker file mappings
 * @returns Record mapping worker names to their file paths
 */
function getWorkers(): Record<string, string>;

/**
 * Resolves the workers root directory from project configuration
 * @returns Absolute path to workers directory
 */
function resolveWorkersRootDir(): string;

/**
 * Initializes worker mappings from specified directories
 * @param workersDirs - Array of worker directory paths to scan
 * @param rootDir - Project root directory path
 * @returns Record mapping worker names to their resolved paths
 */
function initWorkers(workersDirs: string[], rootDir: string): Record<string, string>;

/**
 * Vite plugin for uni-app worker support and compilation
 * @returns Vite plugin configuration for worker processing
 */
function uniWorkersPlugin(): Plugin;

/**
 * JavaScript-specific worker support plugin for enhanced JS worker handling
 * @returns Vite plugin for JavaScript worker compilation
 */
function uniJavaScriptWorkersPlugin(): Plugin;

/**
 * Resolves worker directories from manifest configuration
 * @param inputDir - Input directory to scan for worker configurations
 * @returns Array of resolved worker directory paths
 */
function resolveWorkersDir(inputDir: string): string[];

import { 
  getWorkers,
  initWorkers,
  uniWorkersPlugin,
  resolveWorkersRootDir 
} from "@dcloudio/uni-cli-shared";

// Initialize workers from project directories
const workerDirs = ['./src/workers', './uni_modules/*/workers'];
const rootDir = process.cwd();
const workerMappings = initWorkers(workerDirs, rootDir);

console.log('Available workers:', workerMappings);
// { 'data-processor': '/path/to/src/workers/data-processor.js' }

// Get current worker configuration
const currentWorkers = getWorkers();

// Vite configuration with worker support
export default {
  plugins: [
    uniWorkersPlugin(),
    uniJavaScriptWorkersPlugin()
  ],
  worker: {
    format: 'es',
    plugins: []
  }
};

/**
 * Creates a Vite plugin for HBuilderX console integration and logging
 * @param method - Console method name for logging (defaults to '__f__')
 * @returns Vite plugin for enhanced HBuilderX development experience
 */
function uniHBuilderXConsolePlugin(method?: string): Plugin;

/**
 * Checks if console logging is enabled in development environment
 * @returns True if console logging should be active
 */
function isEnableConsole(): boolean;

import { 
  uniHBuilderXConsolePlugin, 
  isEnableConsole 
} from "@dcloudio/uni-cli-shared";

// Vite configuration for HBuilderX development
export default {
  plugins: [
    // Enable HBuilderX console integration
    uniHBuilderXConsolePlugin('__hbx_log__'),
    
    // Conditional logging based on environment
    isEnableConsole() && {
      name: 'dev-logger',
      configureServer(server) {
        server.middlewares.use('/api/log', loggerMiddleware);
      }
    }
  ].filter(Boolean)
};

// Check console status in development workflow
if (isEnableConsole()) {
  console.log('Development logging enabled');
} else {
  console.log('Production mode - logging disabled');
}

// Vite-specific utilities and plugins (from ./vite module)
// Complete Vite integration API available through main export

// ESBuild utilities and configurations (from ./esbuild module)  
// Complete ESBuild API available through main export

// PostCSS plugins and utilities (from ./postcss module)
// Complete PostCSS API available through main export

import { 
  uniWorkersPlugin,
  uniHBuilderXConsolePlugin,
  isEnableConsole 
} from "@dcloudio/uni-cli-shared";

// Complete development server configuration
export default defineConfig({
  plugins: [
    vue(),
    
    // Worker support for background processing
    uniWorkersPlugin(),
    uniJavaScriptWorkersPlugin(),
    
    // HBuilderX IDE integration
    uniHBuilderXConsolePlugin(),
    
    // Conditional development plugins
    ...(isEnableConsole() ? [
      {
        name: 'dev-tools',
        configureServer(server) {
          // Enhanced development middleware
        }
      }
    ] : [])
  ],
  
  server: {
    port: 3000,
    host: true
  },
  
  worker: {
    format: 'es'
  }
});

import { 
  getWorkers,
  resolveWorkersRootDir 
} from "@dcloudio/uni-cli-shared";

export default defineConfig({
  build: {
    rollupOptions: {
      input: {
        main: './src/main.ts',
        ...getWorkers() // Include all workers in build
      },
      
      output: {
        chunkFileNames: 'js/[name].[hash].js',
        entryFileNames: 'js/[name].[hash].js',
        
        // Separate worker outputs
        manualChunks(id) {
          const workersRoot = resolveWorkersRootDir();
          if (id.includes(workersRoot)) {
            return 'workers';
          }
        }
      }
    },
    
    // Production optimizations
    minify: 'esbuild',
    target: ['es2015', 'chrome63'],
    cssCodeSplit: true
  }
});

import { 
  initWorkers,
  uniWorkersPlugin 
} from "@dcloudio/uni-cli-shared";

// Configure builds for different uni-app platforms
const platformConfigs = {
  'h5': {
    plugins: [
      uniWorkersPlugin(),
      // H5-specific plugins
    ]
  },
  
  'app-plus': {
    plugins: [
      uniWorkersPlugin(),
      // Native app plugins
    ]
  },
  
  'mp-weixin': {
    plugins: [
      // Mini-program specific worker handling
      uniWorkersPlugin()
    ]
  }
};

export default ({ command, mode }) => {
  const platform = process.env.UNI_PLATFORM || 'h5';
  const config = platformConfigs[platform];
  
  // Initialize platform-specific workers
  if (platform === 'app-plus') {
    const workers = initWorkers(['./src/native-workers'], process.cwd());
    console.log('Native workers:', workers);
  }
  
  return defineConfig(config);
};

import { 
  initWorkers,
  getWorkers,
  resolveWorkersDir 
} from "@dcloudio/uni-cli-shared";

// Advanced worker management
class UniWorkerManager {
  private workers: Record<string, string> = {};
  
  async initialize(projectRoot: string) {
    // Discover worker directories from manifest
    const workerDirs = resolveWorkersDir(projectRoot);
    
    // Initialize worker mappings
    this.workers = initWorkers(workerDirs, projectRoot);
    
    console.log('Initialized workers:', Object.keys(this.workers));
  }
  
  getWorkerPath(name: string): string | undefined {
    return this.workers[name];
  }
  
  getAllWorkers(): Record<string, string> {
    return { ...this.workers };
  }
  
  // Dynamic worker loading
  async loadWorker(name: string): Promise<Worker | null> {
    const workerPath = this.getWorkerPath(name);
    if (!workerPath) return null;
    
    return new Worker(workerPath, { 
      type: 'module' 
    });
  }
}

// Usage in application
const workerManager = new UniWorkerManager();
await workerManager.initialize('./');

// Load specific worker
const dataWorker = await workerManager.loadWorker('data-processor');
if (dataWorker) {
  dataWorker.postMessage({ action: 'process', data: [...] });
}

import { 
  uniHBuilderXConsolePlugin, 
  isEnableConsole 
} from "@dcloudio/uni-cli-shared";

// Enhanced console integration for development
const createConsolePlugin = () => {
  if (!isEnableConsole()) return null;
  
  return {
    name: 'uni-console-enhanced',
    configureServer(server) {
      // WebSocket connection for real-time logging
      server.ws.on('uni:console', (data) => {
        console.log('[UNI]', data);
      });
    },
    
    transform(code, id) {
      if (id.includes('.vue')) {
        // Inject console helpers in Vue components
        return {
          code: `
            ${code}
            if (process.env.NODE_ENV === 'development') {
              // Enhanced logging for Vue components
            }
          `,
          map: null
        };
      }
    }
  };
};

// Use in Vite config
export default {
  plugins: [
    uniHBuilderXConsolePlugin('__hbx__'),
    createConsolePlugin()
  ].filter(Boolean)
};

import { uniJavaScriptWorkersPlugin } from "@dcloudio/uni-cli-shared";

// Optimize worker performance with code splitting
export default {
  plugins: [
    uniJavaScriptWorkersPlugin()
  ],
  
  worker: {
    rollupOptions: {
      output: {
        format: 'es',
        // Optimize worker bundle size
        manualChunks: {
          'worker-utils': ['./src/workers/utils'],
          'worker-vendor': ['lodash', 'axios']
        }
      }
    }
  }
};

import { 
  getWorkers,
  isEnableConsole 
} from "@dcloudio/uni-cli-shared";

export default defineConfig({
  build: {
    // Production optimizations
    rollupOptions: {
      output: {
        // Separate worker code from main bundle
        manualChunks: {
          workers: Object.values(getWorkers())
        }
      }
    },
    
    // Conditional development features
    define: {
      '__DEV__': JSON.stringify(isEnableConsole()),
      '__WORKERS_ENABLED__': JSON.stringify(
        Object.keys(getWorkers()).length > 0
      )
    }
  }
});