xhs-mp-compiler-cli 1.0.2-beta.0 → 1.0.2

package/dist/webpack-config/loaders/sjs-loader/scope.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeManager = exports.Scope = exports.SPECIFY_VAR = void 0;
+exports.SPECIFY_VAR = ["getDate", "getRegExp", "console"];
+const IDENTIFIER_WHITE_LIST = [
+    "Object", "Boolean", "Array", "String", "Number", "Date", "Map", "Set",
+    "decodeURI", "decodeURIComponent", "encodeURI", "encodeURIComponent", "isNaN", "isFinite", "parseFloat", "parseInt",
+    "Infinity", "NaN", "undefined",
+    "setTimeout", "clearTimeout", "setInterval", "clearInterval",
+    "JSON", "Math",
+    // 模块化
+    "module", "require", "exports",
+    ...exports.SPECIFY_VAR
+];
+// 变量作用域表
+class Scope {
+    constructor() {
+        // 当前作用域定义的变量
+        this.defines = {};
+        // 当前作用域使用的变量
+        this.access = {};
+    }
+    toString() {
+        return `defines: ${Object.keys(this.defines)} access: ${Object.keys(this.access)}`;
+    }
+    /**
+     * @returns
+     */
+    anlysis() {
+        // TODO 优化算法复杂度
+        // 在自身作用域 以及 上级作用域寻找，找到顶层作用域时 则需要看 白名单是否含有
+        for (const variable in this.access) {
+            // 白名单也不包含此变量
+            if (this.checkGlobal(variable) && !IDENTIFIER_WHITE_LIST.includes(variable)) {
+                return { variable, span: this.access[variable] };
+            }
+        }
+        return undefined;
+    }
+    // 检查是否是全局调用
+    checkGlobal(key) {
+        let scope = this;
+        while (scope) {
+            if (!scope.defines[key]) {
+                scope = scope.parentScope;
+                continue;
+            }
+            else {
+                return false;
+            }
+        }
+        return !scope;
+    }
+    setAccess(key, value) {
+        this.access[key] = value;
+    }
+    setDefines(key, value) {
+        this.defines[key] = value;
+    }
+    setParentScope(scope) {
+        this.parentScope = scope;
+    }
+}
+exports.Scope = Scope;
+class ScopeManager {
+    constructor() {
+        // 栈帧
+        this._scopeStack = [];
+        // 栈 深度遍历结果
+        this._scopeTables = [];
+        // 是否停止收集
+        this._stop = false;
+    }
+    // 停止分析
+    stop() {
+        this._stop = true;
+    }
+    enterScope() {
+        if (this._stop)
+            return;
+        this._scopeStack.push(new Scope());
+    }
+    exitScope() {
+        if (this._stop)
+            return;
+        const scope = this._scopeStack.pop();
+        if (scope) {
+            this._scopeTables.push(scope);
+            scope.setParentScope(this.getCurrentScope());
+        }
+    }
+    getCurrentScope() {
+        if (this._stop)
+            return;
+        return this._scopeStack[this._scopeStack.length - 1];
+    }
+    // 记录定义的值
+    pushIdentifier(id) {
+        var _a;
+        if (this._stop)
+            return;
+        if (this.getCurrentScope()) {
+            (_a = this.getCurrentScope()) === null || _a === void 0 ? void 0 : _a.setDefines(id.value, id.span);
+        }
+    }
+    // 记录使用的值
+    pushAccess(id) {
+        if (this._stop)
+            return;
+        const current = this.getCurrentScope();
+        if (current) {
+            current === null || current === void 0 ? void 0 : current.setAccess(id.value, id.span);
+            if (exports.SPECIFY_VAR.includes(id.value)) {
+                id._xhsScope = current;
+            }
+        }
+    }
+    getDFSScope() {
+        return this._scopeTables;
+    }
+}
+exports.ScopeManager = ScopeManager;

package/dist/webpack-config/loaders/sjs-loader/tranform.d.ts

@@ -0,0 +1,2 @@
+import type { JscTarget, Program } from '@swc/core';
+export declare const transform: (code: string, plugin?: ((m: Program) => Program) | undefined, target?: JscTarget, minify?: boolean) => import("@swc/core").Output;

