or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.md
tile.json

tessl/npm-tarojs--mini-runner

Webpack launcher for mini-program compilation within the Taro ecosystem that converts Taro configurations into Webpack configurations

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@tarojs/mini-runner@4.0.x

To install, run

npx @tessl/cli install tessl/npm-tarojs--mini-runner@4.0.0

index.mddocs/

Taro Mini Runner

Taro Mini Runner is a Webpack launcher for mini-program compilation within the Taro ecosystem. It converts Taro-specific compilation configurations into standard Webpack configurations and compiles source code to be compatible with various mini-program directory structures across multiple platforms.

Package Information

  • Package Name: @tarojs/mini-runner
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install @tarojs/mini-runner

Core Imports

import build from "@tarojs/mini-runner";

For CommonJS:

const build = require("@tarojs/mini-runner");

Named imports for utilities:

import { isQuickAppPkg, resolveNpmSync } from "@tarojs/mini-runner";

Basic Usage

import build from "@tarojs/mini-runner";

// Configure build settings
const config = {
  mode: "production",
  platform: "weapp", // WeChat mini-program
  deviceRatio: {
    640: 2.34 / 2,
    750: 1,
    828: 1.81 / 2
  },
  sourceDir: "src",
  outputDir: "dist",
  plugins: [],
  defineConstants: {},
  copy: {
    patterns: [],
    options: {}
  },
  // ... other Taro build configuration options
};

// Run the build process
try {
  await build("/path/to/project", config);
  console.log("Build completed successfully");
} catch (error) {
  console.error("Build failed:", error);
}

Architecture

Taro Mini Runner is designed around several key components:

  • Build Orchestrator: Main build function that coordinates the compilation process
  • Webpack Configuration Generator: Converts Taro configurations into Webpack-compatible settings
  • Platform Adapters: Support for multiple mini-program platforms with platform-specific optimizations
  • Asset Processing: Handles CSS, images, and other static assets for mini-program environments
  • Module Resolution: Custom npm package resolution for mini-program constraints

Capabilities

Build Function

The primary build function that handles webpack configuration generation and compilation process.

/**
 * Main build function for compiling Taro projects to mini-programs
 * @param appPath - Absolute path to the project root directory
 * @param config - Taro build configuration object
 * @returns Promise that resolves when build completes
 */
function build(appPath: string, config: IBuildConfig): Promise<void>;

Package Utilities

Utility functions for package management and resolution within the Taro ecosystem.

/**
 * Checks if a package name matches QuickApp platform patterns
 * @param name - Package name to check
 * @returns True if package is a QuickApp system or service package
 */
function isQuickAppPkg(name: string): boolean;

/**
 * Synchronously resolves npm package path with caching
 * @param pkgName - Package name to resolve
 * @param root - Root directory for package resolution
 * @returns Resolved package path or null if not found
 */
function resolveNpmSync(pkgName: string, root: string): string | null;

Types

Build Configuration Interface

interface IBuildConfig {
  /** Build mode: 'development' or 'production' */
  mode: 'development' | 'production';
  
  /** Target mini-program platform */
  platform: 'weapp' | 'swan' | 'alipay' | 'tt' | 'jd' | 'qq' | 'quickapp';
  
  /** Project source directory */
  sourceDir: string;
  
  /** Build output directory */
  outputDir: string;
  
  /** Device pixel ratio mappings for responsive design */
  deviceRatio: Record<number, number>;
  
  /** Webpack plugins array */
  plugins: any[];
  
  /** Build-time constants definition */
  defineConstants: Record<string, any>;
  
  /** File copy configuration */
  copy: {
    patterns: any[];
    options: Record<string, any>;
  };
  
  /** CSS modules configuration */
  cssModules?: {
    enable: boolean;
    config: Record<string, any>;
  };
  
  /** PostCSS configuration */
  postcss?: {
    pxtransform: {
      enable: boolean;
      config: Record<string, any>;
    };
    autoprefixer: {
      enable: boolean;
      config: Record<string, any>;
    };
    cssModules: {
      enable: boolean;
      config: Record<string, any>;
    };
  };
  
  /** SASS/SCSS configuration */
  sass?: Record<string, any>;
  
  /** Less configuration */
  less?: Record<string, any>;
  
  /** Stylus configuration */
  stylus?: Record<string, any>;
  
  /** Webpack optimization settings */
  optimization?: {
    splitChunks?: Record<string, any>;
  };
  
  /** Custom webpack configuration function or object */
  webpackChain?: (chain: any, webpack: any) => void;
  
  /** Additional webpack configuration */
  webpack?: Record<string, any>;
  
  /** Build completion callback */
  onBuildFinish?: (error?: Error, stats?: webpack.Stats) => void;
  
  /** Watch mode settings */
  isWatch?: boolean;
  
  /** Enable prerendering */
  prerender?: boolean;
}

Component Interface

interface IComponent {
  /** Component name */
  name: string;
  
  /** Component file path */
  path: string;
  
  /** Whether component is platform-native */
  isNative: boolean;
}

File Type Interface

interface IFileType {
  /** Style file extensions */
  style: string;
  
  /** Script file extensions */
  script: string;
  
  /** Template file extensions */
  templ: string;
  
  /** Configuration file extensions */
  config: string;
  
  /** Optional additional script extensions (for platforms like QuickApp) */
  xs?: string;
}

Option Interface

interface IOption {
  /** Generic key-value object for configuration options */
  [key: string]: any;
}

Custom Webpack Configuration

type CustomWebpackConfig = 
  | ((config: webpack.Configuration, webpack: any) => webpack.Configuration)
  | webpack.Configuration;

Platform Support

Taro Mini Runner supports compilation for multiple mini-program platforms:

  • WeChat Mini Programs (weapp) - WeChat's mini-program platform
  • Baidu Smart Programs (swan) - Baidu's smart mini-program platform
  • Alipay Mini Programs (alipay) - Alipay's mini-program platform
  • ByteDance Mini Programs (tt) - ByteDance (TikTok) mini-program platform
  • JD Mini Programs (jd) - JD.com's mini-program platform
  • QQ Mini Programs (qq) - Tencent QQ's mini-program platform
  • QuickApp (quickapp) - Industry standard for lightweight apps

Each platform has specific build optimizations, API adaptations, and directory structure requirements that are automatically handled during the build process.

Error Handling

The build function handles various error scenarios:

  • Configuration Errors: Invalid or missing build configuration parameters
  • Webpack Compilation Errors: Source code compilation failures, missing dependencies
  • File System Errors: Missing source files, permission issues, disk space problems
  • Platform-Specific Errors: Platform API limitations, size restrictions, feature compatibility

Errors are propagated as rejected promises with detailed error messages and stack traces for debugging.