@umijs/mfsu 4.0.2 → 4.0.5

package/dist/mfsu/strategyCompileTime.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyCompileTime = void 0;
+const utils_1 = require("@umijs/utils");
+const awaitImport_1 = __importDefault(require("../babelPlugins/awaitImport/awaitImport"));
+const getRealPath_1 = require("../babelPlugins/awaitImport/getRealPath");
+const dep_1 = require("../dep/dep");
+const depInfo_1 = require("../depInfo");
+class StrategyCompileTime {
+    constructor({ mfsu }) {
+        this.mfsu = mfsu;
+        this.depInfo = new depInfo_1.DepInfo({ mfsu });
+    }
+    getDepModules() {
+        return this.depInfo.getDepModules();
+    }
+    getCacheFilePath() {
+        return this.depInfo.getCacheFilePath();
+    }
+    init() { }
+    shouldBuild() {
+        return this.depInfo.shouldBuild();
+    }
+    loadCache() {
+        this.depInfo.loadCache();
+    }
+    writeCache() {
+        this.depInfo.writeCache();
+    }
+    refresh() {
+        this.depInfo.snapshot();
+    }
+    getBabelPlugin() {
+        return [awaitImport_1.default, this.getAwaitImportCollectOpts()];
+    }
+    getBuildDepPlugConfig() {
+        const mfsu = this.mfsu;
+        return {
+            onCompileDone: () => {
+                if (mfsu.depBuilder.isBuilding) {
+                    mfsu.buildDepsAgain = true;
+                }
+                else {
+                    mfsu
+                        .buildDeps()
+                        .then(() => {
+                        mfsu.onProgress({
+                            done: true,
+                        });
+                    })
+                        .catch((e) => {
+                        utils_1.logger.error(e);
+                        mfsu.onProgress({
+                            done: true,
+                        });
+                    });
+                }
+            },
+        };
+    }
+    getAwaitImportCollectOpts() {
+        const mfsuOpts = this.mfsu.opts;
+        const mfsu = this.mfsu;
+        return {
+            onTransformDeps: () => { },
+            onCollect: ({ file, data, }) => {
+                this.depInfo.moduleGraph.onFileChange({
+                    file,
+                    // @ts-ignore
+                    deps: [
+                        ...Array.from(data.matched).map((item) => ({
+                            file: item.sourceValue,
+                            isDependency: true,
+                            version: dep_1.Dep.getDepVersion({
+                                dep: item.sourceValue,
+                                cwd: mfsuOpts.cwd,
+                            }),
+                        })),
+                        ...Array.from(data.unMatched).map((item) => ({
+                            file: (0, getRealPath_1.getRealPath)({
+                                file,
+                                dep: item.sourceValue,
+                            }),
+                            isDependency: false,
+                        })),
+                    ],
+                });
+            },
+            exportAllMembers: mfsuOpts.exportAllMembers,
+            unMatchLibs: mfsuOpts.unMatchLibs,
+            remoteName: mfsuOpts.mfName,
+            alias: mfsu.alias,
+            externals: mfsu.externals,
+        };
+    }
+}
+exports.StrategyCompileTime = StrategyCompileTime;

package/dist/mfsu/strategyStaticAnalyze.d.ts

@@ -0,0 +1,23 @@
+import { IBuildDepPluginOpts } from '../webpackPlugins/buildDepPlugin';
+import type { IMFSUStrategy, MFSU } from './mfsu';
+export declare class StaticAnalyzeStrategy implements IMFSUStrategy {
+    private readonly mfsu;
+    private staticDepInfo;
+    constructor({ mfsu, srcCodeCache }: {
+        mfsu: MFSU;
+        srcCodeCache: any;
+    });
+    init(): void;
+    getDepModules(): Record<string, {
+        file: string;
+        version: string;
+    }>;
+    getCacheFilePath(): string;
+    shouldBuild(): false | "dependencies changed";
+    writeCache(): void;
+    getBabelPlugin(): any[];
+    private getMfImportOpts;
+    getBuildDepPlugConfig(): IBuildDepPluginOpts;
+    loadCache(): void;
+    refresh(): void;
+}