package/dist/webpack-config/loaders/sjs-loader/tranform.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = void 0;
+const core_1 = require("@swc/core");
+const transform = (code, plugin, target = 'esnext', minify = false) => (0, core_1.transformSync)(code, {
+    swcrc: false,
+    configFile: false,
+    minify,
+    sourceMaps: false,
+    jsc: {
+        preserveAllComments: true,
+        target,
+        // minify: false,
+        externalHelpers: false,
+        parser: {
+            syntax: "ecmascript",
+            jsx: false,
+            dynamicImport: false,
+            privateMethod: false,
+            functionBind: false,
+            classPrivateProperty: false,
+            exportDefaultFrom: false,
+            exportNamespaceFrom: false,
+            decorators: false,
+            decoratorsBeforeExport: false,
+            importMeta: false,
+        },
+    },
+    plugin,
+});
+exports.transform = transform;

package/dist/webpack-config/loaders/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 根据是否分包获取资源路径
+ */
+export declare const getResourceUris: (options: {
+    appCssExist: boolean;
+    enableLazyCodeLoading: boolean;
+    subPackage: any;
+}) => string[];
+/**
+ * @NOTE
+ *  Create a request and handle the conversion of esModule modules
+ * */
+export declare function createRequire(modulePath: string): string;

package/dist/webpack-config/loaders/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequire = exports.getResourceUris = void 0;
+/**
+ * 根据是否分包获取资源路径
+ */
+const getResourceUris = (options) => {
+    const resourceList = [];
+    const { appCssExist, enableLazyCodeLoading, subPackage } = options;
+    // sjs 无法识别是否引用 所以一律push
+    // 加载顺序 app.css  主包sjs  分包sjs  主包components.js  分包components.js 
+    if (!subPackage) {
+        // 主包
+        appCssExist && resourceList.push(`app.css`);
+        resourceList.push('sjs.js');
+        !enableLazyCodeLoading && resourceList.push(`components.js`);
+    }
+    else if (subPackage === null || subPackage === void 0 ? void 0 : subPackage.independent) {
+        // 独立分包, 自己的components.js
+        resourceList.push(`${subPackage === null || subPackage === void 0 ? void 0 : subPackage.root}/sjs.js`);
+        !enableLazyCodeLoading && resourceList.push(`${subPackage === null || subPackage === void 0 ? void 0 : subPackage.root}/components.js`);
+    }
+    else if (subPackage) {
+        // 普通分包, 自己的components.js，主包components.js app.css
+        appCssExist && resourceList.push(`app.css`);
+        resourceList.push('sjs.js');
+        resourceList.push(`${subPackage === null || subPackage === void 0 ? void 0 : subPackage.root}/sjs.js`);
+        !enableLazyCodeLoading && resourceList.push(`components.js`);
+        !enableLazyCodeLoading && resourceList.push(`${subPackage === null || subPackage === void 0 ? void 0 : subPackage.root}/components.js`);
+    }
+    return resourceList;
+};
+exports.getResourceUris = getResourceUris;
+/**
+ * @NOTE
+ *  Create a request and handle the conversion of esModule modules
+ * */
+function createRequire(modulePath) {
+    return `function() { var obj = require('${modulePath}'); return obj && obj.__esModule ? obj.default : obj; }`;
+}
+exports.createRequire = createRequire;

