f2e-server3/lib/middlewares/less/index.js

f2e-server 3.0

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const _ = __importStar(require("../../utils/misc"));
const node_process_1 = require("node:process");
const path = __importStar(require("node:path"));
const fs = __importStar(require("node:fs"));
const logger_1 = __importDefault(require("../../utils/logger"));
const utils_1 = require("../../utils");
const middleware_less = {
    name: 'less',
    mode: ['dev', 'build'],
    execute: async (conf) => {
        if (!conf.less) {
            return;
        }
        const { entryPoints = [], buildOptions = {} } = conf.less;
        const entry_map = new Map(entryPoints.map(p => {
            if (typeof p === 'string') {
                return [_.pathname_fixer(p), _.pathname_fixer(p.replace(/\.less$/, '.css'))];
            }
            return [_.pathname_fixer(p.in), _.pathname_fixer(p.out)];
        }));
        const deps_map = new Map();
        const less = await (0, utils_1.dynamicImport)('less');
        const build = async function (origin, store) {
            const output = entry_map.get(origin);
            if (!output) {
                logger_1.default.error(`Less entry ${origin} not exists!`);
                return;
            }
            const realPath = path.join(conf.root, origin);
            if (!fs.existsSync(realPath)) {
                logger_1.default.error(`Less file ${realPath} not exists!`);
                (0, node_process_1.exit)(1);
            }
            const data = fs.readFileSync(realPath, 'utf-8');
            const input = data.replace(/(@import.*)"(\S*\/)"/g, (impt, pre, dir) => {
                let pkg = path.join(path.dirname(realPath), dir);
                return fs.readdirSync(pkg).filter(d => /\.less$/.test(d)).map(d => `${pre}"${dir}${d}";`).join('\n');
            });
            const lessData = await less.render(input, {
                rootpath: conf.root,
                filename: origin,
                javascriptEnabled: true,
                sourceMap: {
                    sourceMapURL: output.split('/').pop(),
                    outputSourceFiles: true
                },
                ...buildOptions
            });
            if (lessData.css) {
                store.save({
                    originPath: origin,
                    outputPath: output,
                    data: lessData.css + '',
                });
            }
            if (lessData.map) {
                const map = lessData.map.toString();
                const mapPath = output.replace(/\.css$/, '.css.map');
                store.save({
                    originPath: mapPath,
                    outputPath: mapPath,
                    data: map + '',
                });
            }
            deps_map.set(origin, origin);
            store.ignores.add(origin);
            lessData.imports.forEach(file => {
                store.ignores.add(file);
                deps_map.set(_.pathname_fixer(file), origin);
            });
        };
        return {
            onMemoryLoad: async (store) => {
                const entries = [...entry_map.keys()];
                await Promise.all(entries.map(origin => build(origin, store)));
            },
            buildWatcher: (pathname, eventType, __build, store) => {
                const main = deps_map.get(pathname);
                if (main) {
                    try {
                        build(main, store);
                    }
                    catch (e) {
                        logger_1.default.error(e);
                    }
                }
            }
        };
    }
};
exports.default = middleware_less;