xhs-mp-pack 1.1.0-beta.0

package/dist/MPPack.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { Project } from 'xhs-mp-project';
+import MPPackSetting from '@/MPPackSetting';
+import { EventEmitter } from 'events';
+import { ICompileOptions } from './types';
+import Watching from './Watching';
+export declare abstract class AbstractMPPack extends EventEmitter {
+    abstract hooks: any;
+    abstract watch(config: any, callback?: any): any;
+    abstract changeCompileOptions(config: any): any;
+    abstract activatePkgs(compilePkgs: any): any;
+    abstract reCompilePkgs(config: any): any;
+    abstract build(callback?: any): any;
+    abstract close(callback: any): any;
+}
+export declare class MPPack extends AbstractMPPack {
+    callbacks: any[];
+    project: Project;
+    compiler: any;
+    watcher: Watching | null;
+    packSetting: MPPackSetting;
+    constructor(options: ICompileOptions);
+    createCompiler(compilerConfigs: any): void;
+    private doCreateCompiler;
+    handleProgress: (progress: any) => void;
+    get hooks(): any;
+    watch(config: any, callback?: any): Promise<unknown>;
+    changeCompileOptions(config: any): void;
+    activatePkgs(compilePkgs: any): Promise<unknown>;
+    reCompilePkgs(config: any): Promise<unknown>;
+    build(callback?: any): void;
+    close(callback: any): void;
+}

