bit-bin/dist/jsdoc/vue/vue-parser.js

<a href="https://opensource.org/licenses/Apache-2.0"><img alt="apache" src="https://img.shields.io/badge/License-Apache%202.0-blue.svg"></a> <a href="https://github.com/teambit/bit/blob/master/CONTRIBUTING.md"><img alt="prs" src="https://img.shields.io/b

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = parse;

function _bluebird() {
  const data = require("bluebird");

  _bluebird = function () {
    return data;
  };

  return data;
}

function domain() {
  const data = _interopRequireWildcard(require("domain"));

  domain = function () {
    return data;
  };

  return data;
}

function _parser() {
  const data = _interopRequireDefault(require("@vuedoc/parser"));

  _parser = function () {
    return data;
  };

  return data;
}

function _utils() {
  const data = require("../../utils");

  _utils = function () {
    return data;
  };

  return data;
}

function _logger() {
  const data = _interopRequireDefault(require("../../logger/logger"));

  _logger = function () {
    return data;
  };

  return data;
}

function formatProperty(prop) {
  const {
    name,
    description,
    type,
    required
  } = prop;
  return {
    name,
    description,
    required,
    type,
    defaultValue: {
      value: prop.default === '__undefined__' ? undefined : prop.default,
      computed: false
    }
  };
}

function formatComputed(computed) {
  const {
    name,
    description
  } = computed;
  return {
    name,
    description,
    required: false,
    defaultValue: {
      value: null,
      computed: true
    }
  };
}

function formatProperties(props, computeds) {
  const regularProps = props ? props.map(formatProperty) : [];
  const computedProps = computeds ? computeds.map(formatComputed) : [];
  return regularProps.concat(computedProps);
}

function formatMethod(method) {
  const {
    name,
    description,
    params
  } = method;
  return {
    name,
    description,
    // Private method won't be in the raw vue docs results, so what ever got here is public
    access: 'public',
    args: params,
    returns: method.return
  };
}

function formatMethods(methods) {
  if (!methods) return [];
  return methods.map(formatMethod);
}

function fromVueDocs({
  name,
  description,
  props,
  methods,
  computed
}, filePath) {
  return {
    filePath: (0, _utils().pathNormalizeToLinux)(filePath),
    name,
    description,
    properties: formatProperties(props, computed),
    access: 'public',
    methods: formatMethods(methods)
  };
}

function parse(_x, _x2) {
  return _parse.apply(this, arguments);
}

function _parse() {
  _parse = (0, _bluebird().coroutine)(function* (data, filePath) {
    const options = {
      filecontent: data
    };
    return new Promise(resolve => {
      try {
        // Wrapping this call with a domain since the vue docs parser call process.nextTick directly
        // see (https://gitlab.com/vuedoc/parser/blob/master/lib/parser/Parser.js#L72) which
        // results in sometime throw an unhandled error outside the promise which make the main process hang.
        // read more about it here:
        // https://gitlab.com/vuedoc/parser/issues/56#note_219267637
        const parsingDomain = domain().create();
        parsingDomain.on('error', err => {
          _logger().default.debug(`failed parsing vue docs on path ${filePath} with unhandled error`, err); // never mind, ignore the doc of this source


          resolve([]);
        }).run( /*#__PURE__*/(0, _bluebird().coroutine)(function* () {
          try {
            const vueDocs = yield _parser().default.parse(options);
            const formattedDocs = fromVueDocs(vueDocs, filePath);
            resolve([formattedDocs]);
          } catch (e) {
            _logger().default.debug(`failed parsing vue docs on path ${filePath} with error`, e); // never mind, ignore the doc of this source


            resolve([]);
          }
        }));
      } catch (e) {
        _logger().default.debug(`failed parsing vue docs on path ${filePath} with error`, e); // never mind, ignore the doc of this source


        resolve([]);
      }
    });
  });
  return _parse.apply(this, arguments);
}