@tsed/engines 8.11.0 → 8.11.2-rc.1

package/src/registries/EnginesContainer.ts

@@ -1,37 +0,0 @@
-import {Engine, ViewEngineOptions} from "../components/Engine.js";
-
-export interface EngineProvider {
-  name: string;
-  useClass: typeof Engine;
-  instance?: Engine;
-  options: ViewEngineOptions;
-}
-
-export class EnginesContainer {
-  #providers: Map<string | typeof Engine, EngineProvider> = new Map();
-
-  has(key: string | typeof Engine) {
-    return this.#providers.has(key);
-  }
-
-  get(key: string | typeof Engine) {
-    const provider = this.#providers.get(key);
-
-    if (provider && !provider.instance) {
-      provider.instance = new provider.useClass(provider.name, provider.options);
-    }
-
-    return provider?.instance;
-  }
-
-  set(key: typeof Engine, provider: EngineProvider) {
-    this.#providers.set(key, provider);
-    this.#providers.set(provider.name, provider);
-  }
-
-  getSupportedEngines(): string[] {
-    return [...this.#providers.keys()].filter((key) => typeof key === "string") as string[];
-  }
-}
-
-export const engines = new EnginesContainer();

package/src/utils/cache.spec.ts

@@ -1,13 +0,0 @@
-import {clearCache, getFromCache, setToCache} from "./cache.js";
-
-describe("cache", () => {
-  describe("setToCache()", () => {
-    it("should set result to cache", () => {
-      setToCache("key", "value");
-      expect(getFromCache("key")).toEqual("value");
-
-      clearCache();
-      expect(getFromCache("key")).toEqual(undefined);
-    });
-  });
-});

package/src/utils/cache.ts

@@ -1,153 +0,0 @@
-import fs from "node:fs";
-import {readFile} from "node:fs/promises";
-import {dirname, extname, isAbsolute, join} from "node:path";
-
-const readCache: Map<string, string> = new Map();
-const cacheStore: Map<string, any> = new Map();
-
-export const requires: Map<string, any> = new Map();
-
-export function getCachedEngine(name: string, toName: string = name) {
-  const mdl = requires.get(toName) || {};
-
-  return mdl.default || mdl;
-}
-
-export async function importEngine(name: string, toName: string = name) {
-  if (!requires.has(toName)) {
-    await setEngine(name, toName);
-  }
-
-  return getCachedEngine(toName);
-}
-
-export async function setEngine(name: string, toName: string = name) {
-  const mdl = await import(name);
-
-  requires.set(toName, mdl);
-}
-
-export function setToCache(key: string, value: any) {
-  readCache.set(key, value);
-}
-
-export function getFromCache(key: string) {
-  return readCache.get(key);
-}
-
-/**
- * Clear the cache.
- *
- * @api public
- */
-
-export const clearCache = () => {
-  readCache.clear();
-  cacheStore.clear();
-};
-
-/**
- * Conditionally cache `compiled` template based
- * on the `options` filename and `.cache` boolean.
- *
- * @param {Object} options
- * @param {Function} compiled
- * @return {Function}
- */
-export function cache(options: any, compiled?: any) {
-  // cachable
-  if (compiled && options.filename && options.cache) {
-    readCache.delete(options.filename);
-    cacheStore.set(options.filename, compiled);
-    return compiled;
-  }
-
-  // check cache
-  if (options.filename && options.cache) {
-    return cacheStore.get(options.filename);
-  }
-
-  return compiled;
-}
-
-/**
- * Read `path` with `options` with
- * callback `(err, str)`. When `options.cache`
- * is true the template string will be cached.
- *
- * @param path
- * @param {String} options
- */
-export async function read(path: string, options: any): Promise<string> {
-  let str = readCache.get(path);
-
-  // cached (only if cached is a string and not a compiled template function)
-  if (options.cache && str && typeof str === "string") {
-    return str;
-  }
-
-  // read
-  str = await readFile(path, "utf8");
-
-  // remove extraneous utf8 BOM marker
-  str = str.replace(/^\uFEFF/, "");
-
-  if (options.cache) {
-    readCache.set(path, str);
-  }
-
-  return str;
-}
-
-/**
- * Read `path` with `options` with
- * callback `(err, str)`. When `options.cache`
- * is true the partial string will be cached.
- *
- * @param path
- * @param {String} options
- * @api private
- */
-export function readPartials(path: string, options: any): Promise<Record<string, string> | void> {
-  if (!options.partials) {
-    return Promise.resolve();
-  }
-
-  const keys = Object.keys(options.partials);
-  const partials: Record<string, string> = {};
-
-  return new Promise((resolve, reject) => {
-    async function next(index: number): Promise<any> {
-      if (index === keys.length) {
-        return resolve(partials);
-      }
-
-      const key = keys[index];
-      const partialPath = options.partials[key];
-
-      if (partialPath === undefined || partialPath === null || partialPath === false) {
-        return next(++index);
-      }
-
-      let file;
-      if (isAbsolute(partialPath)) {
-        if (extname(partialPath) !== "") {
-          file = partialPath;
-        } else {
-          file = join(partialPath + extname(path));
-        }
-      } else {
-        file = join(dirname(path), partialPath + extname(path));
-      }
-
-      try {
-        partials[key] = await read(file, options);
-        next(++index);
-      } catch (err) {
-        reject(err);
-      }
-    }
-
-    next(0);
-  });
-}

package/src/utils/getEngines.spec.ts

@@ -1,134 +0,0 @@
-import "../components/index.js";
-import "../index.js";
-
-import {join} from "node:path";
-
-import {getEngine, getEngines} from "./getEngines.js";
-
-const rootDir = import.meta.dirname; // automatically replaced by import.meta.dirname on build
-
-describe("getEngines", () => {
-  describe("getEngine()", () => {
-    describe("render file", () => {
-      it("should return a render function", async () => {
-        const render = getEngine("ejs");
-
-        const result = await new Promise((resolve, reject) => {
-          render(
-            join(rootDir, "../../test/fixtures/ejs/user.ejs"),
-            {
-              user: {
-                name: "Tobi"
-              }
-            },
-            (err, html) => {
-              err ? reject(err) : resolve(html);
-            }
-          );
-        });
-
-        expect(result).toEqual("<p>Tobi</p>");
-      });
-      it("should catch error", async () => {
-        const render = getEngine("ejs");
-
-        const error: any = await new Promise((resolve) => {
-          render(
-            join(rootDir, "../../test/fixtures/ejs/user2.ejs"),
-            {
-              user: {
-                name: "Tobi"
-              }
-            },
-            (err) => {
-              resolve(err);
-            }
-          );
-        });
-
-        expect(error.message).toContain("ENOENT: no such file or directory");
-      });
-    });
-    describe("render template", () => {
-      it("should return a render function", async () => {
-        const {render} = getEngine("ejs");
-
-        const result = await new Promise((resolve, reject) => {
-          render(
-            "<p><%= user.name %></p>",
-            {
-              user: {
-                name: "Tobi"
-              }
-            },
-            (err, html) => {
-              err ? reject(err) : resolve(html);
-            }
-          );
-        });
-
-        expect(result).toEqual("<p>Tobi</p>");
-      });
-      it("should catch error", async () => {
-        const {render} = getEngine("ejs");
-
-        const error: any = await new Promise((resolve) => {
-          render(
-            "<p><%= user.name></p>",
-            {
-              user: {
-                name: "Tobi"
-              }
-            },
-            (err) => {
-              resolve(err);
-            }
-          );
-        });
-
-        expect(error.message).toContain('Could not find matching close tag for "<%=".');
-      });
-    });
-  });
-  describe("getEngines()", () => {
-    it("should return engines", () => {
-      const engines = getEngines();
-      expect(Object.keys(engines)).toEqual([
-        "atpl",
-        "bracket",
-        "dot",
-        "dust",
-        "ect",
-        "ejs",
-        "haml-coffee",
-        "haml",
-        "hamlet",
-        "handlebars",
-        "hogan",
-        "htmling",
-        "jazz",
-        "jqtpl",
-        "just",
-        "liquor",
-        "lodash",
-        "mote",
-        "mustache",
-        "nunjucks",
-        "plates",
-        "pug",
-        "ractive",
-        "react",
-        "slm",
-        "squirrelly",
-        "swig",
-        "templayed",
-        "twig",
-        "twing",
-        "underscore",
-        "vash",
-        "velocityjs",
-        "walrus"
-      ]);
-    });
-  });
-});

package/src/utils/getEngines.ts

@@ -1,60 +0,0 @@
-import {pascalCase} from "pascal-case";
-
-import {EngineOptions} from "../components/Engine.js";
-import {engines} from "../registries/EnginesContainer.js";
-
-export type RenderCallback = (err: Error | null, str?: string | any) => any;
-export interface EngineFunction {
-  (path: string, options: any, cb: RenderCallback): void;
-  (path: string, options: any): Promise<string>;
-
-  render(template: string, options: any, cb: RenderCallback): void;
-  render(template: string, options: any): Promise<string>;
-}
-
-const callbackify = async (fn: any, cb?: RenderCallback) => {
-  try {
-    const html = await fn();
-    cb && cb(null, html);
-    return html;
-  } catch (er) {
-    if (cb) {
-      cb(er);
-    } else {
-      throw er;
-    }
-  }
-};
-
-export function getEngine(name: string): EngineFunction {
-  const cb = async (path: string, options: any, cb?: RenderCallback) => {
-    const engine = engines.get(name)!;
-    await engine.$onInit();
-
-    return callbackify(() => engine.renderFile(path, options), cb);
-  };
-
-  cb.render = async (template: string, options: EngineOptions, cb: RenderCallback) => {
-    const engine = engines.get(name)!;
-    await engine.$onInit();
-
-    return callbackify(() => engine.render(template, options), cb);
-  };
-
-  return cb as any;
-}
-
-let localEngines: any;
-
-export function getEngines(): Record<string, EngineFunction> {
-  localEngines =
-    localEngines ||
-    engines.getSupportedEngines().reduce((acc, key) => {
-      return {
-        ...acc,
-        [key]: getEngine(key)
-      };
-    }, {});
-
-  return localEngines;
-}

package/vitest.config.mts

@@ -1,21 +0,0 @@
-// @ts-ignore
-import {presets} from "@tsed/vitest/presets";
-import {defineConfig} from "vitest/config";
-
-export default defineConfig(
-  {
-    ...presets,
-    test: {
-      ...presets.test,
-      coverage: {
-        ...presets.test.coverage,
-        thresholds: {
-          statements: 0,
-          branches: 0,
-          functions: 0,
-          lines: 0
-        }
-      }
-    }
-  }
-);