@webdoc/template-library/lib/TemplateRenderer.js

Goodies for @webdoc template packages! See @webdoc/legacy-template for an example!

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.TemplateRenderer = void 0;
var _ = _interopRequireWildcard(require("lodash"));
var _Logger = require("./Logger");
var _SymbolLinks = require("./SymbolLinks");
var _fs = _interopRequireDefault(require("fs"));
var _model = require("@webdoc/model");
var _path = _interopRequireDefault(require("path"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
let printedDefaultLinker = false;

class TemplateRenderer {
  constructor(templateDir, docDatabase, docTree) {
    _defineProperty(this, "aliases", void 0);
    _defineProperty(this, "templateDir", void 0);
    _defineProperty(this, "docDatabase", void 0);
    _defineProperty(this, "docTree", void 0);
    _defineProperty(this, "layout", void 0);
    _defineProperty(this, "cache", void 0);
    _defineProperty(this, "data", void 0);
    _defineProperty(this, "settings", void 0);
    _defineProperty(this, "plugins", void 0);
    _defineProperty(this, "htmlText", (str) => {
      if (typeof str !== "string") {
        str = String(str);
      }
      return str.replace(/&/g, "&amp;").replace(/</g, "&lt;");
    });
    this.aliases = new Map();
    this.templateDir = templateDir;
    this.docDatabase = docDatabase;
    this.docTree = docTree;
    this.layout = null;

    this.data = {};
    this.cache = {};
    this.plugins = {};

    this.settings = {
      evaluate: /<\?js([\s\S]+?)\?>/g,
      interpolate: /<\?js=([\s\S]+?)\?>/g,
      escape: /<\?js~([\s\S]+?)\?>/g
    };
  }
  setGlobalTemplateData(data) {
    Object.assign(this.data, data);
    return this;
  }
  setLayoutTemplate(templateFile) {
    this.layout = templateFile;
    return this;
  }
  getPlugin(pluginName) {
    return this.plugins[pluginName];
  }

  installPlugin(name, plugin) {
    if (typeof plugin === "function") {
      this.plugins[name] = plugin;
      this.plugins[name].renderer = this;
      return this;
    }
    if (plugin.bindingPolicy === "complete") {
      this.plugins[name] = plugin;
      plugin.onBind(this);
    } else {
      this.plugins[name] = this.plugins[name] || {};
      Object.assign(this.plugins[name], plugin);
      this.plugins[name].renderer = this;
    }
    return this;
  }
  linkTo(...args) {
    if (!printedDefaultLinker) {
      console.warn("The default linker is the deprecated SymbolLinks API. " + "Upgrade to the LinkerPlugin!");
      printedDefaultLinker = true;

      this.linkTo = _SymbolLinks.SymbolLinks.linkTo;
    }
    return _SymbolLinks.SymbolLinks.linkTo(...args);
  }
  find(spec) {
    return this.docDatabase(spec).get();
  }

  alias(name, fpath) {
    if (typeof name === "object") {
      Object.keys(name).forEach(key => this.alias(key, name[key]));
    } else {
      if (typeof fpath !== "string") {
        throw new Error("Path to alias must be a string");
      }
      this.aliases.set(name, _path.default.resolve(process.cwd(), fpath));
    }
    return this;
  }

  load(filePath) {
    _Logger.templateLogger.info(_Logger.tag.TemplateLibrary, `Loading template ${filePath}`);
    try {
      return _.template(_fs.default.readFileSync(filePath, "utf8"), this.settings);
    } catch (e) {
      _Logger.templateLogger.error(_Logger.tag.TemplateLibrary, "Failure loading template " + filePath);
      console.error(e);
      throw e;
    }
  }

  partial(filePath, data) {
    if (this.aliases.has(filePath)) {
      filePath = (this.aliases.get(filePath));
    }
    filePath = _path.default.resolve(this.templateDir, filePath);

    if (!(filePath in this.cache)) {
      this.cache[filePath] = this.load(filePath);
    }

    _Logger.templateLogger.info(_Logger.tag.TemplateLibrary, `Partial() template ${filePath} ${data}`);
    let docHTML;
    try {
      docHTML = this.cache[filePath].call(this, data);
    } catch (e) {
      console.error(`Rendering template: ${filePath}`);
      console.error(this.cache[filePath].source.split("\n").map((line, i) => `${i}: ${line}`).join("\n"));
      throw e;
    }
    return docHTML;
  }

  render(filePath, data) {
    if (this.aliases.has(filePath)) {
      filePath = (this.aliases.get(filePath));
    }

    _Logger.templateLogger.info(_Logger.tag.TemplateLibrary, `Requested template ${filePath} ${data}`);
    let content = this.partial(filePath, data);
    _Logger.templateLogger.info(_Logger.tag.TemplateLibrary, `Rendering() template ${filePath} ${data}`);

    if (this.layout) {
      const templateData = Array.isArray(data) ? [...data] : {
        ...data
      };
      for (const key in this.data) {
        if (key in this.data) {
          templateData[key] = (0, _.merge)({}, this.data[key], templateData[key] || {});
        }
      }
      templateData.content = content;
      _Logger.templateLogger.info(_Logger.tag.TemplateLibrary, `Request layout ${filePath} ${data}`);
      content = this.partial(this.layout, templateData);
    }
    _Logger.templateLogger.info(_Logger.tag.TemplateLibrary, `Rendering2 template ${filePath} ${data}`);
    return content;
  }
  mangled(doc) {
    return (0, _model.mangled)(doc);
  }

  getNamespaces(doc, recursive = false, out) {
    return this.getMembers(doc, "NSDoc", recursive, out);
  }

  getClasses(doc, recursive = false, out) {
    return this.getMembers(doc, "ClassDoc", recursive, out);
  }

  getEnums(doc, recursive = false, out) {
    return this.getMembers(doc, "EnumDoc", recursive, out);
  }

  getMethods(doc, recursive = false, out) {

    if (!out) {
      out = [];
    }
    for (let i = 0; i < doc.members.length; i++) {
      if (doc.members[i].type === "MethodDoc" && doc.members[i].name !== "constructor" && doc.members[i].access !== "private") {
        out.push(doc.members[i]);
      }
    }
    if (recursive) {
      for (let i = 0; i < doc.members.length; i++) {
        if (doc.members[i].access !== "private") {
          this.getMethods(doc.members[i], true, out);
        }
      }
    }
    return out;
  }

  getFunctions(doc, recursive = false, out) {
    return this.getMembers(doc, "FunctionDoc", recursive, out);
  }

  getMethodLikes(doc, recursive = false, out) {
    if (!out) {
      out = [];
    }
    for (let i = 0; i < doc.members.length; i++) {
      const member = doc.members[i];
      if ((member.type === "FunctionDoc" || member.type === "MethodDoc") && doc.members[i].access !== "private" && doc.members[i].name !== "constructor") {
        out.push(doc.members[i]);
      }
    }
    if (recursive) {
      for (let i = 0; i < doc.members.length; i++) {
        if (doc.members[i].access !== "private") {
          this.getMethodLikes(doc.members[i], true, out);
        }
      }
    }
    return out;
  }

  getConstructor(doc) {
    return (doc.members.find(member => member.type === "MethodDoc" && member.name === "constructor"));
  }

  getEvents(doc, recursive = false, out) {
    return this.getMembers(doc, "EventDoc", recursive, out);
  }

  getProperties(doc, recursive = false, out) {
    return this.getMembers(doc, "PropertyDoc", recursive, out);
  }

  getTypedefs(doc, recursive = false, out) {
    return this.getMembers(doc, "TypedefDoc", recursive, out);
  }

  getMixins(doc, recursive = false, out) {
    return this.getMembers(doc, "MixinDoc", recursive, out);
  }

  getInterfaces(doc, recursive = false, out) {
    return this.getMembers(doc, "InterfaceDoc", recursive, out);
  }

  getMembers(doc, type, recursive = false, out) {
    if (!out) {
      out = [];
    }
    for (let i = 0; i < doc.members.length; i++) {
      if (doc.members[i].type === type && doc.members[i].access !== "private") {
        out.push(doc.members[i]);
      }
    }
    if (recursive) {
      for (let i = 0; i < doc.members.length; i++) {
        if (doc.members[i].access !== "private") {
          this.getMembers(doc, type, true, out);
        }
      }
    }
    return out;
  }
}
exports.TemplateRenderer = TemplateRenderer;