Source: decorator.js

  1. /**
  2.  * @module decorator
  3.  */
  5. import {isString, checkType, getFullDocPath} from "./utils.js";
  7. /**
  8.  * @description Layout decorator.
  9.  */
  10. class Decorator {
  11.   /**
  12.    * @param {Logger} logger
  13.    * @param {Compiler} compiler
  14.    * @return {Decorator}
  15.    */
  16.   constructor(logger, compiler) {
  17.     this.logger = logger;
  18.     this.compiler = compiler;
  19.     this._ = new Map();
  20.   }
  22.   /**
  23.    * @callback decorateCallback
  24.    * @param {Object} ctx
  25.    * @return {String}
  26.    */
  27.   /**
  28.    * @description Register a decorate function.
  29.    * @param {String} layout
  30.    * @param {decorateCallback|String} fn If string, will call Compiler on this
  31.    * filename while decorating.
  32.    * @param {Object} [ctx=null] Custom context if you want to pass something to
  33.    * this decorator. This is deprecated and you should use helper function with
  34.    * layout filter.
  35.    */
  36.   register(layout, fn, ctx = null) {
  37.     checkType(layout, "layout", "String");
  38.     checkType(fn, "fn", "Function", "String");
  39.     if (ctx != null) {
  40.       this.logger.warn("Hikaru suggests you to pass context for specific layouts by using helper function with layout filter because passing context while registering decorator function is deprecated!");
  41.     }
  42.     this._.set(layout, {layout, fn, ctx});
  43.   }
  45.   /**
  46.    * @description Unregister a decorate function.
  47.    * @param {String} layout
  48.    */
  49.   unregister(layout) {
  50.     checkType(layout, "layout", "String");
  51.     this._.delete(layout);
  52.   }
  54.   /**
  55.    * @description Decorate input file with layout.
  56.    * @param {File} file
  57.    * @return {String}
  58.    */
  59.   async decorate(file, ctx) {
  60.     const layout = this.getFileLayout(file);
  61.     if (layout != null) {
  62.       this.logger.debug(`Hikaru is decorating \`${
  63.         this.logger.cyan(getFullDocPath(file))
  64.       }\` with layout \`${
  65.         this.logger.blue(layout)
  66.       }\`...`);
  67.       const handler = this._.get(layout);
  68.       if (handler == null) {
  69.         throw new Error(`Decorator for \`${layout}\` is not registered.`);
  70.       }
  71.       let fn = handler["fn"];
  72.       if (isString(fn)) {
  73.         fn = await this.compiler.compile(handler["fn"]);
  74.       }
  75.       // We support two methods to access file properties, first the file
  76.       // properties will be merged with context properties, so you could
  77.       // directly access them via property names, and then you could also access
  78.       // file properties via `file` object, this is recommended because it is
  79.       // easier to prevent the single `file` property name from conflicting and
  80.       // it is always accessible.
  81.       return fn(Object.assign(file, handler["ctx"], ctx, {"file": file}));
  82.     }
  83.     return file["content"];
  84.   }
  86.   /**
  87.    * @description List registered layout.
  88.    * @return {String[]}
  89.    */
  90.   list() {
  91.     return [...this._.keys()];
  92.   }
  94.   /**
  95.    * @private
  96.    * @description Get simpified layout for file.
  97.    * @param {File} file
  98.    * @return {String}
  99.    */
  100.   getFileLayout(file) {
  101.     if (file["layout"] == null) {
  102.       return null;
  103.     }
  104.     if (!this._.has(file["layout"])) {
  105.       return "page";
  106.     }
  107.     return file["layout"];
  108.   }
  109. }
  111. export default Decorator;