@tsed/engines 8.0.0 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/engines",
   "description": "Template engines library. Provide an API to adding custom engines from decorators.",
   "type": "module",
-  "version": "8.0.0",
+  "version": "8.0.2",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -29,8 +30,8 @@
     "@babel/plugin-transform-runtime": "7.25.7",
     "@babel/preset-env": "7.25.7",
     "@babel/preset-react": "7.25.7",
-    "@tsed/barrels": "8.0.0",
-    "@tsed/typescript": "8.0.0",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "@types/semver": "^7.5.8",
     "atpl": "0.9.3",
     "bracket-template": "^1.1.5",

package/src/components/AtplEngine.ts

@@ -0,0 +1,5 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("atpl")
+export class AtplEngine extends Engine {}

package/src/components/BracketEngine.ts

@@ -0,0 +1,11 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("bracket", {
+  requires: "bracket-template"
+})
+export class BracketEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    return this.engine.compile(template, options);
+  }
+}

package/src/components/DotEngine.ts

@@ -0,0 +1,14 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("dot")
+export class DotEngine extends Engine {
+  getSettings(options: any) {
+    const settings = Object.assign({}, this.engine.templateSettings);
+    return Object.assign(settings, options ? options.dot : {});
+  }
+
+  protected $compile(template: string, options: any) {
+    return this.engine.template(template, this.getSettings(options), options);
+  }
+}

package/src/components/DustEngine.ts

@@ -0,0 +1,55 @@
+import {extname} from "path";
+import {promisify} from "util";
+
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {read} from "../utils/cache.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("dust", {
+  requires: ["dustjs-helpers", "dustjs-linkedin"]
+})
+export class DustEngine extends Engine {
+  private views = ".";
+  private ext = "dust";
+
+  configure(options: any) {
+    if (options) {
+      if (options.ext) {
+        this.ext = options.ext;
+      }
+      if (options.views) {
+        this.views = options.views;
+      }
+      if (options.settings && options.settings.views) {
+        this.views = options.settings.views;
+      }
+    }
+    if (!options || (options && !options.cache)) this.engine.cache = {};
+
+    this.engine.onLoad = async (path: string, callback: any) => {
+      if (extname(path) === "") {
+        path += `.${this.ext}`;
+      }
+      if (path[0] !== "/") {
+        path = `${this.views}/${path}`;
+      }
+      try {
+        callback(null, await read(path, options));
+      } catch (er) {
+        callback(er);
+      }
+    };
+  }
+
+  protected $compile(template: string, options: any) {
+    this.configure(options);
+
+    let templateName;
+
+    if (options.filename) {
+      templateName = options.filename.replace(new RegExp("^" + this.views + "/"), "").replace(new RegExp("\\." + this.ext), "");
+    }
+
+    return promisify(this.engine.compileFn(template, templateName)) as any;
+  }
+}

package/src/components/EctEngine.ts

@@ -0,0 +1,24 @@
+import {promisify} from "util";
+
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("ect")
+export class EctEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    const ECT = this.engine;
+    const engine = new ECT({root: {page: template}});
+    const compile = promisify(engine.render.bind(engine));
+
+    return (options: any) => compile("page", options);
+  }
+
+  protected $compileFile(file: string, options: any): Promise<(options: any) => any> {
+    const ECT = this.engine;
+    const engine = new ECT(options);
+    engine.configure({cache: options.cache});
+    const compile = promisify(engine.render.bind(engine));
+
+    return Promise.resolve((options: any) => compile(file, options));
+  }
+}

package/src/components/EjsEngine.ts

@@ -0,0 +1,5 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("ejs")
+export class EjsEngine extends Engine {}

package/src/components/Engine.ts

