youtube-dl-node/dist/Downloader.js

youtube-dl wrapper for node.js

'use strict';

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _request = require('request');

var _request2 = _interopRequireDefault(_request);

var _requestPromise = require('request-promise');

var _requestPromise2 = _interopRequireDefault(_requestPromise);

var _Base2 = require('./Base');

var _Base3 = _interopRequireDefault(_Base2);

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

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

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var Downloader = function (_Base) {
  _inherits(Downloader, _Base);

  function Downloader(props) {
    _classCallCheck(this, Downloader);

    var _this = _possibleConstructorReturn(this, (Downloader.__proto__ || Object.getPrototypeOf(Downloader)).call(this, props));

    _this._url = 'https://ytdl-org.github.io/youtube-dl/download.html';
    _this._regex = /https:\/\/yt-dl\.org\/downloads\/(.*?)\/youtube-dl/;
    return _this;
  }

  _createClass(Downloader, [{
    key: '_getLatestInfo',
    value: function _getLatestInfo() {
      var _this2 = this;

      return _requestPromise2.default.get(this._url).then(function (html) {
        var result = html.match(_this2._regex);
        if (result) {
          return result;
        } else {
          return Promise.reject('Can\'t find the binary url or version');
        }
      });
    }
  }, {
    key: '_checkVersion',
    value: function _checkVersion() {
      var _this3 = this;

      return this._getLocalVersion().then(function (localVersion) {
        return _this3._getLatestInfo().then(function (info) {
          var _info = _slicedToArray(info, 2),
              url = _info[0],
              version = _info[1];

          return Promise.resolve([version !== localVersion, url, version]);
        });
      });
    }
  }, {
    key: '_getLocalVersion',
    value: function _getLocalVersion() {
      var _this4 = this;

      return new Promise(function (resolve, reject) {
        var fullPath = _this4._getVersionFilePath();
        _fs2.default.readFile(fullPath, 'utf8', function (error, data) {
          if (error) {
            if (error.code === 'ENOENT') {
              resolve('__FIRST_TIME_DOWNLOAD_SO_NO_VERSION__');
            } else {
              reject(error);
            }
          } else {
            resolve(data);
          }
        });
      });
    }
  }, {
    key: '_writeLocalVersion',
    value: function _writeLocalVersion() {
      var _this5 = this;

      var version = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';

      return new Promise(function (resolve, reject) {
        var fullPath = _this5._getVersionFilePath();
        _fs2.default.writeFile(fullPath, version, function (error) {
          if (error) {
            reject(error);
          } else {
            resolve();
          }
        });
      });
    }
  }, {
    key: '_writeYtdlFile',
    value: function _writeYtdlFile(url, os) {
      if (!url) {
        return Promise.reject('no url');
      }

      var to = this._getYtdlBinaryPath();
      if (os === 'win') {
        url += '.exe';
        to += '.exe';
      }

      return new Promise(function (resolve, reject) {
        var foundError = void 0;
        var downloadStream = _request2.default.get(url);

        downloadStream.on('response', function (res) {
          if (res.statusCode !== 200) {
            foundError = 'Response Error: ' + res.statusCode;
            return;
          }

          downloadStream.pipe(_fs2.default.createWriteStream(to, {
            mode: 493
          }));
        });

        downloadStream.on('error', function (error) {
          reject(error);
        });

        downloadStream.on('end', function () {
          if (foundError) {
            reject(foundError);
          } else {
            resolve();
          }
        });
      });
    }
  }, {
    key: '_normalizeOS',
    value: function _normalizeOS(os) {
      if (os === 'win32') {
        return 'win';
      } else {
        return 'default';
      }
    }
  }, {
    key: 'save',
    value: function save(os) {
      var _this6 = this;

      var force = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

      return this._checkVersion().then(function (result) {
        os = _this6._normalizeOS(os);

        var _result = _slicedToArray(result, 3),
            isNewer = _result[0],
            url = _result[1],
            version = _result[2];

        if (isNewer || force) {
          return _this6._writeLocalVersion(version).then(function () {
            return _this6._writeYtdlFile(url, os);
          });
        } else {
          return Promise.resolve();
        }
      });
    }
  }]);

  return Downloader;
}(_Base3.default);

exports.default = Downloader;
module.exports = exports['default'];