@sanpjs/core/dist/createContext.js

@sanpjs/core

"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"));
// @ts-ignore
const only_1 = __importDefault(require("only"));
const config_1 = require("./config");
const defaultOptions_1 = __importDefault(require("./config/defaultOptions"));
const Resolver_1 = __importDefault(require("./Resolver"));
const utils_1 = require("@sanpjs/utils");
function generatePages(type, pages, resolver) {
    switch (type) {
        case 'spa':
        case 'spa-ssr':
            // 收集其余配置项，每个pages内第一个有效的配置的生效
            const others = pages.reduce((prev, cur) => {
                // eslint-disable-next-line no-unused-vars
                const { name, filepath, ...others } = cur;
                // 单页多个其余页面配置时，只取第一个有效配置
                return Object.keys(prev).length === 0 && others ? others : prev;
            }, {});
            // 单页应用含有路由，只有一个入口可以是.sanp/app.js或.sanp/app/index.js
            return [
                {
                    name: 'index',
                    filepath: resolver.resolveSanp('app/index.js'),
                    ...others
                }
            ];
        case 'mpa':
            // 多页应用，多个单文件入口，入口是.sanp/app下的对应js
            return pages.map((p) => {
                p.filepath = resolver.resolveSanp(p.filepath, true);
                return p;
            });
        case 'mpa-ssr':
        case 'component':
        default:
            return pages;
    }
}
function createPages({ pagesDir }, logger, resolver) {
    const directory = resolver.resolveEntry(pagesDir, false);
    if (!fs_extra_1.default.existsSync(directory)) {
        logger.warn(`Pages directory ${directory} not exists`);
        process.exit(24);
    }
    const files = fs_extra_1.default.readdirSync(directory);
    const mayBeEntries = files.map((f) => {
        const extension = path_1.default.extname(f);
        return {
            name: path_1.default.basename(f, extension),
            filepath: resolver.resolveEntry(path_1.default.resolve(directory, f))
        };
    });
    return mayBeEntries.filter(Boolean);
}
// TODO 相对路径改绝对
function normalize(inConfigs, oriConfigs, { cwd, logger }) {
    const build = inConfigs.build || {};
    const server = inConfigs.server || {};
    const configs = {
        ...oriConfigs,
        ...inConfigs,
        // build
        build: {
            ...oriConfigs.build,
            ...build,
            // 检查代码，比如检查出现额外的依赖、检查最后代码是不是es5
            inspect: {
                ...oriConfigs.build?.inspect,
                ...(build.inspect || {})
            },
            // script
            script: {
                ...oriConfigs.build?.script,
                ...(build.script || {})
            },
            // style
            style: {
                ...oriConfigs.build?.style,
                ...(build.style || {})
            },
            optimization: {
                ...oriConfigs.build?.optimization,
                ...(build.optimization || {})
            }
        },
        server: {
            ...oriConfigs.server,
            ...server
        }
    };
    // 处理root
    if (configs.root) {
        if (!path_1.default.isAbsolute(configs.root)) {
            configs.root = path_1.default.resolve(cwd, configs.root);
        }
    }
    else {
        configs.root = cwd;
    }
    const resolver = new Resolver_1.default(configs.root, configs);
    // 处理为绝对路径
    configs.sanpDir = resolver.resolveEntry(configs.sanpDir, false);
    // 增加 configs.$pages
    configs.$pages = configs.pages;
    if (configs.pages) {
        // normalize pages
        if (!Array.isArray(configs.pages)) {
            configs.pages = [configs.pages];
        }
        configs.pages = configs.pages.map((p) => {
            if (typeof p === 'string') {
                // p as name
                return {
                    filepath: resolver.resolve(p)
                };
            }
            else if (p.name) {
                p.filepath = resolver.resolveEntry(p.filepath || path_1.default.join(configs.pagesDir, p.name));
            }
            else {
                // TODO 报错 理论上不会走到这里
                logger.error(`Invalid page config: ${JSON.stringify(p)}`);
            }
            return p;
        });
    }
    else {
        // create pages
        // watch pages directory
        configs.pages = createPages(configs, logger, resolver);
    }
    configs.pages = generatePages(configs.type, configs.pages, resolver);
    // auto load components
    // if(configs.components){
    // }
    return {
        config: configs,
        resolver
    };
}
async function createContext({ configFile, mode, watch, clean, analyze }) {
    const cwd = process.cwd();
    const cached = {};
    // 处理
    const { configs: rawConfigs, filepath } = await (0, config_1.load)(configFile, cwd);
    const clonedConfigs = {
        build: {},
        ...rawConfigs
    };
    if (mode) {
        clonedConfigs.mode = mode;
    }
    if (typeof watch === 'boolean') {
        clonedConfigs.watch = watch;
    }
    // merge args
    // 如果不存在，则使用默认配置
    if (rawConfigs.build) {
        if (!('sourceMap' in rawConfigs.build)) {
            clonedConfigs.build.sourceMap = clonedConfigs.mode === 'production';
        }
        if (!('hash' in rawConfigs.build)) {
            clonedConfigs.build.hash = clonedConfigs.mode === 'production';
        }
    }
    if (clean) {
        clonedConfigs.build.clean = !!clean;
    }
    if (analyze) {
        clonedConfigs.build.analyze = !!analyze;
    }
    // 验证 options schema
    (0, config_1.validate)(clonedConfigs);
    const { config, resolver } = normalize(clonedConfigs, defaultOptions_1.default, { cwd, logger: utils_1.logger });
    const { root: projectRoot } = config;
    // read package.json
    const pkg = fs_extra_1.default.readJsonSync(path_1.default.join(projectRoot, 'package.json'), 'utf-8');
    const context = Object.create({
        // readonly
        get logger() {
            return utils_1.logger;
        },
        get env() {
            return process.env;
        },
        get cwd() {
            return cwd;
        },
        get rawConfig() {
            return rawConfigs;
        },
        get sanpDir() {
            return config.sanpDir;
        },
        get config() {
            return config;
        },
        get configFile() {
            return filepath;
        },
        get resolver() {
            return resolver;
        },
        get pkg() {
            return pkg;
        },
        // config alias readonly
        get pages() {
            return config.pages;
        },
        // 保存用户原始的 pages 信息
        get $pages() {
            return config.$pages;
        },
        get plugins() {
            return config.plugins;
        },
        get root() {
            return config.root;
        },
        get pagesDir() {
            return config.pagesDir;
        },
        get build() {
            return config.build;
        },
        get server() {
            return config.server;
        },
        get ssr() {
            return config.ssr;
        },
        get mode() {
            return config.mode;
        },
        get dev() {
            return config.mode === 'development';
        },
        get prod() {
            return config.mode === 'production';
        },
        // TODO: 实现
        get progress() {
            return config.progress;
        },
        get watch() {
            return config.watch;
        },
        get type() {
            return config.type;
        },
        get isSsr() {
            return ['spa-ssr', 'mpa-ssr'].includes(config.type);
        },
        // writable
        get builder() {
            return cached.builder;
        },
        set builder(builder) {
            if (cached.builder) {
                // 只能设置一次
                throw new Error('builder is already set');
            }
            cached.builder = builder;
        },
        get bundler() {
            return cached.bundler;
        },
        set bundler(bundler) {
            if (cached.bundler) {
                // 只能设置一次
                throw new Error('bundler is already set');
            }
            cached.bundler = bundler;
        },
        // mehtods
        resolve(filepath) {
            return resolver.resolve(filepath);
        },
        getLayout(pageName, checkExist = true) {
            const { resolveLayout } = resolver;
            let page = config.pages.find((p) => p.name === pageName);
            if (page) {
                switch (config.type) {
                    case 'spa':
                    case 'spa-ssr':
                        return resolveLayout(page.layout);
                    case 'mpa':
                        // 先找 page.layout
                        // 再找 ${pageName}.ejs
                        // 最后找 .sanp/layouts/default.ejs
                        if (page.layout) {
                            return resolveLayout(page.layout);
                        }
                        const namedLayout = path_1.default.join(config.root, 'layouts', `${pageName}.ejs`);
                        if (!checkExist) {
                            return namedLayout;
                        }
                        return fs_extra_1.default.existsSync(namedLayout) ? namedLayout : resolveLayout();
                    // case 'spa-ssr':
                    // case 'mpa-ssr':
                    // case 'component':
                }
            }
        },
        toJSON() {
            return (0, only_1.default)(this, [
                'config',
                'configFile',
                'pkg',
                'root',
                'pages',
                'plugins',
                'build',
                'server',
                'ssr',
                'mode',
                'dev',
                'prod',
                'progress',
                'watch',
                'type'
            ]);
        },
        inspect() {
            return this.toJSON();
        }
    });
    return context;
}
exports.default = createContext;
//# sourceMappingURL=createContext.js.map