ahmad-youtubeerrtyret 1.0.0

package/youtube-search/index.js

@@ -0,0 +1,111 @@
+var querystring = require('querystring')
+var axios = require('axios')
+
+var allowedProperties = [
+  'fields',
+  'channelId',
+  'channelType',
+  'eventType',
+  'forContentOwner',
+  'forDeveloper',
+  'forMine',
+  'location',
+  'locationRadius',
+  'onBehalfOfContentOwner',
+  'order',
+  'pageToken',
+  'publishedAfter',
+  'publishedBefore',
+  'regionCode',
+  'relatedToVideoId',
+  'relevanceLanguage',
+  'safeSearch',
+  'topicId',
+  'type',
+  'videoCaption',
+  'videoCategoryId',
+  'videoDefinition',
+  'videoDimension',
+  'videoDuration',
+  'videoEmbeddable',
+  'videoLicense',
+  'videoSyndicated',
+  'videoType',
+  'key'
+]
+
+module.exports = function search (term, opts, cb) {
+  if (typeof opts === 'function') {
+    cb = opts
+    opts = {}
+  }
+
+  if (!opts) opts = {}
+
+  if (!cb) {
+    return new Promise(function (resolve, reject) {
+      search(term, opts, function (err, results, pageInfo) {
+        if (err) return reject(err)
+        resolve({results: results, pageInfo: pageInfo})
+      })
+    })
+  }
+
+  var params = {
+    q: term,
+    part: opts.part || 'snippet',
+    maxResults: opts.maxResults || 30
+  }
+
+  Object.keys(opts).map(function (k) {
+    if (allowedProperties.indexOf(k) > -1) params[k] = opts[k]
+  })
+
+  axios.get('https://www.googleapis.com/youtube/v3/search?' + querystring.stringify(params))
+    .then(function (response) {
+      var result = response.data
+
+      var pageInfo = {
+        totalResults: result.pageInfo.totalResults,
+        resultsPerPage: result.pageInfo.resultsPerPage,
+        nextPageToken: result.nextPageToken,
+        prevPageToken: result.prevPageToken
+      }
+
+      var findings = result.items.map(function (item) {
+        var link = ''
+        var id = ''
+        switch (item.id.kind) {
+          case 'youtube#channel':
+            link = 'https://www.youtube.com/channel/' + item.id.channelId
+            id = item.id.channelId
+            break
+          case 'youtube#playlist':
+            link = 'https://www.youtube.com/playlist?list=' + item.id.playlistId
+            id = item.id.playlistId
+            break
+          default:
+            link = 'https://www.youtube.com/watch?v=' + item.id.videoId
+            id = item.id.videoId
+            break
+        }
+
+        return {
+          id: id,
+          link: link,
+          kind: item.id.kind,
+          publishedAt: item.snippet.publishedAt,
+          channelId: item.snippet.channelId,
+          channelTitle: item.snippet.channelTitle,
+          title: item.snippet.title,
+          description: item.snippet.description,
+          thumbnails: item.snippet.thumbnails
+        }
+      })
+
+      return cb(null, findings, pageInfo)
+    })
+    .catch(function (err) {
+      return cb(err)
+    })
+}

package/youtube-search/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "youtube-search",
+  "version": "1.1.6",
+  "description": "Search for youtube videos",
+  "main": "index.js",
+  "scripts": {
+    "test": "standard && node tests/test-*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MaxGfeller/youtube-search"
+  },
+  "keywords": [
+    "youtube",
+    "search",
+    "api"
+  ],
+  "author": "Max Gfeller <max.gfeller@gmail.com>",
+  "license": "BSD",
+  "dependencies": {
+    "axios": "^0.21.1",
+    "xml2js": "~0.2.8"
+  },
+  "devDependencies": {
+    "browserify": "^16.2.3",
+    "standard": "^11.0.1",
+    "tape": "^4.9.1"
+  }
+}

package/youtube-search/tests/test-search.js