package/dist/webpack-config/loaders/wxss-loader.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webpack-config/loaders/wxss-loader.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const postcss_1 = __importDefault(require("postcss"));
+const postcss_import_1 = __importDefault(require("postcss-import"));
+const postcss_prefix_selector_1 = __importDefault(require("postcss-prefix-selector"));
+const CssSyntaxError_1 = __importDefault(require("css-loader/dist/CssSyntaxError"));
+const tagTransformMap_1 = __importDefault(require("../lib/tagTransformMap"));
+const getCssSuffixName_1 = __importDefault(require("../../utils/getCssSuffixName"));
+const common_1 = require("../../utils/common");
+const tags = Object.keys(tagTransformMap_1.default).join('|');
+const labelStr = `(^|\\s)(${tags}|page|audio|live-player|map|cover-view|cover-image|video)`;
+const labelReg = new RegExp(labelStr, 'g');
+function wxssLoader(source) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e;
+        const done = this.async();
+        this._compiler.xhsData = this._compiler.xhsData || {};
+        const { appJSON = {}, miniprogramDir = '' } = this._compiler.xhsData;
+        const shortPath = (0, common_1.getShortPath)(miniprogramDir, this.resourcePath).replace(new RegExp(`\\.${(0, getCssSuffixName_1.default)()}$`), '');
+        const index = (_c = (_b = (_a = appJSON === null || appJSON === void 0 ? void 0 : appJSON.componentsMap) === null || _a === void 0 ? void 0 : _a[shortPath]) === null || _b === void 0 ? void 0 : _b.index) !== null && _c !== void 0 ? _c : null;
+        const styleIsolation = (_e = (_d = appJSON === null || appJSON === void 0 ? void 0 : appJSON.componentsMap) === null || _d === void 0 ? void 0 : _d[shortPath]) === null || _e === void 0 ? void 0 : _e.styleIsolation;
+        const selectorIndex = styleIsolation === 'shared' ? 0 : index || 0;
+        // js / json 的配置会影响样式
+        const extReg = new RegExp(`${(0, getCssSuffixName_1.default)()}$`);
+        this.addDependency(this.resourcePath.replace(extReg, 'js'));
+        this.addDependency(this.resourcePath.replace(extReg, 'json'));
+        (0, postcss_1.default)()
+            .use((0, postcss_import_1.default)({ root: miniprogramDir }))
+            .use((0, postcss_prefix_selector_1.default)({
+            prefix: 'xhs',
+            transform(prefix, selector) {
+                // 支持 host 选择器 https://developers.weixin.qq.com/miniprogram/dev/framework/custom-component/wxml-wxss.html
+                if (selector === ':host') {
+                    return `[is="${shortPath}"]`;
+                }
+                /**
+                 * 替换所有类选择器，用于做样式隔离 wiki: https://wiki.xiaohongshu.com/pages/viewpage.action?pageId=181017177
+                 * .app -> .xhs_0_app
+                 */
+                selector = selector.replace(/\.(\w)/g, `.xhs_${selectorIndex}_$1`);
+                // 为内置组件加上 xhs 前缀
+                if (selector.match(labelReg)) {
+                    selector = selector.replace(labelReg, `$1${prefix}-$2`);
+                }
+                return selector;
+            },
+        }))
+            .process(source, {
+            from: this.resourcePath,
+        })
+            .then(result => {
+            result.messages.forEach(({ file, type }) => {
+                if (type === 'dependency') {
+                    this.addDependency(file);
+                }
+            });
+            done(null, result.css);
+        })
+            .catch(error => {
+            done(error.name === 'CssSyntaxError' ? new CssSyntaxError_1.default(error) : error);
+        });
+    });
+}
+module.exports = wxssLoader;

package/dist/webpack-config/plugins/VueLoaderPlugin.d.ts

@@ -0,0 +1,19 @@
+import { TemplateCompiler, CompilerOptions, SFCTemplateCompileOptions, SFCScriptCompileOptions } from 'vue/compiler-sfc';
+import { Compiler, Plugin } from 'webpack';
+export interface VueLoaderOptions {
+    babelParserPlugins?: SFCScriptCompileOptions['babelParserPlugins'];
+    transformAssetUrls?: SFCTemplateCompileOptions['transformAssetUrls'];
+    compiler?: TemplateCompiler | string;
+    compilerOptions?: CompilerOptions;
+    refSugar?: boolean;
+    customElement?: boolean | RegExp;
+    hotReload?: boolean;
+    exposeFilename?: boolean;
+    appendExtension?: boolean;
+    isServerBuild?: boolean;
+}
+declare class VueLoaderPlugin implements Plugin {
+    static NS: string;
+    apply(compiler: Compiler): void;
+}
+export default VueLoaderPlugin;

