@zenweb/template 3.0.0

package/README.md

@@ -0,0 +1,94 @@
+# zenweb-template
+
+zenweb template render module
+
+## Install
+
+```bash
+npm install @zenweb/template
+```
+
+### nunjucks
+
+```bash
+npm install nunjucks
+npm install @types/nunjucks --save-dev
+```
+
+### handlebars
+
+```bash
+npm install handlebars
+```
+
+## Config
+
+src/index.ts
+```ts
+import { create } from 'zenweb';
+import modTemplate from '@zenweb/template';
+import nunjucks from '@zenweb/template/engine/nunjucks';
+import handlebars from '@zenweb/template/handlebars';
+
+const app = create();
+
+app.setup(modTemplate({
+  matchPath: [/\.html$/i],
+  engine: nunjucks({
+    filter: require('./template/filter'),
+    global: require('./template/global'),
+  }),
+}));
+
+// Multiple Engines
+app.setup(modTemplate({
+  type: 'xml',
+  matchPath: [/\.xml$/i],
+  templateAffix: '.xml',
+  engineName: 'xml',
+  engine: handlebars(),
+}));
+
+app.start();
+```
+
+## Use
+
+src/controller/demo.ts
+```ts
+import { Context, mapping } from "zenweb";
+
+export class DemoController {
+  @mapping({ path: ['/', '/index.html'] })
+  index(ctx: Context) {
+    ctx.template('index.html');
+    return { name: 'Hello' };
+  }
+
+  @mapping({ path: '/test.html' })
+  test() {
+    return { name: 'Test' };
+  }
+
+  @mapping()
+  xml(ctx: Context) {
+    ctx.template({ engine: 'xml' })
+    return { name: 'Test' };
+  }
+}
+```
+
+template/index.html
+```html
+<h1>Hello {{name}}</h1>
+```
+
+template/test.html
+```html
+<h1>Hello {{name}}</h1>
+```
+
+template/xml.xml
+```xml
+<root>{{name}}</root>
+```

package/dist/engine/handlebars.d.ts

@@ -0,0 +1,14 @@
+import { TemplateEngine } from '../types';
+export interface HandlebarsOption extends CompileOptions {
+    /**
+     * 模版文件夹
+     * @default './template'
+     */
+    path?: string | string[];
+    /**
+     * 缓存已编译模版
+     * @default true
+     */
+    cache?: boolean;
+}
+export default function (option?: HandlebarsOption): TemplateEngine;

package/dist/engine/handlebars.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const util_1 = require("util");
+const handlebars_1 = require("handlebars");
+const utils_1 = require("../utils");
+const fs_exists = (0, util_1.promisify)(fs.exists);
+const fs_readFile = (0, util_1.promisify)(fs.readFile);
+function default_1(option) {
+    const opt = Object.assign({
+        path: './template',
+        cache: true,
+    }, option);
+    (0, utils_1.debug)('option: %o', opt);
+    const paths = (Array.isArray(opt.path) ? opt.path : [opt.path]).map(p => (0, utils_1.cwdPath)(p));
+    async function loadTemplate(template) {
+        for (const p of paths) {
+            const filename = path.join(p, template);
+            if (await fs_exists(filename)) {
+                return await fs_readFile(filename, 'utf-8');
+            }
+        }
+        throw new Error(`Template file not found: ${template}`);
+    }
+    const cache = {};
+    return async function handlebars(template, data) {
+        if (opt.cache && !cache[template]) {
+            const content = await loadTemplate(template);
+            cache[template] = (0, handlebars_1.compile)(content, opt);
+        }
+        return cache[template](data);
+    };
+}
+exports.default = default_1;

package/dist/engine/nunjucks.d.ts

@@ -0,0 +1,36 @@
+import { Environment, ConfigureOptions, Extension } from 'nunjucks';
+import { TemplateEngine } from '../types';
+export interface NunjucksOption {
+    /**
+     * 模版文件夹
+     * @default './template'
+     */
+    path?: string | string[];
+    /**
+     * 配置过滤器
+     */
+    filter?: {
+        [name: string]: (...args: any[]) => any;
+    };
+    /**
+     * 配置自定义扩展
+     */
+    extension?: {
+        [name: string]: Extension;
+    };
+    /**
+     * 配置全局变量
+     */
+    global?: {
+        [name: string]: any;
+    };
+    /**
+     * 设置 nunjucks 配置
+     */
+    nunjucksConfig?: ConfigureOptions;
+    /**
+     * 设置 nunjucks 环境变量
+     */
+    configureEnvironment?: (env: Environment) => any;
+}
+export default function (option?: NunjucksOption): TemplateEngine;