@@ -0,0 +1,32 @@
+var search = require('../')
+var test = require('tape')
+
+var key = process.env.API_KEY
+
+test('basic', (t) => {
+  search('jsconf', {
+    key: key
+  }, function (err, results) {
+    t.notOk(err, 'no error')
+    t.equals(results.length, 30, '30 results')
+    t.end()
+  })
+})
+
+test('promise', (t) => {
+  var p = search('jsconf', { key: key })
+  t.ok(p)
+  p.then((result) => {
+    t.equals(result.results.length, 30, '30 results')
+    t.end()
+  })
+})
+
+test('multiple words', (t) => {
+  var p = search('best videos', { key: key })
+  t.ok(p)
+  p.then((result) => {
+    t.equals(result.results.length, 30, '30 results')
+    t.end()
+  })
+})

package/ytdl-getinfo/.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - "stable"

package/ytdl-getinfo/README.md

@@ -0,0 +1,77 @@
+# ytdl-getinfo ![](https://travis-ci.org/TheBITLINK/ytdl-getinfo.svg?branch=master)
+
+Gets information on a video (or playlist) using youtube-dl.
+
+Like the getInfo function of `node-youtube-dl`, but promisified and event-based.
+
+## Usage
+
+```javascript
+const { getInfo } = require('ytdl-getinfo')
+```
+
+## Examples
+
+- Basic example:
+  ```javascript
+  getInfo('https://www.youtube.com/watch?v=v7BddpYYNGk').then(info => {
+    // info.items[0] should contain the output of youtube-dl --dump-json
+    console.log(info.items[0].title)
+  })
+  ```
+
+- Video Search:
+  ```javascript
+  getInfo('Muzzy - Endgame').then(info => {
+    // info.items[0] contains information of the first search result
+    console.log(info.items[0].url)    
+  })
+  ```
+
+- Custom Arguments:
+  ```javascript
+  getInfo('v7BddpYYNGk', ['--format=bestaudio']).then(info => {
+    // ...
+  })
+  ```
+
+- Playlists (event based)
+  ```javascript
+  getInfo('PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re').then(info => {
+    // info.partial is true for playlists
+    if (info.partial) {
+      info.on('video', v => console.log(v.title))
+      info.on('done', () => console.log(`Playlist contains ${info.items.length} items.`))
+    }
+  })
+  ```
+
+- Playlists (promise based)
+  ```javascript
+  getInfo('PLwiyx1dc3P2JR9N8gQaQN_BCvlSlap7re', [], true).then(info => {
+    // info.items contains all the playlist items
+  })
+  ```
+
+- Multiple queries at once (acts like a playlist)
+  ```javascript
+  getInfo(['v7BddpYYNGk', 'BMhrBLD_B2U']).then(info => {
+    // ...
+  })
+  ```
+
+## Manually updating the youtube-dl binary
+
+```javascript
+require('ytdl-getinfo').update().then(version => {
+  console.log(`youtube-dl updated to version ${version}`)
+})
+```
+
+## Determining the version of the youtube-dl binary
+
+```javascript
+require('ytdl-getinfo').getVersion().then(version => {
+  console.log(`Current youtube-dl version: ${version}`)
+})
+```

package/ytdl-getinfo/index.js