package/dist/webpack-config/plugins/VueLoaderPlugin.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+// @ts-nocheck
+const querystring_1 = __importDefault(require("querystring"));
+const getMlSuffixName_1 = __importDefault(require("../../utils/getMlSuffixName"));
+const id = 'vue-loader-plugin';
+const NS = 'vue-loader';
+const NormalModule = require('webpack/lib/NormalModule');
+const BasicEffectRulePlugin = require('webpack/lib/rules/BasicEffectRulePlugin');
+const BasicMatcherRulePlugin = require('webpack/lib/rules/BasicMatcherRulePlugin');
+const UseEffectRulePlugin = require('webpack/lib/rules/UseEffectRulePlugin');
+const RuleSetCompiler = require('webpack/lib/rules/RuleSetCompiler');
+const ObjectMatcherRulePlugin = require('webpack/lib/rules/ObjectMatcherRulePlugin');
+const objectMatcherRulePlugins = [];
+objectMatcherRulePlugins.push(new ObjectMatcherRulePlugin('assert', 'assertions'), new ObjectMatcherRulePlugin('descriptionData'));
+const ruleSetCompiler = new RuleSetCompiler([
+    new BasicMatcherRulePlugin('test', 'resource'),
+    new BasicMatcherRulePlugin('mimetype'),
+    new BasicMatcherRulePlugin('dependency'),
+    new BasicMatcherRulePlugin('include', 'resource'),
+    new BasicMatcherRulePlugin('exclude', 'resource', true),
+    new BasicMatcherRulePlugin('conditions'),
+    new BasicMatcherRulePlugin('resource'),
+    new BasicMatcherRulePlugin('resourceQuery'),
+    new BasicMatcherRulePlugin('resourceFragment'),
+    new BasicMatcherRulePlugin('realResource'),
+    new BasicMatcherRulePlugin('issuer'),
+    new BasicMatcherRulePlugin('compiler'),
+    ...objectMatcherRulePlugins,
+    new BasicEffectRulePlugin('type'),
+    new BasicEffectRulePlugin('sideEffects'),
+    new BasicEffectRulePlugin('parser'),
+    new BasicEffectRulePlugin('resolve'),
+    new BasicEffectRulePlugin('generator'),
+    new UseEffectRulePlugin(),
+]);
+let uid = 0;
+const matcherCache = new WeakMap();
+function match(rule, fakeFile) {
+    let ruleSet = matcherCache.get(rule);
+    if (!ruleSet) {
+        // skip the `include` check when locating the vue rule
+        const clonedRawRule = Object.assign({}, rule);
+        delete clonedRawRule.include;
+        ruleSet = ruleSetCompiler.compile([clonedRawRule]);
+        matcherCache.set(rule, ruleSet);
+    }
+    return ruleSet.exec({
+        resource: fakeFile,
+    });
+}
+function cloneRule(rawRule, refs, ruleCheck, ruleResource) {
+    const compiledRule = ruleSetCompiler.compileRule(`clonedRuleSet-${++uid}`, rawRule, refs);
+    // do not process rule with enforce
+    if (!rawRule.enforce) {
+        const ruleUse = compiledRule.effects
+            .filter(effect => effect.type === 'use')
+            .map((effect) => effect.value);
+        // fix conflict with config.loader and config.options when using config.use
+        delete rawRule.loader;
+        delete rawRule.options;
+        rawRule.use = ruleUse;
+    }
+    let currentResource;
+    const res = Object.assign(Object.assign({}, rawRule), { resource: (resources) => {
+            currentResource = resources;
+            return true;
+        }, resourceQuery: (query) => {
+            if (!query) {
+                return false;
+            }
+            const parsed = querystring_1.default.parse(query.slice(1));
+            if (parsed.vue == null) {
+                return false;
+            }
+            if (!ruleCheck(parsed, compiledRule)) {
+                return false;
+            }
+            const fakeResourcePath = ruleResource(parsed, currentResource);
+            for (const condition of compiledRule.conditions) {
+                // add support for resourceQuery
+                const request = condition.property === 'resourceQuery' ? query : fakeResourcePath;
+                if (condition && !condition.fn(request)) {
+                    return false;
+                }
+            }
+            return true;
+        } });
+    delete res.test;
+    if (rawRule.rules) {
+        res.rules = rawRule.rules.map(rule => cloneRule(rule, refs, ruleCheck, ruleResource));
+    }
+    if (rawRule.oneOf) {
+        res.oneOf = rawRule.oneOf.map(rule => cloneRule(rule, refs, ruleCheck, ruleResource));
+    }
+    return res;
+}
+const langBlockRuleCheck = (query, rule) => query.type === 'custom' || !rule.conditions.length || query.lang != null;
+const jsRuleCheck = (query) => query.type === 'template';
+const jsRuleResource = (query, resource) => `${resource}.js`;
+const langBlockRuleResource = (query, resource) => `${resource}.${query.lang}`;
+class VueLoaderPlugin {
+    apply(compiler) {
+        // add NS marker so that the loader can detect and report missing plugin
+        compiler.hooks.compilation.tap(id, compilation => {
+            NormalModule.getCompilationHooks(compilation).loader.tap(id, (loaderContext) => {
+                loaderContext[NS] = true;
+            });
+        });
+        const rules = compiler.options.module.rules;
+        let rawVueRule;
+        let vueRules = [];
+        for (const rawRule of rules) {
+            // skip rules with 'enforce'. eg. rule for eslint-loader
+            if (rawRule.enforce) {
+                continue;
+            }
+            vueRules = match(rawRule, `foo.${(0, getMlSuffixName_1.default)()}`);
+            if (!vueRules.length) {
+                vueRules = match(rawRule, 'foo.vue.html');
+            }
+            if (vueRules.length > 0) {
+                if (rawRule.oneOf) {
+                    throw new Error(`[VueLoaderPlugin Error] vue-loader currently does not support vue rules with oneOf.`);
+                }
+                rawVueRule = rawRule;
+                break;
+            }
+        }
+        if (!vueRules.length) {
+            throw new Error(`[VueLoaderPlugin Error] No matching rule for .vue files found.\n` +
+                `Make sure there is at least one root-level rule that matches .vue or .vue.html files.`);
+        }
+        // get the normlized "use" for vue files
+        const vueUse = vueRules.filter(rule => rule.type === 'use').map(rule => rule.value);
+        // get vue-loader options
+        const vueLoaderUseIndex = vueUse.findIndex(u => 
+        // FIXME: this code logic is incorrect when project paths starts with `vue-loader-something`
+        /^vue-loader|(\/|\\|@)vue-loader/.test(u.loader));
+        if (vueLoaderUseIndex < 0) {
+            throw new Error(`[VueLoaderPlugin Error] No matching use for vue-loader is found.\n` +
+                `Make sure the rule matching .vue files include vue-loader in its use.`);
+        }
+        // make sure vue-loader options has a known ident so that we can share
+        // options by reference in the template-loader by using a ref query like
+        // template-loader??vue-loader-options
+        const vueLoaderUse = vueUse[vueLoaderUseIndex];
+        const vueLoaderOptions = (vueLoaderUse.options = vueLoaderUse.options || {});
+        // for each user rule (expect the vue rule), create a cloned rule
+        // that targets the corresponding language blocks in *.vue files.
+        const refs = new Map();
+        const clonedRules = rules
+            .filter(r => r !== rawVueRule)
+            .map(rawRule => cloneRule(rawRule, refs, langBlockRuleCheck, langBlockRuleResource));
+        // fix conflict with config.loader and config.options when using config.use
+        delete rawVueRule.loader;
+        delete rawVueRule.options;
+        rawVueRule.use = vueUse;
+        // rule for template compiler
+        const templateCompilerRule = {
+            loader: require.resolve('vue-loader/dist/templateLoader'),
+            resourceQuery: (query) => {
+                if (!query) {
+                    return false;
+                }
+                const parsed = querystring_1.default.parse(query.slice(1));
+                return parsed.vue != null && parsed.type === 'template';
+            },
+            options: vueLoaderOptions,
+        };
+        // for each rule that matches plain .js files, also create a clone and
+        // match it against the compiled template code inside *.vue files, so that
+        // compiled vue render functions receive the same treatment as user code
+        // (mostly babel)
+        const jsRulesForRenderFn = rules
+            .filter(r => r !== rawVueRule && match(r, 'test.js').length > 0)
+            .map(rawRule => cloneRule(rawRule, refs, jsRuleCheck, jsRuleResource));
+        // global pitcher (responsible for injecting template compiler loader & CSS
+        // post loader)
+        const pitcher = {
+            loader: require.resolve('vue-loader/dist/pitcher'),
+            resourceQuery: (query) => {
+                if (!query) {
+                    return false;
+                }
+                const parsed = querystring_1.default.parse(query.slice(1));
+                return parsed.vue != null;
+            },
+        };
+        // replace original rules
+        compiler.options.module.rules = [
+            pitcher,
+            ...jsRulesForRenderFn,
+            templateCompilerRule,
+            ...clonedRules,
+            ...rules,
+        ];
+    }
+}
+VueLoaderPlugin.NS = NS;
+exports.default = VueLoaderPlugin;