@@ -0,0 +1,87 @@
+import {cache, getCachedEngine, importEngine, read, readPartials} from "../utils/cache.js";
+
+export interface ViewEngineOptions {
+  requires?: string | string[];
+}
+
+export interface EngineOptions {
+  cache?: boolean;
+
+  [otherOptions: string]: any;
+}
+
+export class Engine {
+  protected driverName: string;
+
+  constructor(
+    readonly name: string,
+    readonly options: ViewEngineOptions
+  ) {}
+
+  get engine(): any {
+    return getCachedEngine(this.name);
+  }
+
+  async $onInit() {
+    await this.importEngine(this.name, this.options);
+  }
+
+  compile(template: string, options: EngineOptions) {
+    options = this.$cacheOptions(template, options, false);
+
+    return cache(options) || cache(options, this.$compile.call(this, template, options));
+  }
+
+  compileFile(file: string, options: EngineOptions) {
+    options = this.$cacheOptions(file, options, true);
+
+    return cache(options) || cache(options, this.$compileFile.call(this, file, options));
+  }
+
+  async render(template: string, options: EngineOptions) {
+    const compile = await this.compile(template, options);
+
+    return compile(options);
+  }
+
+  async renderFile(file: string, options: EngineOptions) {
+    const opts = await this.readPartials(file, options);
+    const compile = await this.compileFile(file, opts);
+
+    return compile(opts);
+  }
+
+  protected async readPartials(file: string, options: EngineOptions) {
+    options.filename = file;
+    const partials = await readPartials(file, options);
+
+    const opts = Object.assign({}, options);
+    opts.partials = partials;
+
+    return opts;
+  }
+
+  protected $cacheOptions(template: string, options: EngineOptions, fromFile?: boolean) {
+    return options;
+  }
+
+  protected $compile(template: string, options: EngineOptions): (options: EngineOptions) => Promise<string> {
+    return this.engine.compile(template, options);
+  }
+
+  protected async $compileFile(file: string, options: EngineOptions) {
+    const template = await read(file, options);
+    return this.$compile(template, options);
+  }
+
+  protected async importEngine(name: string, options: ViewEngineOptions) {
+    const reqs = ([] as string[]).concat(options.requires || [name]);
+
+    for (const req of reqs) {
+      try {
+        await importEngine(req, name);
+        this.driverName = req;
+      } catch (er) {}
+    }
+  }
+}

package/src/components/HamlCoffeeEngine.ts

@@ -0,0 +1,5 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("haml-coffee")
+export class HamlCoffeeEngine extends Engine {}

package/src/components/HamlEngine.ts

@@ -0,0 +1,12 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("haml")
+export class HamlEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    return (options: any) => {
+      options.locals = options;
+      return Promise.resolve(this.engine.render(template, options).trimLeft());
+    };
+  }
+}

package/src/components/HamletEngine.ts

@@ -0,0 +1,12 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("hamlet")
+export class HamletEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    return (options: any) => {
+      options.locals = options;
+      return Promise.resolve(this.engine.render(template, options).trimLeft());
+    };
+  }
+}

package/src/components/HandlebarsEngine.ts

@@ -0,0 +1,19 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("handlebars")
+export class HandlebarsEngine extends Engine {
+  protected configure(options: any) {
+    for (const partial in options.partials) {
+      this.engine.registerPartial(partial, options.partials[partial]);
+    }
+    for (const helper in options.helpers) {
+      this.engine.registerHelper(helper, options.helpers[helper]);
+    }
+  }
+
+  protected $compile(template: string, options: any) {
+    this.configure(options);
+    return this.engine.compile(template, options);
+  }
+}

package/src/components/HoganEngine.spec.ts

