@comet-cli/plugin-documentation/dist/index.esm.js

Plugin for generating API documentation

/*!
 * @comet-cli/plugin-documentation v0.2.2
 * (c) Elisha Witte <elishawitte@gmail.com>
 * Released under the MIT License.
 */
import { ensureDir, writeFile, readFile } from 'fs-extra';
import { resolve, join } from 'path';

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

function _await(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var _require = require('vue-server-renderer'),
    createBundleRenderer = _require.createBundleRenderer;

function _invoke(body, then) {
  var result = body();

  if (result && result.then) {
    return result.then(then);
  }

  return then(result);
}

var webpack = require('webpack');

var DocumentationPlugin = /*#__PURE__*/function () {
  function DocumentationPlugin() {
    _classCallCheck(this, DocumentationPlugin);
  }

  _createClass(DocumentationPlugin, [{
    key: "execute",
    value: function execute(model, config, logger) {
      try {
        var _this2 = this;

        logger.spin('Compiling API documentation');
        var outputDir = resolve(config.output || './');
        return _await(_this2.getTemplate(config), function (template) {
          var serverBundle = require(resolve(__dirname, '../dist/vue-ssr-server-bundle.json'));

          var renderer = createBundleRenderer(serverBundle, {
            runInNewContext: false,
            template: template
          });

          var metaData = _this2.generateMetadata(config);

          var context = {
            model: model,
            config: config,
            title: _this2.getTitle(config, model),
            meta: metaData,
            styleTag: _this2.getStyleTag(config),
            jsTag: _this2.getJsTag(config)
          };
          return _await(renderer.renderToString(context), function (html) {
            return _await(ensureDir(outputDir), function () {
              return _await(writeFile(resolve(outputDir, 'index.html'), html), function () {
                return _await(_this2.bundleAssets(config), function (assets) {
                  return _await(ensureDir(join(outputDir, 'assets')), function () {
                    return _await(writeFile(join(outputDir, 'assets', 'style.css'), assets.css), function () {
                      return _await(writeFile(join(outputDir, 'assets', 'bundle.js'), assets.js), function () {
                        logger.succeed('API documentation compiled');
                      });
                    });
                  });
                });
              });
            });
          });
        });
      } catch (e) {
        return Promise.reject(e);
      }
    }
  }, {
    key: "name",
    value: function name() {
      return 'documentation';
    }
  }, {
    key: "compile",
    value: function compile(config) {
      return new Promise(function (resolve, reject) {
        webpack(config, function (error, stats) {
          if (error) {
            return reject(error);
          }

          if (stats.hasErrors()) {
            stats.toJson().errors.forEach(function (err) {
              console.error(err);
            });
            reject(new Error('Failed to compile with errors.'));
            return;
          }

          resolve(stats.toJson({
            modules: false
          }));
        });
      });
    }
  }, {
    key: "getTitle",
    value: function getTitle(config, model) {
      if (config.data && config.data.title) {
        return config.data.title;
      }

      if (model.info.name) {
        return model.info.name;
      }

      return 'API Reference';
    }
  }, {
    key: "getStyleTag",
    value: function getStyleTag(config) {
      if (config.data && config.data.asset_src) {
        var src = config.data.asset_src;
        var resolved = src !== '' && !src.endsWith('/') ? "".concat(src, "/") : src;
        return "<link rel=\"stylesheet\" href=\"".concat(resolved, "style.css\">");
      }

      return '<link rel="stylesheet" href="assets/style.css">';
    }
  }, {
    key: "getJsTag",
    value: function getJsTag(config) {
      if (config.data && config.data.asset_src) {
        var src = config.data.asset_src;
        var resolved = src !== '' && !src.endsWith('/') ? "".concat(src, "/") : src;
        return "<script src=\"".concat(resolved, "bundle.js\"></script>");
      }

      return '<script src="assets/bundle.js"></script>';
    }
  }, {
    key: "getTemplate",
    value: function getTemplate(config) {
      try {
        return _await(readFile(resolve(__dirname, './index.template.html'), 'utf-8'), function (template) {
          return _invoke(function () {
            if (config.template) {
              return _await(readFile(resolve(config.template), 'utf-8'), function (_readFile) {
                template = _readFile;
              });
            }
          }, function () {
            return template;
          });
        });
      } catch (e) {
        return Promise.reject(e);
      }
    }
  }, {
    key: "generateMetadata",
    value: function generateMetadata(config) {
      if (config.data && config.data.description) {
        return "\n      <meta name=\"description\" content=\"".concat(config.data.description, "\">\n      ");
      }

      return undefined;
    }
  }, {
    key: "bundleAssets",
    value: function bundleAssets(config) {
      try {
        return _await(readFile(resolve(__dirname, 'assets/dist/style.css'), 'utf-8'), function (cssBundle) {
          return _await(readFile(resolve(__dirname, 'assets/dist/bundle.js'), 'utf-8'), function (jsSource) {
            return _await(readFile(resolve(__dirname, '../dist/app.js'), 'utf-8'), function (jsBundle) {
              return _invoke(function () {
                if (config.css !== undefined) {
                  return _await(readFile(resolve(config.css), 'utf-8'), function (userCss) {
                    cssBundle += "\n".concat(userCss);
                  });
                }
              }, function () {
                return {
                  css: cssBundle,
                  js: "".concat(jsSource, "\n").concat(jsBundle)
                };
              });
            });
          });
        });
      } catch (e) {
        return Promise.reject(e);
      }
    }
  }]);

  return DocumentationPlugin;
}();

export default DocumentationPlugin;