@tsed/engines 8.0.1 → 8.0.2

package/src/components/RactiveEngine.ts

@@ -0,0 +1,34 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine, EngineOptions} from "./Engine.js";
+
+@ViewEngine("ractive")
+export class RactiveEngine extends Engine {
+  protected $compile(template: string, options: EngineOptions) {
+    const Engine = this.engine;
+    const compile = this.engine.parse(template);
+    Engine.DEBUG = false;
+    return (options: EngineOptions) => {
+      options.template = compile;
+      return new Engine(this.clean(options)).toHTML();
+    };
+  }
+
+  protected clean(options: any) {
+    if (options.data === null || options.data === undefined) {
+      // Shallow clone the options object
+      options.data = Object.assign({}, options);
+
+      // Remove consolidate-specific properties from the clone
+      let i;
+      let length;
+      let properties = ["template", "filename", "cache", "partials"];
+
+      for (i = 0, length = properties.length; i < length; i++) {
+        const property = properties[i];
+        delete options.data[property];
+      }
+    }
+
+    return options;
+  }
+}

package/src/components/ReactEngine.ts

@@ -0,0 +1,163 @@
+import {readFileSync} from "fs";
+import {resolve} from "path";
+
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {getCachedEngine, getFromCache, importEngine, setToCache} from "../utils/cache.js";
+import {Engine, EngineOptions, ViewEngineOptions} from "./Engine.js";
+
+@ViewEngine("react", {
+  requires: ["react"]
+})
+export class ReactEngine extends Engine {
+  constructor(name: string, options: ViewEngineOptions) {
+    super(name, options);
+    this.patchRequire();
+  }
+
+  async $onInit() {
+    await super.$onInit();
+    await importEngine("react-dom/server", "ReactDOM");
+    await importEngine("@babel/core", "babel");
+  }
+
+  get babel() {
+    return getCachedEngine("babel");
+  }
+
+  get reactDOM() {
+    return getCachedEngine("ReactDOM");
+  }
+
+  protected patchRequire() {
+    if (require.extensions) {
+      // Ensure JSX is transformed on require
+      if (!require.extensions[".jsx"]) {
+        require.extensions[".jsx"] = this.requireReact.bind(this);
+      }
+
+      // Supporting .react extension as well as test cases
+      // Using .react extension is not recommended.
+      if (!require.extensions[".react"]) {
+        require.extensions[".react"] = this.requireReact.bind(this);
+      }
+    }
+  }
+
+  protected configure(options: EngineOptions) {
+    const base = options.base;
+    delete options.base;
+
+    const enableCache = options.cache;
+    delete options.cache;
+
+    const isNonStatic = options.isNonStatic;
+    delete options.isNonStatic;
+    return {base, enableCache, isNonStatic};
+  }
+
+  protected $compile(template: string, options: EngineOptions) {
+    // Assign HTML Base
+    const {base, enableCache, isNonStatic} = this.configure(options);
+
+    // Start Conversion
+    const Code = this.requireReactString(template);
+    const Factory = this.engine.createFactory(Code);
+
+    return () => {
+      const parsed = new Factory(options);
+      const content = isNonStatic ? this.reactDOM.renderToString(parsed) : this.reactDOM.renderToStaticMarkup(parsed);
+
+      if (base) {
+        options.content = content;
+
+        return this.renderWithBase(template, base, enableCache, options);
+      }
+
+      return content;
+    };
+  }
+
+  protected async $compileFile(file: string, options: EngineOptions) {
+    // Assign HTML Base
+    const {base, enableCache, isNonStatic} = this.configure(options);
+
+    let path = resolve(file);
+    delete require.cache[path];
+
+    const ReactDOM = await importEngine("react-dom/server", "ReactDOM");
+
+    const {default: Code} = await import(path);
+    const Factory = this.engine.createFactory(Code);
+
+    return () => {
+      const parsed = new Factory(options);
+      const content = isNonStatic ? ReactDOM.renderToString(parsed) : ReactDOM.renderToStaticMarkup(parsed);
+
+      if (base) {
+        options.content = content;
+
+        return this.renderWithBase(file, base, enableCache, options);
+      }
+
+      return content;
+    };
+  }
+
+  protected renderWithBase(key: string, base: any, enableCache: undefined | boolean, options: EngineOptions) {
+    const baseStr = getFromCache(key) || readFileSync(resolve(base), "utf8");
+
+    if (enableCache) {
+      setToCache(key, baseStr);
+    }
+
+    return this.reactBaseTmpl(baseStr, options);
+  }
+
+  protected transformFileSync(filename: string) {
+    return this.babel.transformFileSync(filename, {presets: ["@babel/preset-react"]}).code;
+  }
+
+  protected transform(src: string) {
+    return this.babel.transform(src, {presets: ["@babel/preset-react"]}).code;
+  }
+
+  protected requireReact(module: any, filename: string) {
+    const compiled = this.transformFileSync(filename);
+    return module._compile(compiled, filename);
+  }
+
+  protected requireReactString(src: string, filename?: string) {
+    if (!filename) filename = "";
+    // @ts-ignore
+    const m = new module.constructor();
+    filename = filename || "";
+
+    // Compile Using React
+    const compiled = this.transform(src);
+
+    // Compile as a module
+    m.paths = module.paths;
+    m._compile(compiled, filename);
+
+    return m.exports;
+  }
+
+  protected reactBaseTmpl(data: any, options: any) {
+    let exp: any;
+    let regex: any;
+
+    // Iterates through the keys in file object
+    // and interpolate / replace {{key}} with it's value
+    for (const k in options) {
+      if (options.hasOwnProperty(k)) {
+        exp = `{{${k}}}`;
+        regex = new RegExp(exp, "g");
+        if (data.match(regex)) {
+          data = data.replace(regex, options[k]);
+        }
+      }
+    }
+
+    return data;
+  }
+}