@@ -0,0 +1,79 @@
+import {join} from "path";
+
+import {getEngineFixture} from "../../test/getEngineFixture.js";
+import {HoganEngine} from "./HoganEngine.js";
+
+describe("HoganEngine", () => {
+  it("should render the given content (by string - no cache)", async () => {
+    const {render, locals, $compile, template} = await getEngineFixture({token: HoganEngine});
+    await render();
+
+    expect(await render()).toEqual("<p>Tobi</p>");
+    expect($compile()).toHaveBeenCalledTimes(2);
+    expect($compile()).toHaveBeenCalledWith(template, {...locals, cache: false});
+  });
+  it("should render the given content (by string - with cache)", async () => {
+    const {render, locals, $compile, template} = await getEngineFixture({token: HoganEngine, cache: true});
+    await render();
+
+    expect(await render()).toEqual("<p>Tobi</p>");
+    expect($compile()).toHaveBeenCalledTimes(2);
+    expect($compile()).toHaveBeenCalledWith(template, {...locals, cache: true});
+  });
+  it("should render the given content (by file - no cache)", async () => {
+    const {renderFile, locals, $compile, path, template} = await getEngineFixture({token: HoganEngine});
+    await renderFile();
+    const content = await renderFile();
+
+    expect(content).toEqual("<p>Tobi</p>");
+    expect($compile()).toHaveBeenCalledTimes(2);
+    expect($compile()).toHaveBeenCalledWith(template, {
+      ...locals,
+      partials: undefined,
+      filename: path,
+      cache: false
+    });
+  });
+  it("should render the given content (by file - with cache)", async () => {
+    const {renderFile, locals, $compile, path, template} = await getEngineFixture({token: HoganEngine, cache: true});
+
+    await renderFile();
+    const content = await renderFile();
+
+    expect(content).toEqual("<p>Tobi</p>");
+    expect($compile()).toHaveBeenCalledTimes(1);
+    expect($compile()).toHaveBeenCalledWith(template, {
+      ...locals,
+      partials: undefined,
+      filename: path,
+      cache: true
+    });
+  });
+
+  // partials
+  it("should support partials", async () => {
+    const {renderFile} = await getEngineFixture({token: HoganEngine, templateName: "partials"});
+    const locals = {
+      partials: {
+        partial: "user"
+      }
+    };
+    const html = await renderFile(locals);
+
+    expect(html).toEqual("<p>Tobi</p>");
+  });
+  it("should support absolute path partial", async () => {
+    const {renderFile, rootDir, name} = await getEngineFixture({token: HoganEngine, templateName: "partials"});
+    const locals = {partials: {partial: join(rootDir, "fixtures", name, "user")}};
+    const html = await renderFile(locals);
+
+    expect(html).toEqual("<p>Tobi</p>");
+  });
+  it("should support relative path partial", async () => {
+    const {renderFile, name} = await getEngineFixture({token: HoganEngine, templateName: "partials"});
+
+    const locals = {partials: {partial: `../${name}/user`}};
+    const html = await renderFile(locals);
+    expect(html).toEqual("<p>Tobi</p>");
+  });
+});

package/src/components/HoganEngine.ts

@@ -0,0 +1,14 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine, EngineOptions} from "./Engine.js";
+
+@ViewEngine("hogan", {
+  requires: "hogan.js"
+})
+export class HoganEngine extends Engine {
+  protected $compile(template: string, options: EngineOptions) {
+    const compile = this.engine.compile(template, options);
+    return (options: EngineOptions) => {
+      return compile.render(options, options.partials);
+    };
+  }
+}

package/src/components/HtmlingEngine.ts

@@ -0,0 +1,11 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("htmling")
+export class HtmlingEngine extends Engine {
+  protected $compile(template: string) {
+    const compile = this.engine.string(template);
+
+    return (options: any) => compile.render(options);
+  }
+}

package/src/components/JazzEngine.ts

@@ -0,0 +1,10 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("jazz")
+export class JazzEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    const compile = this.engine.compile(template, options);
+    return (options: any) => new Promise<string>((resolve) => compile.eval(options, resolve));
+  }
+}

package/src/components/JqtplEngine.ts

@@ -0,0 +1,10 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("jqtpl")
+export class JqtplEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    this.engine.template(template, template);
+    return (options: any) => this.engine.tmpl(template, options);
+  }
+}

