alapa/dist/template/render.js

A cutting-edge web development framework designed to revolutionize the way developers build modern web applications.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.TemplateEngine = void 0;
const utils_1 = require("../utils");
const main_1 = require("./extension/component/main");
const main_2 = require("./extension/container/main");
const include_1 = require("./extension/include");
const output_1 = require("./output");
const misc_1 = require("./regex/misc");
const utils_2 = require("./utils");
const fs_1 = __importDefault(require("fs"));
class TemplateEngine {
    static compile(template, context) {
        template = template.replace(misc_1.templateCommentRegex, "");
        template = (0, utils_2.removeCommentsFromCode)(template);
        template = include_1.Include.render(template);
        main_2.Container.compile(template);
        template = main_2.Container.removeContainersFromTemplate(template);
        let outputOfTemplateEngine = "";
        function addOutPutToTemplateEngine(output = "") {
            outputOfTemplateEngine += output;
        }
        function containers(key) {
            if (!key)
                return main_2.Container.get();
            return main_2.Container.get().filter((k) => k.key == key);
        }
        const getOutPutToTemplateEngine = () => outputOfTemplateEngine;
        context = context || {};
        context["addOutPutToTemplateEngine"] = addOutPutToTemplateEngine;
        context["getOutPutToTemplateEngine"] = getOutPutToTemplateEngine;
        context["containers"] = containers;
        context["escapeHTML"] = utils_2.escapeHTML;
        // Clean up the template
        template = template.replace(misc_1.importRegex, "");
        template = (0, output_1.outPutVariable)(template);
        template = template.replace(misc_1.codeRegex, (match, codeBlock) => {
            return `</no-code>${codeBlock}<no-code>`;
        });
        template = `<no-code>${template}</no-code>`;
        // Escape HTML and prepare the output
        template = template.replace(misc_1.noCodeRegex, (match, html) => {
            html = (0, utils_2.escapeCode)(html);
            return `;addOutPutToTemplateEngine(\`${html}\`);`;
        });
        // Prepare the function with the context directly accessible
        template = `${template} return getOutPutToTemplateEngine()`;
        const output = new Function(`return (function() {
                  for (const key in this) {
                      global[key] = this[key];
                  }
                      ${template}
              }).apply(this);
          `).call(context);
        template = template.replace(/\[\[\s?(.*?)\s?\]\]/g, (match, key) => {
            try {
                const value = `{% addOutPutToTemplateEngine(\`$\{${key}}\`); %}`;
                return value;
            }
            catch (e) {
                utils_1.Logger.error(`Error while processing template: ${e}`);
                return "";
            }
        });
        return output !== undefined ? output : "";
    }
    static renderString(template, context) {
        main_2.Container.clear();
        return this.compile(template, context);
    }
    static getTemplate(templatePath) {
        const template = fs_1.default.readFileSync(templatePath, "utf8");
        return template;
    }
    static renderFile(templatePath, context) {
        const template = main_1.Component.compileFile(templatePath, context);
        return this.renderString(template, context);
    }
}
exports.TemplateEngine = TemplateEngine;