package/src/components/SlmEngine.ts

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

package/src/components/SquirrellyEngine.spec.ts

@@ -0,0 +1,98 @@
+import {join} from "path";
+
+import {getEngineFixture} from "../../test/getEngineFixture.js";
+import {requires} from "../utils/cache.js";
+import {SquirrellyEngine} from "./SquirrellyEngine.js";
+
+describe("SquirrellyEngine", () => {
+  it("should render the given content (by string - no cache)", async () => {
+    const {render, locals, $compile, template} = await getEngineFixture({token: SquirrellyEngine});
+    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: SquirrellyEngine, 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: SquirrellyEngine});
+    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: SquirrellyEngine,
+      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
+    });
+  });
+
+  // Use case: return safe HTML that won’t be escaped in the final render.
+  it("should support helpers", async () => {
+    const Sqrl = requires.get("squirrelly");
+    const user = {name: "<strong>Tobi</strong>"};
+
+    Sqrl.defineHelper("myhelper", (args: string[], content: any, blocks: any) => {
+      return args[0].slice(1, -1);
+    });
+
+    const {render} = await getEngineFixture({token: SquirrellyEngine, templateName: "helpers"});
+
+    const html = await render({user: user});
+    expect(html).toEqual("strong>Tobi</strong");
+  });
+
+  // partials
+  it("should support partials", async () => {
+    const {renderFile} = await getEngineFixture({token: SquirrellyEngine, 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: SquirrellyEngine, 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: SquirrellyEngine, templateName: "partials"});
+
+    const locals = {partials: {partial: `../${name}/user`}};
+    const html = await renderFile(locals);
+    expect(html).toEqual("<p>Tobi</p>");
+  });
+});

package/src/components/SquirrellyEngine.ts

@@ -0,0 +1,18 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine, EngineOptions} from "./Engine.js";
+
+@ViewEngine("squirrelly")
+export class SquirrellyEngine extends Engine {
+  protected $compile(template: string, options: EngineOptions) {
+    for (const partial in options.partials) {
+      this.engine.definePartial(partial, options.partials[partial]);
+    }
+    for (const helper in options.helpers) {
+      this.engine.defineHelper(helper, options.helpers[helper]);
+    }
+
+    const compile = this.engine.Compile(template, options);
+
+    return (options: EngineOptions) => compile(options, this.engine);
+  }
+}