package/src/components/JustEngine.ts

@@ -0,0 +1,24 @@
+import {promisify} from "util";
+
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("just")
+export class JustEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    const JUST = this.engine;
+    const engine = new JUST({root: {page: template}});
+    const compile = promisify(engine.render.bind(engine));
+
+    return (options: any) => compile("page", options);
+  }
+
+  protected $compileFile(file: string, options: any) {
+    const JUST = this.engine;
+    const engine = new JUST(options);
+    engine.configure({useCache: options.cache});
+    const compile = promisify(engine.render.bind(engine));
+
+    return Promise.resolve((options: any) => compile(file, options));
+  }
+}

package/src/components/LiquorEngine.ts

@@ -0,0 +1,5 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("liquor")
+export class LiquorEngine extends Engine {}

package/src/components/LodashEngine.ts

@@ -0,0 +1,14 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("lodash")
+export class LodashEngine extends Engine {
+  render(template: string, options: any) {
+    const compile = this.compile(template, options);
+    return compile(options).replace(/\n$/, "");
+  }
+
+  protected $compile(template: string, options: any) {
+    return this.engine.template(template, options);
+  }
+}

package/src/components/MoteEngine.ts

@@ -0,0 +1,5 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("mote")
+export class MoteEngine extends Engine {}

package/src/components/MustacheEngine.ts

@@ -0,0 +1,9 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("mustache")
+export class MustacheEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    return (options: any) => this.engine.render(template, options, options.partials);
+  }
+}

package/src/components/NunjucksEngine.ts

@@ -0,0 +1,58 @@
+import {promisify} from "util";
+
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("nunjucks")
+export class NunjucksEngine extends Engine {
+  protected configure(options: any) {
+    const engine = options.nunjucksEnv || this.engine;
+    let env = engine;
+
+    // deprecated fallback support for express
+    // <https://github.com/tj/consolidate.js/pull/152>
+    // <https://github.com/tj/consolidate.js/pull/224>
+    if (options.settings && options.settings.views) {
+      env = engine.configure(options.settings.views);
+    } else if (options.nunjucks && options.nunjucks.configure) {
+      env = engine.configure.apply(engine, options.nunjucks.configure);
+    }
+
+    //
+    // because `renderString` does not initiate loaders
+    // we must manually create a loader for it based off
+    // either `options.settings.views` or `options.nunjucks` or `options.nunjucks.root`
+    //
+    // <https://github.com/mozilla/nunjucks/issues/730>
+    // <https://github.com/crocodilejs/node-email-templates/issues/182>
+    //
+
+    // so instead we simply check if we passed a custom loader
+    // otherwise we create a simple file based loader
+    if (options.loader) {
+      return new engine.Environment(options.loader);
+    }
+
+    if (options.settings && options.settings.views) {
+      return new engine.Environment(new engine.FileSystemLoader(options.settings.views));
+    }
+
+    if (options.nunjucks && options.nunjucks.loader) {
+      if (typeof options.nunjucks.loader === "string") {
+        return new engine.Environment(new engine.FileSystemLoader(options.nunjucks.loader));
+      }
+
+      return new engine.Environment(new engine.FileSystemLoader(options.nunjucks.loader[0], options.nunjucks.loader[1]));
+    }
+
+    return env;
+  }
+
+  protected $compile(template: string, options: any) {
+    let engine = this.configure(options);
+
+    const render = promisify(engine.renderString.bind(engine));
+
+    return (options: any) => render(template, options);
+  }
+}

package/src/components/PlatesEngine.ts

@@ -0,0 +1,12 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("plates")
+export class PlatesEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    return (options: any) => {
+      const map = options.map || undefined;
+      return this.engine.bind(template, options, map);
+    };
+  }
+}

package/src/components/PugEngine.spec.ts

