@ices/locale-webpack-plugin/dist/Plugin.js

webpack plugin for parsing locale files

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const use_loader_1 = require("@ices/use-loader");
const module_1 = require("./lib/module");
const ExtractPlugin_1 = tslib_1.__importDefault(require("./lib/ExtractPlugin"));
const extractLoader_1 = tslib_1.__importDefault(require("./loader/extractLoader"));
const localeLoader_1 = tslib_1.__importDefault(require("./loader/localeLoader"));
const ymlLoader_1 = tslib_1.__importDefault(require("./loader/ymlLoader"));
/**
 * 使用的组件类型。
 * 暂未提供vue组件。
 */
var ComponentType;
(function (ComponentType) {
    ComponentType["react"] = "react";
    ComponentType["vue"] = "vue";
})(ComponentType || (ComponentType = {}));
/**
 * 用于加载解析语言定义文件至组件模块的webpack插件。
 */
class LocaleWebpackPlugin {
    constructor(options) {
        this.extractPlugin = null;
        this.resolveAlias = null;
        this.fileLoaders = [ymlLoader_1.default];
        this.options = Object.assign({
            test: this.fileLoaders.map(({ test }) => test),
            componentType: ComponentType.react,
            esModule: true,
        }, options);
        const { componentType } = this.options;
        const moduleDetails = this.getLibModuleDetails(componentType);
        this.moduleGenerator = this.getModuleGenerator(moduleDetails);
        this.extensions = this.getSupportedExtensions();
        (0, module_1.createDeclarations)(moduleDetails, this.extensions, 'lib/locale.d.ts');
    }
    getLibModuleDetails(componentType) {
        let moduleDetails = null;
        switch (componentType) {
            case ComponentType.react:
                moduleDetails = (0, module_1.getModuleDetails)('@ices/react-locale');
                break;
            case ComponentType.vue:
                // exports = getModuleExports(['@ices/vue-locale'])
                break;
        }
        if (!moduleDetails) {
            throw new Error(`There is no corresponding component loader for ${componentType}`);
        }
        return moduleDetails;
    }
    getModuleGenerator({ loaderModule, name }) {
        const { getModuleCode } = loaderModule;
        if (typeof getModuleCode !== 'function') {
            throw new Error(`There is no corresponding code generator (${name})`);
        }
        return getModuleCode;
    }
    getSupportedExtensions() {
        const extSet = new Set();
        for (const { extensions } of this.fileLoaders) {
            if (Array.isArray(extensions)) {
                for (const ext of extensions) {
                    extSet.add(ext.replace(/^\./, ''));
                }
            }
        }
        return [...extSet];
    }
    getLoaderRule({ filepath, test, resourceQuery }, extractLocales) {
        const { options: { esModule }, extensions, moduleGenerator, extractPlugin, resolveAlias, mode, } = this;
        const options = {
            mode,
            esModule,
            extensions,
            resolveAlias,
            extract: extractLocales,
            extractor: extractPlugin,
            generator: moduleGenerator,
        };
        const rule = { test, resourceQuery };
        if (extractLocales) {
            rule.use = [
                { loader: extractLoader_1.default.filepath, options },
                { loader: filepath, options },
            ];
        }
        else {
            rule.loader = filepath;
            rule.options = options;
        }
        //
        return rule;
    }
    apply(compiler) {
        const { test, include, exclude, extract, esModule, extractOptions } = this.options;
        const { options: compilerOptions } = compiler;
        const { target, resolve = {}, mode } = compilerOptions;
        const { alias: resolveAlias } = resolve;
        this.resolveAlias = resolveAlias || null;
        this.mode = !mode || mode === 'none' ? process.env.NODE_ENV : mode;
        let shouldExtract = extract;
        if (typeof shouldExtract !== 'boolean') {
            shouldExtract = this.mode === 'production' && !/node|electron/.test(`${target}`);
        }
        if (shouldExtract) {
            this.extractPlugin = new ExtractPlugin_1.default(Object.assign({}, extractOptions, { esModule }));
            this.extractPlugin.apply(compiler);
        }
        const rule = {
            test,
            include,
            exclude,
            rules: [
                this.getLoaderRule(localeLoader_1.default),
                {
                    oneOf: this.fileLoaders.map((loader) => this.getLoaderRule(loader, shouldExtract)),
                },
            ],
        };
        (0, use_loader_1.addLoaderBefore)(compilerOptions, ({ name, type, isUseItem }) => !isUseItem && (name === 'file-loader' || /asset(\/resource)?/.test(`${type}`)), rule);
    }
}
exports.default = LocaleWebpackPlugin;
//# sourceMappingURL=Plugin.js.map