package/dist/mfsu/strategyStaticAnalyze.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticAnalyzeStrategy = void 0;
+const utils_1 = require("@umijs/utils");
+const getAliasedPath_1 = require("../babelPlugins/awaitImport/getAliasedPath");
+const MFImport_1 = __importDefault(require("../babelPlugins/awaitImport/MFImport"));
+const staticDepInfo_1 = require("../staticDepInfo/staticDepInfo");
+class StaticAnalyzeStrategy {
+    constructor({ mfsu, srcCodeCache }) {
+        this.mfsu = mfsu;
+        this.staticDepInfo = new staticDepInfo_1.StaticDepInfo({
+            mfsu,
+            srcCodeCache,
+        });
+    }
+    init() {
+        this.staticDepInfo.init();
+    }
+    getDepModules() {
+        return this.staticDepInfo.getDepModules();
+    }
+    getCacheFilePath() {
+        return this.staticDepInfo.getCacheFilePath();
+    }
+    shouldBuild() {
+        return this.staticDepInfo.shouldBuild();
+    }
+    writeCache() {
+        this.staticDepInfo.writeCache();
+    }
+    getBabelPlugin() {
+        return [MFImport_1.default, this.getMfImportOpts()];
+    }
+    getMfImportOpts() {
+        const mfsu = this.mfsu;
+        const mfsuOpts = this.mfsu.opts;
+        return {
+            resolveImportSource: (source) => {
+                const depMat = this.staticDepInfo.getDependencies();
+                const r = (0, getAliasedPath_1.getAliasedPathWithLoopDetect)({
+                    value: source,
+                    alias: mfsu.alias,
+                });
+                const m = depMat[r];
+                if (m) {
+                    return m.replaceValue;
+                }
+                return r;
+            },
+            exportAllMembers: mfsuOpts.exportAllMembers,
+            unMatchLibs: mfsuOpts.unMatchLibs,
+            remoteName: mfsuOpts.mfName,
+            alias: mfsu.alias,
+            externals: mfsu.externals,
+        };
+    }
+    getBuildDepPlugConfig() {
+        const mfsu = this.mfsu;
+        return {
+            beforeCompile: async () => {
+                utils_1.logger.event(`[MFSU][eager] start build deps`);
+                if (mfsu.depBuilder.isBuilding) {
+                    mfsu.buildDepsAgain = true;
+                }
+                else {
+                    this.staticDepInfo.consumeAllProducedEvents();
+                    mfsu
+                        .buildDeps()
+                        .then(() => {
+                        mfsu.onProgress({
+                            done: true,
+                        });
+                    })
+                        .catch((e) => {
+                        utils_1.logger.error(e);
+                        mfsu.onProgress({
+                            done: true,
+                        });
+                    });
+                }
+            },
+            onFileChange: async (c) => {
+                utils_1.logger.debug('webpack found changes modified:', c.modifiedFiles, 'removed:', c.removedFiles);
+                // webpack init run
+                if (!c.modifiedFiles || c.modifiedFiles.size === 0) {
+                    return;
+                }
+                const start = Date.now();
+                let event = this.staticDepInfo.getProducedEvent();
+                while (event.length === 0) {
+                    await sleep(200);
+                    console.log('.');
+                    event = this.staticDepInfo.getProducedEvent();
+                    if (Date.now() - start > 5000) {
+                        utils_1.logger.warn('webpack wait mfsu deps too long');
+                        break;
+                    }
+                }
+            },
+            onCompileDone: () => {
+                // fixme if mf module finished earlier than src compile
+            },
+        };
+    }
+    loadCache() {
+        this.staticDepInfo.loadCache();
+    }
+    refresh() {
+        this.staticDepInfo.snapshot();
+    }
+}
+exports.StaticAnalyzeStrategy = StaticAnalyzeStrategy;
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, ms);
+    });
+}

package/dist/moduleGraph.d.ts