@@ -0,0 +1,50 @@
+import {getEngineFixture} from "../../test/getEngineFixture.js";
+import {PugEngine} from "./PugEngine.js";
+
+describe("PugEngine", () => {
+  it("should render the given content (by string - no cache)", async () => {
+    const {render, locals, $compile, template} = await getEngineFixture({token: PugEngine});
+    await render();
+
+    expect(await render()).toEqual("<p>Tobi</p>");
+    expect($compile()).toHaveBeenCalledTimes(2);
+    expect($compile()).toHaveBeenCalledWith(template, {...locals, cache: false});
+  });
+  it("should render the given content (by string - with cache)", async () => {
+    const {render, locals, $compile, template} = await getEngineFixture({token: PugEngine, cache: true});
+    await render();
+
+    expect(await render()).toEqual("<p>Tobi</p>");
+    expect($compile()).toHaveBeenCalledTimes(2);
+    expect($compile()).toHaveBeenCalledWith(template, {...locals, cache: true});
+  });
+  it("should render the given content (by file - no cache)", async () => {
+    const {renderFile, locals, $compileFile, path} = await getEngineFixture({token: PugEngine});
+    await renderFile();
+    const content = await renderFile();
+
+    expect(content).toEqual("<p>Tobi</p>");
+    expect($compileFile()).toHaveBeenCalledTimes(2);
+    expect($compileFile()).toHaveBeenCalledWith(path, {
+      ...locals,
+      partials: undefined,
+      filename: path,
+      cache: false
+    });
+  });
+  it("should render the given content (by file - with cache)", async () => {
+    const {renderFile, locals, $compileFile, path} = await getEngineFixture({token: PugEngine, cache: true});
+
+    await renderFile();
+    const content = await renderFile();
+
+    expect(content).toEqual("<p>Tobi</p>");
+    expect($compileFile()).toHaveBeenCalledTimes(1);
+    expect($compileFile()).toHaveBeenCalledWith(path, {
+      ...locals,
+      partials: undefined,
+      filename: path,
+      cache: true
+    });
+  });
+});

package/src/components/PugEngine.ts

@@ -0,0 +1,15 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("pug", {
+  requires: ["pug", "then-pug"]
+})
+export class PugEngine extends Engine {
+  protected $compile(template: string, options: any) {
+    return this.engine.compile(template, options);
+  }
+
+  protected $compileFile(file: string, options: any) {
+    return this.engine.compileFile(file, options);
+  }
+}

package/src/components/RactiveEngine.spec.ts

@@ -0,0 +1,36 @@
+import {getEngineFixture} from "../../test/getEngineFixture.js";
+import {RactiveEngine} from "./RactiveEngine.js";
+
+describe("RactiveEngine", () => {
+  it("should render the given content (by string - no cache)", async () => {
+    const {render, locals, $compile, template} = await getEngineFixture({token: RactiveEngine});
+    await render();
+
+    expect(await render()).toEqual("<p>Tobi</p>");
+    expect($compile()).toHaveBeenCalledTimes(2);
+  });
+  it("should render the given content (by string - with cache)", async () => {
+    const {render, $compile, template} = await getEngineFixture({token: RactiveEngine, cache: true});
+    await render();
+
+    expect(await render()).toEqual("<p>Tobi</p>");
+    expect($compile()).toHaveBeenCalledTimes(2);
+  });
+  it("should render the given content (by file - no cache)", async () => {
+    const {renderFile, $compileFile} = await getEngineFixture({token: RactiveEngine});
+    await renderFile();
+    const content = await renderFile();
+
+    expect(content).toEqual("<p>Tobi</p>");
+    expect($compileFile()).toHaveBeenCalledTimes(2);
+  });
+  it("should render the given content (by file - with cache)", async () => {
+    const {renderFile, $compileFile} = await getEngineFixture({token: RactiveEngine, cache: true});
+
+    await renderFile();
+    const content = await renderFile();
+
+    expect(content).toEqual("<p>Tobi</p>");
+    expect($compileFile()).toHaveBeenCalledTimes(1);
+  });
+});