@@ -0,0 +1,105 @@
+const Playlist = require('./playlist')
+const update = require('./updater')
+const path = require('path')
+const os = require('os')
+const { spawn, execFile } = require('child_process')
+const { platform } = process
+
+module.exports = {
+  update,
+  /**
+   * Gets information about a video url.
+   *
+   * By default, if you don't pass any args to the executable, the following
+   * will be used: --default-search=ytsearch -i
+   *
+   * --dump-json will always be used no matter what.
+   *
+   * Unless wait is set to true, the promise will resolve when there's information
+   * on at least one video.
+   *
+   * @param {string|string[]} query - URL(s) to find.
+   * @param {string[]} args - Arguments passed to the youtube-dl executable.
+   * @param {boolean} wait - Wait for all videos before resolving the promise.
+   * @return {Promise<Playlist>} - A playlist object containing the video information.
+   */
+  getInfo (query, args, wait = false) {
+    return new Promise((resolve, reject) => {
+      let lastError
+      let pData = ''
+      // Checks
+      if (!query) return reject(new Error('No query specified.'))
+      if (typeof query !== 'string' && !(query instanceof Array)) {
+        return reject(new Error('query must be a string or array'))
+      }
+      // Arguments
+      const a = ['--dump-json']
+        .concat(args || ['--default-search=ytsearch', '-i', '--format=best'])
+        .concat(['-a', '-']) // stdin
+      const q = [].concat(query)
+      // Create a playlist object
+      const pl = new Playlist()
+      // Launch the youtube-dl executable
+      const bin = path.join(__dirname, `ytdl`, `youtube-dl${platform === 'win32' ? '.exe' : ''}`)
+      const ytdl = spawn(bin, a, { maxBuffer: Infinity })
+      // Handle errors
+      ytdl.on('error', reject)
+      ytdl.stderr.on('data', d => pl.emit('error', new Error(d)))
+      // Send query
+      ytdl.stdin.end(q.join(os.EOL), 'utf8')
+      // Parse incoming data
+      ytdl.stdout.on('data', d => {
+        pData += d
+        if (pData.indexOf('\n') <= 0) return
+        try {
+          const data = JSON.parse(pData)
+          pl.items.push(data)
+          pl.emit('video', data)
+          if (pl.items.length === 2 && !wait) {
+            // Wait 100ms for the process to exit before resolving the promise
+            // This way, if there's only 2 videos, the playlist will be resolved
+            // with 'partial' set to false.
+            setTimeout(() => {
+              if (pl.partial) {
+                resolve(pl)
+                pl.emit('video', data)
+              }
+            }, 100)
+          }
+        } catch (e) {
+          pl.emit('error', e)
+        }
+        pData = ''
+      })
+      // Close Event
+      ytdl.on('close', code => {
+        pl.partial = false
+        pl.emit('done')
+        // Reject the promise if there are no items and there's a error
+        if (!pl.items.length && code > 0) {
+          return reject(lastError || new Error('Process exited with code ' + code))
+        }
+        // Resolve the promise if wait is set to true or there's only one item
+        if (wait || pl.items.length <= 1) resolve(pl)
+      })
+      // Keep track of the errors
+      pl.on('error', e => { lastError = e })
+      // Add a _cancel function to kill the process
+      pl._cancel = () => ytdl.kill()
+    })
+  },
+  /**
+   * Resolves to the version string of the youtube-dl executable
+   * @return {Promise<string>}
+   */
+  getVersion () {
+    const bin = path.join(__dirname, `ytdl`, `youtube-dl${platform === 'win32' ? '.exe' : ''}`)
+
+    return new Promise((resolve, reject) => {
+      execFile(bin, ['--version'], (error, stdout, stderr) => {
+        if (error || stderr.length) return reject(error || stderr)
+        resolve(stdout)
+      })
+    })
+  }
+}

package/ytdl-getinfo/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "ytdl-getinfo",
+  "version": "1.1.0",
+  "description": "Gets video information using youtube-dl",
+  "main": "index.js",
+  "scripts": {
+    "postinstall": "node updater",
+    "update": "node updater",
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TheBITLINK/ytdl-getinfo.git"
+  },
+  "keywords": [
+    "youtube-dl"
+  ],
+  "author": "TheBITLINK aka BIT <me@thebitlink.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/TheBITLINK/ytdl-getinfo/issues"
+  },
+  "homepage": "https://github.com/TheBITLINK/ytdl-getinfo#readme",
+  "dependencies": {
+    "request": "^2.81.0"
+  },
+  "devDependencies": {
+    "chai": "^3.5.0",
+    "chai-as-promised": "^6.0.0",
+    "chai-events": "0.0.1",
+    "mocha": "^3.2.0"
+  }
+}

package/ytdl-getinfo/playlist.js

@@ -0,0 +1,50 @@
+const EventEmitter = require('events')
+
+/**
+ * Represents a video playlist.
+ */
+class Playlist extends EventEmitter {
+  constructor () {
+    super()
+    /**
+     * Items of the playlist
+     */
+    this.items = []
+    /**
+     * true when youtube-dl is still getting information on other videos
+     * @type {boolean}
+     */
+    this.partial = true
+  }
+
+  /**
+   * Cancels playlist fetching
+   */
+  cancel () {
+    if (this.partial && this._cancel) {
+      this._cancel()
+      this.emit('cancelled')
+    }
+  }
+}
+
+// JSDoc Events
+/**
+ * Emitted when information about a video is available
+ *
+ * @event Playlist#video
+ * @type {object}
+ */
+/**
+ * Emitted when all videos are done
+ *
+ * @event Playlist#done
+ */
+/**
+ * Emitted when youtube-dl reports an error
+ *
+ * @event Playlist#error
+ */
+
+
+module.exports = Playlist