package/src/components/SwigEngine.ts

@@ -0,0 +1,14 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("swig", {
+  requires: ["swig", "swig-templates"]
+})
+export class SwigEngine extends Engine {
+  protected $compile(template: string, options: any): (options: any) => Promise<string> {
+    if (options.cache === true) options.cache = "memory";
+    this.engine.setDefaults({cache: options.cache});
+
+    return this.engine.compile(template, options);
+  }
+}

package/src/components/TemplayedEngine.ts

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

package/src/components/TwigEngine.spec.ts

@@ -0,0 +1,44 @@
+import {getEngineFixture} from "../../test/getEngineFixture.js";
+import {TwigEngine} from "./TwigEngine.js";
+
+describe("TwigEngine", () => {
+  it("should render the given content (by string - no cache)", async () => {
+    const {render, $compile, template} = await getEngineFixture({token: TwigEngine});
+    await render();
+
+    expect(await render()).toEqual("<p>Tobi</p>");
+    expect($compile()).toHaveBeenCalledTimes(2);
+    expect($compile()).toHaveBeenCalledWith(template, {
+      allowInlineIncludes: undefined,
+      cache: false,
+      data: "<p>{{ user.name }}</p>",
+      namespaces: undefined,
+      path: undefined,
+      user: {name: "Tobi"}
+    });
+  });
+  it("should render the given content (by string - with cache)", async () => {
+    const {render, $compile} = await getEngineFixture({token: TwigEngine, 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, path} = await getEngineFixture({token: TwigEngine});
+    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: TwigEngine, cache: true});
+
+    await renderFile();
+    const content = await renderFile();
+
+    expect(content).toEqual("<p>Tobi</p>");
+    expect($compileFile()).toHaveBeenCalledTimes(1);
+  });
+});

package/src/components/TwigEngine.ts

@@ -0,0 +1,24 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine, EngineOptions} from "./Engine.js";
+
+@ViewEngine("twig")
+export class TwigEngine extends Engine {
+  protected $cacheOptions(template: string, options: any) {
+    return {
+      ...options,
+      data: template,
+      allowInlineIncludes: options.allowInlineIncludes,
+      namespaces: options.namespaces,
+      path: options.path
+    };
+  }
+
+  protected $compile(template: string, options: EngineOptions) {
+    const {twig: engine} = this.engine;
+    options.data = template;
+
+    const compile = engine(options);
+
+    return (options: EngineOptions) => compile.render(options);
+  }
+}

package/src/components/TwingEngine.spec.ts

@@ -0,0 +1,36 @@
+import {getEngineFixture} from "../../test/getEngineFixture.js";
+import {TwingEngine} from "./TwingEngine.js";
+
+describe("TwingEngine", () => {
+  it("should render the given content (by string - no cache)", async () => {
+    const {render, $compile} = await getEngineFixture({token: TwingEngine});
+    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} = await getEngineFixture({token: TwingEngine, 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: TwingEngine});
+    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, path} = await getEngineFixture({token: TwingEngine, cache: true});
+
+    await renderFile();
+    const content = await renderFile();
+
+    expect(content).toEqual("<p>Tobi</p>");
+    expect($compileFile()).toHaveBeenCalledTimes(1);
+  });
+});

package/src/components/TwingEngine.ts

@@ -0,0 +1,31 @@
+import {existsSync} from "fs";
+
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("twing")
+export class TwingEngine extends Engine {
+  private instance: any;
+
+  protected $compile(template: string, options: any): (options: any) => Promise<string> {
+    const engine = this.engine;
+
+    if (!this.instance) {
+      let loader = new engine.TwingLoaderNull();
+
+      if (options.settings && options.settings.views && existsSync(options.settings.views)) {
+        loader = new engine.TwingLoaderFilesystem(options.settings.views);
+      }
+
+      this.instance = new engine.TwingEnvironment(loader);
+    }
+
+    const $cmp = this.instance.createTemplate(template);
+
+    return async (options: any) => {
+      const compile = await $cmp;
+
+      return compile.render(options);
+    };
+  }
+}