package/dist/MPPack.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MPPack = exports.AbstractMPPack = void 0;
+const xhs_mp_project_1 = require("xhs-mp-project");
+const ProgressPlugin_1 = __importDefault(require("@/plugins/ProgressPlugin"));
+const MPPackSetting_1 = __importDefault(require("@/MPPackSetting"));
+const events_1 = require("events");
+const Compiler_1 = __importDefault(require("@/Compiler"));
+const MultiCompiler_1 = __importDefault(require("@/MultiCompiler"));
+const PluginManager_1 = __importDefault(require("@/PluginManager"));
+const defaults_1 = require("@/base/defaults");
+const const_1 = __importDefault(require("@/base/const"));
+const CachedInputFileSystem_1 = __importDefault(require("enhanced-resolve/lib/CachedInputFileSystem"));
+const graceful_fs_1 = __importDefault(require("graceful-fs"));
+const createConsoleLogger_1 = __importDefault(require("@/base/logging/createConsoleLogger"));
+const nodeConsole_1 = __importDefault(require("@/base/logging/nodeConsole"));
+const NodeWatchFileSystem_1 = __importDefault(require("@/base/NodeWatchFileSystem"));
+const normalization_1 = require("./base/normalization");
+const watchOptions = {
+    aggregateTimeout: 300,
+    poll: false,
+    ignored: ['**/node_modules', 'project.config.json', 'project.private.config.json'],
+};
+const { BUILD_REASON } = const_1.default;
+class AbstractMPPack extends events_1.EventEmitter {
+}
+exports.AbstractMPPack = AbstractMPPack;
+class MPPack extends AbstractMPPack {
+    constructor(options) {
+        super();
+        this.callbacks = [];
+        this.compiler = null;
+        this.watcher = null;
+        this.doCreateCompiler = options => {
+            const compiler = new Compiler_1.default(this.project, this.packSetting, options);
+            const { infrastructureLogging } = options;
+            compiler.infrastructureLogger = (0, createConsoleLogger_1.default)({
+                level: infrastructureLogging.level || 'info',
+                debug: infrastructureLogging.debug || false,
+                console: infrastructureLogging.console ||
+                    (0, nodeConsole_1.default)({
+                        colors: infrastructureLogging.colors,
+                        appendOnly: infrastructureLogging.appendOnly,
+                        stream: infrastructureLogging.stream,
+                    }),
+            });
+            compiler.inputFileSystem = new CachedInputFileSystem_1.default(graceful_fs_1.default, 60000);
+            const inputFileSystem = compiler.inputFileSystem;
+            compiler.outputFileSystem = graceful_fs_1.default;
+            compiler.intermediateFileSystem = graceful_fs_1.default;
+            compiler.watchFileSystem = new NodeWatchFileSystem_1.default(compiler.inputFileSystem);
+            compiler.hooks.beforeRun.tap('NodeEnvironmentPlugin', compiler => {
+                if (compiler.inputFileSystem === inputFileSystem) {
+                    compiler.fsStartTime = Date.now();
+                    inputFileSystem.purge();
+                }
+            });
+            if (Array.isArray(options.plugins)) {
+                for (const plugin of options.plugins) {
+                    if (typeof plugin === 'function') {
+                        plugin.call(compiler, compiler);
+                    }
+                    else if (plugin) {
+                        plugin.apply(compiler);
+                    }
+                }
+            }
+            (0, defaults_1.applyWebpackOptionsDefaults)(options);
+            compiler.hooks.environment.call();
+            compiler.hooks.afterEnvironment.call();
+            new PluginManager_1.default().setup(options, compiler);
+            return compiler;
+        };
+        this.handleProgress = progress => {
+            this.emit('progress', progress);
+        };
+        const { projectPath, project, platform } = options;
+        process.env.__platform = platform;
+        this.project = project || new xhs_mp_project_1.Project({
+            projectPath: projectPath,
+        });
+        this.packSetting = new MPPackSetting_1.default(this.project, options);
+    }
+    createCompiler(compilerConfigs) {
+        compilerConfigs = compilerConfigs.map(rawOption => {
+            const options = (0, normalization_1.getNormalizedWebpackOptions)(rawOption);
+            (0, defaults_1.applyWebpackOptionsBaseDefaults)(options);
+            return options;
+        });
+        const compilers = compilerConfigs.map(options => this.doCreateCompiler(options));
+        const compiler = new MultiCompiler_1.default(compilers, {});
+        for (const childCompiler of compilers) {
+            if (childCompiler.options.dependencies) {
+                compiler.setDependencies(childCompiler, childCompiler.options.dependencies);
+            }
+        }
+        this.compiler = compiler;
+        new ProgressPlugin_1.default(this.handleProgress).apply(this.compiler);
+    }
+    get hooks() {
+        return this.compiler.hooks;
+    }
+    watch(config, callback) {
+        return new Promise(resolve => {
+            if (this.watcher) {
+                this.watcher.close(() => { });
+                this.watcher = null;
+            }
+            this.watcher = this.compiler.watch(Object.assign(Object.assign({}, watchOptions), config), (err, stats) => {
+                var _a, _b;
+                const buildReason = (_b = (_a = stats === null || stats === void 0 ? void 0 : stats.stats) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.buildReason;
+                console.log('buildReason', buildReason);
+                if (this.callbacks.length) {
+                    this.callbacks.forEach(callback => callback({ err, stats }));
+                    this.callbacks = [];
+                }
+                if (buildReason === BUILD_REASON.FILE_CHANGE) {
+                    callback === null || callback === void 0 ? void 0 : callback(err, stats);
+                }
+            });
+            this.callbacks.push(resolve);
+        });
+    }
+    changeCompileOptions(config) {
+        if (!this.watcher) {
+            return;
+        }
+        this.packSetting.changeSetting(config);
+    }
+    activatePkgs(compilePkgs) {
+        return new Promise(resolve => {
+            if (!this.watcher) {
+                return;
+            }
+            this.packSetting.activatePkgs(compilePkgs);
+            this.watcher.invalidateWithReason(BUILD_REASON.ACTIVATE_PKG, () => { });
+            this.callbacks.push(resolve);
+        });
+    }
+    reCompilePkgs(config) {
+        return new Promise(resolve => {
+            var _a;
+            if (!this.watcher) {
+                return;
+            }
+            if (config) {
+                this.changeCompileOptions(config);
+            }
+            (_a = this.watcher) === null || _a === void 0 ? void 0 : _a.invalidateWithReason(BUILD_REASON.RECOMPILE, () => { });
+            this.callbacks.push(resolve);
+        });
+    }
+    build(callback) {
+        this.compiler.run(callback);
+    }
+    close(callback) {
+        this.compiler.close(callback);
+    }
+}
+exports.MPPack = MPPack;

package/dist/MPPackSetting.d.ts

@@ -0,0 +1,52 @@
+import { ENV, ICompileOptions } from './types';
+import { Project } from 'xhs-mp-project';
+declare class MPPackSetting {
+    private project;
+    private options;
+    distDir: string;
+    env: ENV;
+    tsConfigPath?: string;
+    cacheDirectory?: string;
+    action: string;
+    watch?: boolean;
+    compressJs: boolean;
+    enableVDom: boolean;
+    enableV2: boolean;
+    enableV1: boolean;
+    compilePkgs: string[];
+    enableSourcemap: boolean;
+    compileType: string;
+    devServerPort: any;
+    constructor(project: Project, options: ICompileOptions);
+    get usingPackageType(): "v2" | "v1";
+    serialize(): {
+        distDir: string;
+        env: ENV;
+        tsConfigPath: string | undefined;
+        cacheDirectory: string | undefined;
+        project?: Project | undefined;
+        projectPath?: string | undefined;
+        platform?: "wx" | "xhs" | undefined;
+        clearDistDir?: boolean | undefined;
+        compressJs?: boolean | undefined;
+        enableVDom?: boolean | undefined;
+        enableV2?: boolean | undefined;
+        enableV1?: boolean | undefined;
+        action: "build" | "dev";
+        watch?: boolean | undefined;
+        enableSourcemap?: boolean | undefined;
+        compilePkgs?: string[] | undefined;
+        compileType?: string | undefined;
+        devServerPort?: number | undefined;
+        callback?: (() => void) | undefined;
+    };
+    static deSerialize(project: any, options: any): MPPackSetting;
+    changeSetting(options?: {}): void;
+    activatePkgs(compilePkgs?: never[]): void;
+    getCompilePkgs(): string[];
+    getCompilePkgsForEntries(): {
+        mainPkg: boolean;
+        subPkgs: any;
+    };
+}
+export default MPPackSetting;

package/dist/MPPackSetting.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const common_1 = require("@/base/common");
+const utils_1 = require("@/base/utils");
+const types_1 = require("./types");
+class MPPackSetting {
+    constructor(project, options) {
+        this.compilePkgs = [];
+        const { action, watch, tsConfigPath, compressJs = true, enableVDom = false, enableV2 = false, enableV1 = true, enableSourcemap = true, compilePkgs = [], compileType = '', clearDistDir = true, devServerPort } = options;
+        this.project = project;
+        this.options = options;
+        this.distDir = (0, utils_1.formatPath)(options.distDir || path_1.default.join(process.cwd(), 'dist'));
+        this.env = action === 'dev' ? types_1.ENV.development : types_1.ENV.production;
+        this.action = action;
+        this.watch = watch;
+        this.tsConfigPath = (0, utils_1.formatPath)(tsConfigPath || (0, common_1.getTsConfigPath)(project.projectPath));
+        this.cacheDirectory = (0, utils_1.formatPath)(options.cacheDirectory);
+        this.enableVDom = enableVDom;
+        this.enableV2 = enableV2;
+        this.enableV1 = enableV1;
+        if (this.action === 'build') {
+            this.enableV1 = true;
+        }
+        if (!enableV1 && !enableV2) {
+            this.enableV1 = true;
+            this.enableV2 = false;
+        }
+        this.compressJs = compressJs;
+        this.enableSourcemap = enableSourcemap;
+        this.compilePkgs = compilePkgs;
+        this.compileType = compileType;
+        this.devServerPort = devServerPort;
+        if (clearDistDir) {
+            try {
+                if (fs_extra_1.default.existsSync(this.distDir)) {
+                    // eslint-disable-line
+                    fs_extra_1.default.rmSync(this.distDir, { recursive: true });
+                }
+            }
+            catch (error) {
+                // noop
+            }
+        }
+    }
+    get usingPackageType() {
+        return this.enableV2 ? 'v2' : 'v1';
+    }
+    serialize() {
+        return Object.assign(Object.assign({}, this.options), { distDir: this.distDir, env: this.env, tsConfigPath: this.tsConfigPath, cacheDirectory: this.cacheDirectory });
+    }
+    static deSerialize(project, options) {
+        return new MPPackSetting(project, options);
+    }
+    changeSetting(options = {}) {
+        for (const key in options) {
+            this[key] = options[key];
+        }
+        this.options = Object.assign(Object.assign({}, this.options), options);
+    }
+    activatePkgs(compilePkgs = []) {
+        compilePkgs.forEach(pkg => {
+            if (!this.compilePkgs.includes(pkg)) {
+                this.compilePkgs.push(pkg);
+            }
+        });
+    }
+    getCompilePkgs() {
+        return this.compilePkgs || [];
+    }
+    // 全量入口编译，但实际各个module走lazy-compile
+    // 这样所有文件才会被watch
+    getCompilePkgsForEntries() {
+        const subpackages = this.project.getSubPackages();
+        return {
+            mainPkg: true,
+            subPkgs: subpackages
+        };
+    }
+}
+exports.default = MPPackSetting;

package/dist/MultiCompiler.d.ts

@@ -0,0 +1,25 @@
+export default class MultiCompiler {
+    hooks: any;
+    compilers: any;
+    _options: {
+        parallelism: any;
+    };
+    dependencies: WeakMap<any, any>;
+    running: boolean;
+    constructor(compilers: any, options: any);
+    get options(): any;
+    get outputPath(): any;
+    set inputFileSystem(value: any);
+    set outputFileSystem(value: any);
+    set watchFileSystem(value: any);
+    set intermediateFileSystem(value: any);
+    getInfrastructureLogger(name: any): any;
+    setDependencies(compiler: any, dependencies: string[]): void;
+    validateDependencies(callback: any): boolean;
+    runWithDependencies(compilers: any, fn: any, callback: any): void;
+    _runGraph(setup: any, run: any, callback: any): any[];
+    watch(watchOptions: any, handler: any): any;
+    run(callback: any): any;
+    purgeInputFileSystem(): void;
+    close(callback: any): void;
+}