package/ytdl-getinfo/test/test.js

@@ -0,0 +1,68 @@
+const { getInfo } = require('../index')
+var chai = require('chai')
+chai.use(require('chai-events'))
+chai.use(require('chai-as-promised'))
+chai.should()
+
+describe('ytdl-getinfo', function () {
+  it('should fail when called with no query', function () {
+    return getInfo().should.be.rejected
+  })
+  
+  it('should resolve with basic info for a single video', function () {
+    this.timeout(30000)
+    return getInfo('v7BddpYYNGk').should.eventually.have.property('items').with.lengthOf(1)
+  })
+
+  it('should resolve with "partial" set to false for a single video', function () {
+    this.timeout(30000)
+    return getInfo('v7BddpYYNGk').should.eventually.have.property('partial', false)
+  })
+
+  it('should resolve with "partial" set to true for playlists', function () {
+    this.timeout(30000)
+    return getInfo('PLJGN3qYb3JQyx429pxmyPVMUFnbqbaE9n').then(p => { p.cancel(); return p })
+    .should.eventually.have.property('partial', true)
+  })
+  
+  it('should wait for the entire playlist when "wait" is true', function () {
+    this.timeout(60000)
+    return getInfo('PLJGN3qYb3JQyx429pxmyPVMUFnbqbaE9n', [], true)
+    .should.eventually.have.property('items').with.lengthOf(3)
+  })
+
+  // it('should be able to handle large amounts of data', function () {
+  //  this.timeout(30000)
+  //  return getInfo('JwKHxzfmAOY').should.eventually.have.property('items').with.lengthOf(1)
+  // })
+
+  it('should throw errors produced by youtube-dl', function () {
+    this.timeout(30000)
+    return getInfo('AnYcMiksJ-A').should.be.rejected // Private Video
+  })
+
+  it('should handle unicode searches properly', function () {
+    this.timeout(30000)
+    return getInfo('幽閉サテライト - ひと肌くらいの熱')
+    .should.eventually.have.property('items').with.lengthOf(1)
+  })
+
+  it('should properly escape queries starting with a dash', function () {
+    this.timeout(30000)
+    return getInfo('-H-sigEewZ8')
+    .should.eventually.have.property('items').with.lengthOf(1)
+  })
+
+  it('should handle multiple queries properly', function () {
+    this.timeout(60000)
+    return getInfo(['EJTZms5PFg8', '_7inU3si8nA'], [], true)
+    .should.eventually.have.property('items').with.lengthOf(2)
+  })
+
+  it('should emit the "done" event when all the playlist data is available', function () {
+    this.timeout(60000)
+    return getInfo('PLJGN3qYb3JQyx429pxmyPVMUFnbqbaE9n')
+    .should.eventually.emit('done')
+  })
+
+})

package/ytdl-getinfo/updater.js

@@ -0,0 +1,42 @@
+const fs = require('fs')
+const path = require('path')
+const request = require('request')
+const { execFile } = require('child_process')
+
+/**
+ * Updates or downloads the youtube-dl binary.
+ * @return {Promise<String>} - New version number
+ */
+function updateBinary () {
+  return new Promise((resolve, reject) => {
+    const bin = `youtube-dl${process.platform === 'win32' ? '.exe' : ''}`
+    const dest = path.join(__dirname, `ytdl`, bin)
+
+    // Get the latest version
+    request.get(`https://yt-dl.org/downloads/latest/${bin}`)
+    .on('error', e => reject(e)) // Handle errors
+    .on('end', () => setTimeout(() => {
+      // Try to get the version number
+      execFile(dest, ['--version'], (error, stdout, stderr) => {
+        if (error || stderr.length) return reject(error || stderr)
+        resolve(stdout)
+      })
+    }, 1000))
+    .pipe(fs.createWriteStream(dest, { mode: 0o755 }))
+  })
+}
+
+if (require.main === module) {
+  // CLI
+  console.log('Updating youtube-dl to the latest version...')
+  updateBinary().then(version => {
+    console.log(`Successfully downloaded youtube-dl ${version}`)
+    process.exit()
+  }).catch(e => {
+    console.error(e)
+    process.exit(1)
+  })
+} else {
+  // Module
+  module.exports = updateBinary
+}