package/src/components/UnderscoreEngine.ts

@@ -0,0 +1,26 @@
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("underscore")
+export class UnderscoreEngine extends Engine {
+  async render(template: string, options: any) {
+    const tpl: string = await this.compile(template, options)(options);
+    return tpl.replace(/\n$/, "");
+  }
+
+  protected $cacheOptions(template: string, options: any): any {
+    const partials: any = {};
+
+    for (const partial in options.partials) {
+      partials[partial] = this.engine.template(options.partials[partial]);
+    }
+
+    options.partials = partials;
+
+    return options;
+  }
+
+  protected $compile(template: string, options: any): (options: any) => Promise<string> {
+    return this.engine.template(template, null, options);
+  }
+}

package/src/components/VashEngine.ts

@@ -0,0 +1,33 @@
+import {promisify} from "util";
+
+import {ViewEngine} from "../decorators/viewEngine.js";
+import {Engine} from "./Engine.js";
+
+@ViewEngine("vash")
+export class VashEngine extends Engine {
+  compile(template: string, options: any): (options: any) => Promise<string> {
+    if (options.helpers) {
+      for (const key in options.helpers) {
+        if (!options.helpers.hasOwnProperty(key) || typeof options.helpers[key] !== "function") {
+          continue;
+        }
+        this.engine.helpers[key] = options.helpers[key];
+      }
+    }
+
+    const compile = promisify(this.engine.compile(template, options));
+
+    return async (options: any) => {
+      const ctx = await compile(options);
+      ctx.finishLayout();
+      return ctx.toString();
+    };
+  }
+
+  async render(template: string, options: any) {
+    const compile = this.compile(template, options);
+
+    const tpl = await compile(options);
+    return tpl.replace(/\n$/, "");
+  }
+}

package/src/components/VelocityEngine.spec.ts

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

package/src/components/VelocityEngine.ts

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

package/src/components/WalrusEngine.ts

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

package/src/decorators/viewEngine.ts

@@ -0,0 +1,8 @@
+import {ViewEngineOptions} from "../components/Engine.js";
+import {engines} from "../registries/EnginesContainer.js";
+
+export function ViewEngine(name: string, options: ViewEngineOptions = {}): ClassDecorator {
+  return (target: any) => {
+    engines.set(target, {name, useClass: target, options});
+  };
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./components/AtplEngine.js";
+export * from "./components/BracketEngine.js";
+export * from "./components/DotEngine.js";
+export * from "./components/DustEngine.js";
+export * from "./components/EctEngine.js";
+export * from "./components/EjsEngine.js";
+export * from "./components/Engine.js";
+export * from "./components/HamlCoffeeEngine.js";
+export * from "./components/HamlEngine.js";
+export * from "./components/HamletEngine.js";
+export * from "./components/HandlebarsEngine.js";
+export * from "./components/HoganEngine.js";
+export * from "./components/HtmlingEngine.js";
+export * from "./components/JazzEngine.js";
+export * from "./components/JqtplEngine.js";
+export * from "./components/JustEngine.js";
+export * from "./components/LiquorEngine.js";
+export * from "./components/LodashEngine.js";
+export * from "./components/MoteEngine.js";
+export * from "./components/MustacheEngine.js";
+export * from "./components/NunjucksEngine.js";
+export * from "./components/PlatesEngine.js";
+export * from "./components/PugEngine.js";
+export * from "./components/RactiveEngine.js";
+export * from "./components/ReactEngine.js";
+export * from "./components/SlmEngine.js";
+export * from "./components/SquirrellyEngine.js";
+export * from "./components/SwigEngine.js";
+export * from "./components/TemplayedEngine.js";
+export * from "./components/TwigEngine.js";
+export * from "./components/TwingEngine.js";
+export * from "./components/UnderscoreEngine.js";
+export * from "./components/VashEngine.js";
+export * from "./components/VelocityEngine.js";
+export * from "./components/WalrusEngine.js";
+export * from "./decorators/viewEngine.js";
+export * from "./registries/EnginesContainer.js";
+export * from "./utils/cache.js";
+export * from "./utils/getEngines.js";