f2e-server3/lib/middlewares/include/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 fs = __importStar(require("node:fs"));
const path = __importStar(require("node:path"));
const logger_1 = __importDefault(require("../../utils/logger"));
const _ = __importStar(require("../../utils/misc"));
const node_process_1 = require("node:process");
const htmlReplacer = function replace(content, root, recursive) {
    const items = [];
    let result = content;
    if (/<f2e:include\s+src="([^"]+)"\s*\/>/.test(content)) {
        result = content.replace(/<f2e:include\s+src="([^"]+)"\s*\/>/g, (_, src) => {
            const realpath = path.join(path.dirname(root), src);
            const data = fs.readFileSync(realpath, 'utf-8');
            items.push({ src: realpath, data });
            if (recursive && /<f2e:include\s+src="([^"]+)"\s*\/>/.test(data)) {
                const { items: subItems, result: subResult } = replace(data, realpath, recursive);
                items.push(...subItems);
                return subResult;
            }
            else {
                return data;
            }
        });
    }
    return {
        items,
        result
    };
};
const defaultLoaders = {
    '.html': htmlReplacer,
    '.htm': htmlReplacer,
    '.shtml': htmlReplacer,
};
const middleware_include = {
    name: 'include',
    mode: ['dev', 'build'],
    execute: async (conf) => {
        const { root, include } = conf;
        if (!include) {
            return;
        }
        const { recursive = false, entryPoints = [], loaders = defaultLoaders, } = include;
        if (entryPoints.length === 0) {
            logger_1.default.error('Include entryPoints is empty!');
            (0, node_process_1.exit)(1);
        }
        const entry_map = new Map(entryPoints.map(p => {
            if (typeof p === 'string') {
                const origin = _.pathname_fixer(p);
                return [origin, origin];
            }
            return [_.pathname_fixer(p.in), _.pathname_fixer(p.out)];
        }));
        const deps_map = new Map();
        const build = async function (origin, store) {
            const output = entry_map.get(origin);
            if (!output) {
                logger_1.default.error(`Include entry ${origin} not exists!`);
                return;
            }
            const realPath = path.join(conf.root, origin);
            if (!fs.existsSync(realPath)) {
                logger_1.default.error(`Include file ${realPath} not exists!`);
                (0, node_process_1.exit)(1);
            }
            const data = fs.readFileSync(realPath, 'utf-8');
            const ext = path.extname(origin);
            const loader = loaders[ext];
            if (!loader) {
                logger_1.default.error(`Include loader ${ext} not exists!`);
                (0, node_process_1.exit)(1);
            }
            const { items, result } = await loader(data, realPath, recursive);
            if (result) {
                store.save({
                    originPath: origin,
                    outputPath: output,
                    data: result,
                });
            }
            deps_map.set(origin, origin);
            store.ignores.add(origin);
            items.forEach(item => {
                const p = _.pathname_fixer(path.relative(root, item.src));
                store.ignores.add(p);
                deps_map.set(_.pathname_fixer(p), 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_include;