@elodin/cli/es/util.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.chmod = chmod;
exports.readdir = readdir;
exports.readdirForCompilable = readdirForCompilable;
exports.isCompilableExtension = isCompilableExtension;
exports.compile = compile;
exports.deleteDir = deleteDir;
exports.requireChokidar = requireChokidar;

var _fsReaddirRecursive = _interopRequireDefault(require("fs-readdir-recursive"));

var _chalk = _interopRequireDefault(require("chalk"));

var _path4 = _interopRequireDefault(require("path"));

var _fs = _interopRequireDefault(require("fs"));

var _core = require("@elodin/core");

var _error = require("./error");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

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; }

function _templateObject6() {
  var data = _taggedTemplateLiteral(["", ""]);

  _templateObject6 = function _templateObject6() {
    return data;
  };

  return data;
}

function _templateObject5() {
  var data = _taggedTemplateLiteral(["{red ", "}"]);

  _templateObject5 = function _templateObject5() {
    return data;
  };

  return data;
}

function _templateObject4() {
  var data = _taggedTemplateLiteral(["The property ", " does not accept the value {bold ", "}.\n{dim Check {underline https://elodin.dev/docs/language/styles#", "} for a list of available values.}"]);

  _templateObject4 = function _templateObject4() {
    return data;
  };

  return data;
}

function _templateObject3() {
  var data = _taggedTemplateLiteral(["", ": {red ", "}"]);

  _templateObject3 = function _templateObject3() {
    return data;
  };

  return data;
}

function _templateObject2() {
  var data = _taggedTemplateLiteral(["The property {bold ", "} is not a valid ", " property.", "\n{dim Check {underline https://elodin.dev/docs/language/styles#", "} for a list of available properties.}"]);

  _templateObject2 = function _templateObject2() {
    return data;
  };

  return data;
}

function _templateObject() {
  var data = _taggedTemplateLiteral(["{red ", "}: ", ""]);

  _templateObject = function _templateObject() {
    return data;
  };

  return data;
}

function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }

function chmod(src, dest) {
  _fs["default"].chmodSync(dest, _fs["default"].statSync(src).mode);
}

function readdir(dirname, includeDotfiles, filter) {
  return (0, _fsReaddirRecursive["default"])(dirname, function (filename, _index, currentDirectory) {
    var stat = _fs["default"].statSync(_path4["default"].join(currentDirectory, filename));

    if (stat.isDirectory()) return true;
    return (includeDotfiles || filename[0] !== '.') && (!filter || filter(filename));
  });
}

function readdirForCompilable(dirname, includeDotfiles) {
  return readdir(dirname, includeDotfiles, isCompilableExtension);
}

function isCompilableExtension(filename) {
  return _path4["default"].extname(filename) === '.elo';
} // export function transform(filename, code, opts) {
//   opts = {
//     ...opts,
//     filename,
//   }
//   return new Promise((resolve, reject) => {
//     babel.transform(code, opts, (err, result) => {
//       if (err) reject(err)
//       else resolve(result)
//     })
//   })
// }


function compile(filename, opts) {
  var log = function log(errors) {
    return errors.forEach(function (error) {
      var count = ++opts.errorCount;

      if (error.type === _core.errorTypes.INVALID_PROPERTY) {
        var property = error.property,
            value = error.value,
            _path = error.path,
            line = error.line,
            format = error.format,
            hint = error.hint;
        var didYouMeanMessage = hint ? "\n\n  Did you mean: ".concat(hint, "?\n") : '';
        (0, _error.logSyntaxError)({
          count: count,
          path: _path,
          lineNumber: line,
          line: (0, _chalk["default"])(_templateObject(), property, (0, _core.formatFromAST)(value)),
          message: (0, _chalk["default"])(_templateObject2(), property, format, didYouMeanMessage, format)
        });
      } else if (error.type === _core.errorTypes.INVALID_VALUE) {
        var _property = error.property,
            _value = error.value,
            _path2 = error.path,
            _line = error.line,
            _format = error.format;
        (0, _error.logSyntaxError)({
          count: count,
          path: _path2,
          lineNumber: _line,
          line: (0, _chalk["default"])(_templateObject3(), _property, (0, _core.formatFromAST)(_value)),
          message: (0, _chalk["default"])(_templateObject4(), _property, (0, _core.formatFromAST)(_value), _format)
        });
      } else {
        var _line2 = error.line,
            _path3 = error.path,
            message = error.message,
            source = error.source,
            token = error.token;
        var lineCode = source ? source.substr(0, token.end).split('\n').pop() : '';
        (0, _error.logSyntaxError)({
          count: count,
          path: _path3,
          lineNumber: _line2,
          line: (0, _chalk["default"])(_templateObject5(), lineCode),
          message: (0, _chalk["default"])(_templateObject6(), message)
        });
      }
    });
  };

  return new Promise(function (resolve, reject) {
    return (0, _core.transformFile)(filename, _objectSpread({}, opts, {
      log: log
    }), resolve);
  });
}

function deleteDir(path) {
  if (_fs["default"].existsSync(path)) {
    _fs["default"].readdirSync(path).forEach(function (file) {
      var curPath = path + '/' + file;

      if (_fs["default"].lstatSync(curPath).isDirectory()) {
        // recurse
        deleteDir(curPath);
      } else {
        // delete file
        _fs["default"].unlinkSync(curPath);
      }
    });

    _fs["default"].rmdirSync(path);
  }
}

process.on('uncaughtException', function (err) {
  console.error(err);
  process.exit(1);
});

function requireChokidar() {
  try {
    return require('chokidar');
  } catch (err) {
    console.error('The optional dependency chokidar failed to install and is required for ' + '--watch. Chokidar is likely not supported on your platform.');
    throw err;
  }
}