@@ -1,3 +1,4 @@
+import type { DepModule } from './depInfo';
 declare class ModuleNode {
     file: string;
     importers: Set<ModuleNode>;
@@ -15,10 +16,7 @@ interface IDep {
 export declare class ModuleGraph {
     fileToModules: Map<string, ModuleNode>;
     depToModules: Map<string, ModuleNode>;
-    depSnapshotModules: Record<string, {
-        file: string;
-        version: string;
-    }>;
+    depSnapshotModules: Record<string, DepModule>;
     rootModules: Set<ModuleNode>;
     constructor();
     restore(data: {
@@ -36,10 +34,7 @@ export declare class ModuleGraph {
         depModules: Record<string, {
             version: string | null;
         }>;
-        depSnapshotModules: Record<string, {
-            file: string;
-            version: string;
-        }>;
+        depSnapshotModules: Record<string, DepModule>;
     };
     snapshotDeps(): void;
     getDepsInfo(mods: Map<string, ModuleNode>): Record<string, {

package/dist/staticDepInfo/importParser.d.ts

@@ -0,0 +1,4 @@
+export default function parse(code: string): {
+    from: string;
+    imports: string[];
+}[];

package/dist/staticDepInfo/importParser.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const _importParser_js_1 = require("../../vendors/importParser/_importParser.js");
+function parse(code) {
+    return (0, _importParser_js_1.parse)(code);
+}
+exports.default = parse;

package/dist/staticDepInfo/simulations/babel-plugin-import.d.ts

@@ -0,0 +1,15 @@
+import type { ImportSpecifier } from '@umijs/bundler-utils/compiled/es-module-lexer';
+import type { Match } from '../staticDepInfo';
+export default function createHandle(importOptions: {
+    libraryName: string;
+    libraryDirectory: string;
+    style: boolean | string;
+    camel2UnderlineComponentName?: boolean;
+    camel2DashComponentName?: boolean;
+}): (opts: {
+    rawCode: string;
+    imports: ImportSpecifier[];
+    mfName: string;
+    alias: Record<string, string>;
+    pathToVersion(p: string): string;
+}) => Match[];

package/dist/staticDepInfo/simulations/babel-plugin-import.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@umijs/utils");
+const path_1 = require("path");
+const getAliasedPath_1 = require("../../babelPlugins/awaitImport/getAliasedPath");
+const importParser_1 = __importDefault(require("../importParser"));
+function createHandle(importOptions) {
+    var _a;
+    const { libraryName, libraryDirectory } = importOptions;
+    const useUnderline = importOptions.camel2UnderlineComponentName;
+    const useDash = (_a = importOptions.camel2DashComponentName) !== null && _a !== void 0 ? _a : true;
+    const transformName = useUnderline
+        ? (n) => transCamel(n, '_')
+        : useDash
+            ? (n) => transCamel(n, '-')
+            : (n) => n;
+    /*
+      todo support other config values
+       [x] boolean true
+       [x] string css
+       [ ] function
+     */
+    const stylePathFromCompPath = importOptions.style === 'css'
+        ? (compFsPath) => (0, utils_1.winPath)((0, path_1.join)(compFsPath, 'style/css'))
+        : (compFsPath) => (0, utils_1.winPath)((0, path_1.join)(compFsPath, 'style'));
+    return function handleImports(opts) {
+        const { imports, rawCode } = opts;
+        if ((imports === null || imports === void 0 ? void 0 : imports.length) > 0) {
+            const version = opts.pathToVersion(libraryName);
+            function addToMatches(moduleFsPath) {
+                const unAliasedModulePath = (0, getAliasedPath_1.getAliasedPathWithLoopDetect)({
+                    value: (0, utils_1.winPath)(moduleFsPath),
+                    alias: opts.alias,
+                });
+                retMatched.push({
+                    isMatch: true,
+                    value: unAliasedModulePath,
+                    replaceValue: `${mfName}/${unAliasedModulePath}`,
+                    version,
+                });
+                const unAliasedStylePath = (0, getAliasedPath_1.getAliasedPathWithLoopDetect)({
+                    value: stylePathFromCompPath(moduleFsPath),
+                    alias: opts.alias,
+                });
+                retMatched.push({
+                    isMatch: true,
+                    value: unAliasedStylePath,
+                    replaceValue: `${mfName}/${unAliasedStylePath}`,
+                    version,
+                });
+            }
+            const importSnippets = imports
+                .map(({ ss, se }) => {
+                return rawCode.slice(ss, se + 1);
+            })
+                .join('\n');
+            const retMatched = [];
+            const parsedImports = (0, importParser_1.default)(importSnippets);
+            const importedVariable = new Set();
+            for (const i of parsedImports) {
+                i.imports.forEach((v) => {
+                    if (v === '*') {
+                        errorLogForSpaceImport(libraryName);
+                    }
+                    importedVariable.add(v);
+                });
+            }
+            const mfName = opts.mfName;
+            for (const v of importedVariable.entries()) {
+                const importVariableName = v[0];
+                if (importVariableName === 'default') {
+                    addToMatches((0, path_1.join)(libraryName, libraryDirectory));
+                    continue;
+                }
+                const transformedName = transformName(importVariableName);
+                const importFsPath = (0, path_1.join)(libraryName, libraryDirectory, transformedName);
+                addToMatches(importFsPath);
+            }
+            return retMatched;
+        }
+        return [];
+    };
+}
+exports.default = createHandle;
+function transCamel(_str, symbol) {
+    const str = _str[0].toLowerCase() + _str.substr(1);
+    return str.replace(/([A-Z])/g, ($1) => `${symbol}${$1.toLowerCase()}`);
+}
+function errorLogForSpaceImport(libraryName) {
+    utils_1.logger.error(`"import * as ant from 'antd'" or "export * from '${libraryName}'" are not allowed in mfsu#version=v4`);
+    utils_1.logger.error(`solutions:`);
+    utils_1.logger.error(`  change to "import { Xxx } from '${libraryName}'" or`);
+    utils_1.logger.error(`            "export { Xxx } from '${libraryName}'" syntax`);
+    utils_1.logger.error(`  or use mfsu#version=v3 configuration`);
+    throw Error(`"import * as ant from 'antd'" not allowed in mfsu#version=4`);
+}

package/dist/staticDepInfo/staticDepInfo.d.ts

@@ -0,0 +1,56 @@
+import { ImportSpecifier } from '@umijs/bundler-utils/compiled/es-module-lexer';
+import { checkMatch } from '../babelPlugins/awaitImport/checkMatch';
+import { MFSU } from '../mfsu/mfsu';
+declare type FileChangeEvent = {
+    event: 'unlink' | 'change' | 'add';
+    path: string;
+};
+declare type MergedCodeInfo = {
+    imports: readonly ImportSpecifier[];
+    code: string;
+    events: FileChangeEvent[];
+};
+declare type AutoUpdateSrcCodeCache = {
+    register(listener: (info: MergedCodeInfo) => void): void;
+    getMergedCode(): MergedCodeInfo;
+};
+interface IOpts {
+    mfsu: MFSU;
+    srcCodeCache: AutoUpdateSrcCodeCache;
+    safeList?: string[];
+}
+export declare type Match = ReturnType<typeof checkMatch> & {
+    version: string;
+};
+export declare class StaticDepInfo {
+    private opts;
+    private readonly cacheFilePath;
+    private mfsu;
+    private readonly include;
+    private currentDep;
+    private builtWithDep;
+    private produced;
+    private readonly cwd;
+    private readonly runtimeSimulations;
+    constructor(opts: IOpts);
+    getProducedEvent(): {
+        changes: unknown[];
+    }[];
+    consumeAllProducedEvents(): void;
+    shouldBuild(): false | "dependencies changed";
+    getDepModules(): Record<string, {
+        file: string;
+        version: string;
+    }>;
+    snapshot(): void;
+    loadCache(): void;
+    writeCache(): void;
+    getCacheFilePath(): string;
+    getDependencies(): Record<string, Match>;
+    init(): void;
+    private _getDependencies;
+    private simulateRuntimeTransform;
+    private appendIncludeList;
+    allRuntimeHelpers(): Promise<void>;
+}
+export {};

package/dist/staticDepInfo/staticDepInfo.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticDepInfo = void 0;
+const utils_1 = require("@umijs/utils");
+const fs_1 = require("fs");
+// @ts-ignore
+const why_1 = __importDefault(require("is-equal/why"));
+const path_1 = require("path");
+const checkMatch_1 = require("../babelPlugins/awaitImport/checkMatch");
+const dep_1 = require("../dep/dep");
+const babel_plugin_import_1 = __importDefault(require("./simulations/babel-plugin-import"));
+class StaticDepInfo {
+    constructor(opts) {
+        this.currentDep = {};
+        this.builtWithDep = {};
+        this.produced = [];
+        this.mfsu = opts.mfsu;
+        this.include = this.mfsu.opts.include || [];
+        this.opts = opts;
+        this.cacheFilePath = (0, path_1.join)(this.opts.mfsu.opts.tmpBase, 'MFSU_CACHE_v4.json');
+        this.cwd = this.mfsu.opts.cwd;
+        opts.srcCodeCache.register((info) => {
+            this.produced.push({ changes: info.events });
+            this.currentDep = this._getDependencies(info.code, info.imports);
+        });
+        this.runtimeSimulations = [
+            {
+                packageName: 'antd',
+                handleImports: (0, babel_plugin_import_1.default)({
+                    libraryName: 'antd',
+                    style: true,
+                    libraryDirectory: 'es',
+                }),
+            },
+        ];
+    }
+    getProducedEvent() {
+        return this.produced;
+    }
+    consumeAllProducedEvents() {
+        this.produced = [];
+    }
+    shouldBuild() {
+        if (utils_1.lodash.isEqual(this.builtWithDep, this.currentDep)) {
+            return false;
+        }
+        else {
+            if (process.env.DEBUG_UMI) {
+                const reason = (0, why_1.default)(this.builtWithDep, this.currentDep);
+                utils_1.logger.info('[MFSU][eager]: isEqual(oldDep,newDep) === false, because ', reason);
+            }
+            return 'dependencies changed';
+        }
+    }
+    getDepModules() {
+        const map = this.getDependencies();
+        const staticDeps = {};
+        const keys = Object.keys(map);
+        for (const k of keys) {
+            staticDeps[k] = {
+                file: k,
+                version: map[k].version,
+            };
+        }
+        return staticDeps;
+    }
+    snapshot() {
+        this.builtWithDep = this.currentDep;
+    }
+    loadCache() {
+        if ((0, fs_1.existsSync)(this.cacheFilePath)) {
+            this.builtWithDep = JSON.parse((0, fs_1.readFileSync)(this.cacheFilePath, 'utf-8'));
+            utils_1.logger.info('[MFSU][eager] restored cache');
+        }
+    }
+    writeCache() {
+        utils_1.fsExtra.mkdirpSync((0, path_1.dirname)(this.cacheFilePath));
+        const newContent = JSON.stringify(this.builtWithDep, null, 2);
+        if ((0, fs_1.existsSync)(this.cacheFilePath) &&
+            (0, fs_1.readFileSync)(this.cacheFilePath, 'utf-8') === newContent) {
+            return;
+        }
+        utils_1.logger.info('[MFSU][eager] write cache');
+        (0, fs_1.writeFileSync)(this.cacheFilePath, newContent, 'utf-8');
+    }
+    getCacheFilePath() {
+        return this.cacheFilePath;
+    }
+    getDependencies() {
+        return this.currentDep;
+    }
+    init() {
+        const merged = this.opts.srcCodeCache.getMergedCode();
+        this.currentDep = this._getDependencies(merged.code, merged.imports);
+    }
+    _getDependencies(bigCodeString, imports) {
+        const start = Date.now();
+        const cwd = this.mfsu.opts.cwd;
+        const opts = {
+            exportAllMembers: this.mfsu.opts.exportAllMembers,
+            unMatchLibs: this.mfsu.opts.unMatchLibs,
+            remoteName: this.mfsu.opts.mfName,
+            alias: this.mfsu.alias,
+            externals: this.mfsu.externals,
+        };
+        const matched = {};
+        const unMatched = new Set();
+        const pkgNames = this.runtimeSimulations.map(({ packageName }) => packageName);
+        const groupedMockImports = {};
+        for (const imp of imports) {
+            if (pkgNames.indexOf(imp.n) >= 0) {
+                const name = imp.n;
+                if (groupedMockImports[name]) {
+                    groupedMockImports[name].push(imp);
+                }
+                else {
+                    groupedMockImports[name] = [imp];
+                }
+                continue;
+            }
+            if (unMatched.has(imp.n)) {
+                continue;
+            }
+            if (matched[imp.n]) {
+                continue;
+            }
+            const match = (0, checkMatch_1.checkMatch)({
+                value: imp.n,
+                depth: 1,
+                filename: '_.js',
+                opts,
+            });
+            if (match.isMatch) {
+                matched[match.value] = {
+                    ...match,
+                    version: dep_1.Dep.getDepVersion({
+                        dep: match.value,
+                        cwd,
+                    }),
+                };
+            }
+            else {
+                unMatched.add(imp.n);
+            }
+        }
+        this.simulateRuntimeTransform(matched, groupedMockImports, bigCodeString);
+        this.appendIncludeList(matched, opts);
+        utils_1.logger.debug('[MFSU][eager] _getDependencies costs', Date.now() - start);
+        return matched;
+    }
+    simulateRuntimeTransform(matched, groupedImports, rawCode) {
+        for (const mock of this.runtimeSimulations) {
+            const name = mock.packageName;
+            const pathToVersion = (dep) => {
+                return dep_1.Dep.getDepVersion({
+                    dep,
+                    cwd: this.cwd,
+                });
+            };
+            const ms = mock.handleImports({
+                imports: groupedImports[name],
+                rawCode,
+                alias: this.mfsu.alias,
+                mfName: this.mfsu.opts.mfName,
+                pathToVersion,
+            });
+            for (const m of ms) {
+                matched[m.value] = m;
+            }
+        }
+    }
+    appendIncludeList(matched, opts) {
+        for (const p of this.include) {
+            const match = (0, checkMatch_1.checkMatch)({
+                value: p,
+                depth: 1,
+                filename: '_.js',
+                opts,
+            });
+            if (match.isMatch) {
+                matched[match.value] = {
+                    ...match,
+                    version: dep_1.Dep.getDepVersion({
+                        dep: match.value,
+                        cwd: this.cwd,
+                    }),
+                };
+            }
+        }
+    }
+    async allRuntimeHelpers() {
+        // todo mfsu4
+    }
+}
+exports.StaticDepInfo = StaticDepInfo;

package/dist/webpackPlugins/buildDepPlugin.d.ts

@@ -1,10 +1,11 @@
 import type { Compiler } from 'webpack';
-interface IOpts {
+export interface IBuildDepPluginOpts {
     onCompileDone: Function;
+    onFileChange?: (c: Compiler) => Promise<any>;
+    beforeCompile?: () => Promise<any>;
 }
 export declare class BuildDepPlugin {
     private opts;
-    constructor(opts: IOpts);
+    constructor(opts: IBuildDepPluginOpts);
     apply(compiler: Compiler): void;
 }
-export {};

package/dist/webpackPlugins/buildDepPlugin.js

@@ -7,6 +7,14 @@ class BuildDepPlugin {
         this.opts = opts;
     }
     apply(compiler) {
+        compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, (c) => {
+            var _a, _b;
+            return ((_b = (_a = this.opts).onFileChange) === null || _b === void 0 ? void 0 : _b.call(_a, c)) || Promise.resolve();
+        });
+        compiler.hooks.beforeCompile.tap(PLUGIN_NAME, () => {
+            var _a, _b;
+            (_b = (_a = this.opts).beforeCompile) === null || _b === void 0 ? void 0 : _b.call(_a);
+        });
         compiler.hooks.done.tap(PLUGIN_NAME, (stats) => {
             if (!stats.hasErrors()) {
                 this.opts.onCompileDone();