package/dist/engine/nunjucks.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nunjucks_1 = require("nunjucks");
+const utils_1 = require("../utils");
+function default_1(option) {
+    const opt = Object.assign({
+        path: './template',
+    }, option);
+    (0, utils_1.debug)('option: %o', opt);
+    const paths = (Array.isArray(opt.path) ? opt.path : [opt.path]).map(p => (0, utils_1.cwdPath)(p));
+    const env = (0, nunjucks_1.configure)(paths, opt.nunjucksConfig);
+    if (opt.filter) {
+        Object.entries(opt.filter).forEach(([name, func]) => env.addFilter(name, func));
+    }
+    if (opt.extension) {
+        Object.entries(opt.extension).forEach(([name, ext]) => env.addExtension(name, ext));
+    }
+    if (opt.global) {
+        Object.entries(opt.global).forEach(([name, value]) => env.addGlobal(name, value));
+    }
+    if (typeof opt.configureEnvironment === 'function') {
+        opt.configureEnvironment(env);
+    }
+    return function nunjucks(name, data) {
+        return new Promise((resolve, reject) => {
+            env.render(name, data, (err, res) => {
+                if (err)
+                    return reject(err);
+                resolve(res);
+            });
+        });
+    };
+}
+exports.default = default_1;

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { SetupFunction } from '@zenweb/core';
+import { RenderManager } from '@zenweb/result';
+import { TemplateSetupOption, TemplateOption } from './types';
+import { TEMPLATE_OPTION } from './render';
+export * from './types';
+export { RenderManager };
+export default function setup(option: TemplateSetupOption): SetupFunction;
+declare module '@zenweb/core' {
+    interface Context {
+        [TEMPLATE_OPTION]?: TemplateOption;
+        /**
+         * 启用并设置模版渲染
+         * - 不传参数: 启用
+         * - false: 关闭模版渲染
+         * - string: 设置模版文件名
+         * - TemplateOption: 详细设置
+         */
+        template(template_or_option?: false | string | TemplateOption): void;
+    }
+}

package/dist/index.js

@@ -0,0 +1,51 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderManager = void 0;
+const result_1 = require("@zenweb/result");
+Object.defineProperty(exports, "RenderManager", { enumerable: true, get: function () { return result_1.RenderManager; } });
+const render_1 = require("./render");
+__exportStar(require("./types"), exports);
+function contextTemplate(template_or_option) {
+    if (template_or_option === false) {
+        delete this[render_1.TEMPLATE_OPTION];
+        return;
+    }
+    if (!this[render_1.TEMPLATE_OPTION]) {
+        this[render_1.TEMPLATE_OPTION] = {};
+    }
+    if (typeof template_or_option === 'string') {
+        Object.assign(this[render_1.TEMPLATE_OPTION], { template: template_or_option });
+    }
+    else if (typeof template_or_option === 'object') {
+        Object.assign(this[render_1.TEMPLATE_OPTION], template_or_option);
+    }
+}
+function setup(option) {
+    return async function template(setup) {
+        if (!option.engineName) {
+            option.engineName = option.engine.name;
+        }
+        setup.debug('option: %o', option);
+        setup.assertModuleExists('result', '@zenweb/result');
+        const renderManager = await setup.core.injector.getInstance(result_1.RenderManager);
+        renderManager.add(new render_1.TemplateRender(option));
+        if (!('template' in setup.app.context)) {
+            setup.defineContextProperty('template', { value: contextTemplate });
+        }
+    };
+}
+exports.default = setup;

package/dist/render.d.ts

@@ -0,0 +1,11 @@
+import { Context } from '@zenweb/core';
+import { ResultRender } from '@zenweb/result';
+import { TemplateSetupOption } from './types';
+export declare const TEMPLATE_OPTION: unique symbol;
+export declare class TemplateRender implements ResultRender {
+    private _option;
+    type: string;
+    constructor(_option: TemplateSetupOption);
+    match(ctx: Context): boolean;
+    render(ctx: Context, data?: unknown): any;
+}