package/dist/webpack-config/plugins/XhsMpErrorTransformPlugin.d.ts

@@ -0,0 +1,8 @@
+import { Compiler } from 'webpack';
+/**
+ * 将 VueCompilerError 转换为 xhsml 错误提示
+ */
+declare class XhsMpErrorTransformPlugin {
+    apply(compiler: Compiler): void;
+}
+export default XhsMpErrorTransformPlugin;

package/dist/webpack-config/plugins/XhsMpErrorTransformPlugin.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getMlSuffixName_1 = __importDefault(require("../../utils/getMlSuffixName"));
+/**
+ * 将 VueCompilerError 转换为 xhsml 错误提示
+ */
+class XhsMpErrorTransformPlugin {
+    apply(compiler) {
+        compiler.hooks.afterCompile.tap('XhsMpErrorTransformPlugin', (compilation) => {
+            let vueCompilerErrors = [];
+            const errorFiles = new Set();
+            compilation.errors = compilation.errors.filter(err => {
+                if (/VueCompilerError/.test(err.message)) {
+                    vueCompilerErrors.push(err);
+                    return false;
+                }
+                return true;
+            });
+            // 同一个文件只取最后一个报错
+            vueCompilerErrors = vueCompilerErrors.reverse().reduce((acc, err) => {
+                if (err.module) {
+                    const { context } = err.module;
+                    if (!errorFiles.has(context)) {
+                        err.stack = undefined;
+                        err.message = err.message.replace(/VueCompilerError/g, `[ ${(0, getMlSuffixName_1.default)()} 文件编译错误 ]`).replace(/at createCompilerError .*?/g, '');
+                        err.details = undefined;
+                        acc.push(err);
+                        errorFiles.add(context);
+                    }
+                }
+                return acc;
+            }, []);
+            compilation.errors.push(...vueCompilerErrors);
+        });
+    }
+}
+exports.default = XhsMpErrorTransformPlugin;

package/dist/webpack-config/plugins/XhsMpJsonPlugin.d.ts

@@ -0,0 +1,36 @@
+import { Compiler } from 'webpack';
+import { AppJSON } from '../../types/index';
+interface IXhsMpJsonPluginOptions {
+    mpDir: string;
+    miniprogramDir: string;
+    extJsonPath?: string;
+}
+export interface IXhsData {
+    mpDir?: string;
+    miniprogramDir?: string;
+    appJSON?: AppJSON;
+    legacyAppJSON?: AppJSON;
+    jsonDependencies?: string[];
+}
+export type XhsCompiler = Compiler & {
+    xhsData: IXhsData;
+};
+/**
+ * 为 compiler 添加 xhsData 数据
+ */
+declare class XhsMpJsonPlugin {
+    options: IXhsMpJsonPluginOptions;
+    appJSON: AppJSON;
+    legacyAppJSON: AppJSON;
+    shouldUpdateAppJson: 'first' | boolean;
+    jsonDependencies: Set<string>;
+    static getHooks: any;
+    constructor(options: IXhsMpJsonPluginOptions);
+    apply(compiler: XhsCompiler): void;
+    /**
+     * 1. 收集所有的 json 依赖
+     * 2. 为各个 loader 更新 appJson
+     */
+    updateAppJson(compiler: XhsCompiler): void;
+}
+export default XhsMpJsonPlugin;