package/dist/render.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateRender = exports.TEMPLATE_OPTION = void 0;
+const utils_1 = require("./utils");
+exports.TEMPLATE_OPTION = Symbol('template@option');
+class TemplateRender {
+    constructor(_option) {
+        this._option = _option;
+        this.type = this._option.type || 'html';
+    }
+    match(ctx) {
+        const opt = ctx[exports.TEMPLATE_OPTION];
+        if (opt && opt.engine === this._option.engineName) {
+            (0, utils_1.debug)('matchEngine: %o', this._option.engineName);
+            return true;
+        }
+        // 匹配路径规则
+        if (this._option.matchPath) {
+            for (const reg of this._option.matchPath) {
+                if (reg.test(ctx.path)) {
+                    (0, utils_1.debug)('matchPath: %o', reg);
+                    return true;
+                }
+            }
+        }
+        // 匹配 Accept 头类型
+        if (this._option.matchAccept) {
+            const _type = ctx.accepts(this._option.matchAccept);
+            if (_type) {
+                (0, utils_1.debug)('matchAccept: %o', _type);
+                return true;
+            }
+        }
+        return false;
+    }
+    render(ctx, data) {
+        console.log(this);
+        const opt = ctx[exports.TEMPLATE_OPTION];
+        let template = opt === null || opt === void 0 ? void 0 : opt.template;
+        if (!template) {
+            template = ctx.path.slice(1);
+            if (this._option.templateAffix) {
+                template += this._option.templateAffix;
+            }
+        }
+        return this._option.engine(template, data);
+    }
+}
+exports.TemplateRender = TemplateRender;

package/dist/types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 渲染引擎的渲染方法
+ * - 方法名作为默认的引擎名称
+ */
+export type TemplateEngine = (template: string, data?: any) => any;
+export interface TemplateSetupOption {
+    /**
+     * 输出类型
+     * @default 'html'
+     */
+    type?: string;
+    /**
+     * 匹配路径结尾例如 `/.html$/i`
+     */
+    matchPath?: RegExp[];
+    /**
+     * 匹配 Accept Type 头信息
+     */
+    matchAccept?: string[];
+    /**
+     * 模版名后缀
+     * - 例如 '.html'
+     * - 在不指定 `TemplateOption.template` 时有效
+     */
+    templateAffix?: string;
+    /**
+     * 失败使用模版
+     */
+    failTemplate?: string;
+    /**
+     * 渲染引擎
+     */
+    engine: TemplateEngine;
+    /**
+     * 设置渲染引擎名称
+     * - 引擎名称默认取 `engine.name` 可以设置此项改名，可用于多模块切换
+     */
+    engineName?: string;
+}
+export interface TemplateOption {
+    /**
+     * 指定模版名，不指定取 `ctx.path`
+     */
+    template?: string;
+    /**
+     * 使用的渲染引擎
+     * - 对应的是 `TemplateSetupOption.engineName`
+     */
+    engine?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="debug" />
+export declare const debug: import("debug").Debugger;
+export declare function cwdPath(p: string): string;

package/dist/utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cwdPath = exports.debug = void 0;
+const path = require("path");
+const debug_1 = require("debug");
+exports.debug = (0, debug_1.default)('zenweb:template');
+function cwdPath(p) {
+    if (p.startsWith('./')) {
+        return path.join(process.cwd(), p.slice(2));
+    }
+    return p;
+}
+exports.cwdPath = cwdPath;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@zenweb/template",
+  "version": "3.0.0",
+  "description": "zenweb template render module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./engine": "./dist/engine"
+  },
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "rimraf dist && tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "cd example && cross-env DEBUG=* ts-node app"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": {
+    "name": "YeFei",
+    "email": "316606233@qq.com"
+  },
+  "keywords": [
+    "zenweb",
+    "koa",
+    "template",
+    "nunjucks"
+  ],
+  "license": "MIT",
+  "homepage": "https://zenweb.node.ltd",
+  "devDependencies": {
+    "@types/nunjucks": "^3.2.1",
+    "cross-env": "^7.0.3",
+    "handlebars": "^4.7.7",
+    "nunjucks": "^3.2.3",
+    "rimraf": "^4.4.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.2",
+    "zenweb": "^3.18.0"
+  },
+  "dependencies": {
+    "debug": "^4.3.4"
+  }
+}