@ormoshe/js-video-url-parser 0.5.1

package/lib/provider/voomly.d.ts

@@ -0,0 +1,14 @@
+import { VideoInfo } from '../urlParser';
+
+export interface VoomlyUrlParameters {
+    [key: string]: any;
+}
+
+export type VoomlyMediaTypes = 'video';
+
+export interface VoomlyVideoInfo extends VideoInfo<VoomlyUrlParameters, VoomlyMediaTypes> {
+    provider: 'voomly';
+    channel: string;
+}
+
+export type VoomlyParseResult = VoomlyVideoInfo | undefined;

package/lib/provider/voomly.js

@@ -0,0 +1,46 @@
+const { combineParams } = require('../util');
+
+function Voomly() {
+  this.provider = 'voomly';
+  this.defaultFormat = 'long';
+  this.formats = {
+    long: this.createLongUrl,
+  };
+  this.mediaTypes = {
+    VIDEO: 'video',
+  };
+}
+
+module.exports = Voomly;
+
+Voomly.prototype.parseUrl = function(url) {
+  var match = url.match(
+    /(?:v|embed)\/([a-zA-Z\d]+)/i
+  );
+  return match ? match[1] : undefined;
+};
+
+Voomly.prototype.parse = function(url, params) {
+  var result = {
+    mediaType: this.mediaTypes.VIDEO,
+    params: params,
+    id: this.parseUrl(url),
+  };
+  return result.id ? result : undefined;
+};
+
+Voomly.prototype.createUrl = function(baseUrl, vi, params) {
+  if (!vi.id || vi.mediaType !== this.mediaTypes.VIDEO) {
+    return undefined;
+  }
+
+  var url = baseUrl + vi.id;
+  url += combineParams(params);
+  return url;
+};
+
+Voomly.prototype.createLongUrl = function(vi, params) {
+  return this.createUrl('https://share.voomly.com/v/', vi, params);
+};
+
+require('../base').bind(new Voomly());

package/lib/provider/wistia.d.ts

@@ -0,0 +1,15 @@
+import { VideoInfo } from '../urlParser';
+
+export interface WistiaUrlParameters {
+    [key: string]: any;
+    start?: number;
+}
+
+export type WistiaMediaTypes = 'video' | 'embedvideo';
+
+export interface WistiaVideoInfo extends VideoInfo<WistiaUrlParameters, WistiaMediaTypes> {
+    provider: 'wistia';
+    channel?: string;
+}
+
+export type WistiaParseResult = WistiaVideoInfo | undefined;

package/lib/provider/wistia.js

@@ -0,0 +1,112 @@
+const {
+  combineParams,
+  getTime,
+} = require('../util');
+
+function Wistia() {
+  this.provider = 'wistia';
+  this.alternatives = [];
+  this.defaultFormat = 'long';
+  this.formats = {
+    long: this.createLongUrl,
+    embed: this.createEmbedUrl,
+    embedjsonp: this.createEmbedJsonpUrl,
+  };
+  this.mediaTypes = {
+    VIDEO: 'video',
+    EMBEDVIDEO: 'embedvideo',
+  };
+}
+
+module.exports = Wistia;
+
+Wistia.prototype.parseUrl = function(url) {
+  var match = url.match(
+    /(?:(?:medias|iframe)\/|wvideo=)([\w-]+)/
+  );
+  return match ? match[1] : undefined;
+};
+
+Wistia.prototype.parseChannel = function(url) {
+  var match = url.match(
+    /(?:(?:https?:)?\/\/)?([^.]*)\.wistia\./
+  );
+  var channel = match ? match[1] : undefined;
+  if (channel === 'fast' || channel === 'content') {
+    return undefined;
+  }
+  return channel;
+};
+
+Wistia.prototype.parseParameters = function(params, result) {
+  if (params.wtime) {
+    params.start = getTime(params.wtime);
+    delete params.wtime;
+  }
+  if (params.wvideo === result.id) {
+    delete params.wvideo;
+  }
+  return params;
+};
+
+Wistia.prototype.parseMediaType = function(result) {
+  if (result.id && result.channel) {
+    return this.mediaTypes.VIDEO;
+  } else if (result.id) {
+    delete result.channel;
+    return this.mediaTypes.EMBEDVIDEO;
+  } else {
+    return undefined;
+  }
+};
+
+Wistia.prototype.parse = function(url, params) {
+  var result = {
+    id: this.parseUrl(url),
+    channel: this.parseChannel(url),
+  };
+  result.params = this.parseParameters(params, result);
+  result.mediaType = this.parseMediaType(result);
+
+  if (!result.id) {
+    return undefined;
+  }
+
+  return result;
+};
+
+Wistia.prototype.createUrl = function(vi, params, url) {
+  if (params.start) {
+    params.wtime = params.start;
+    delete params.start;
+  }
+
+  url += combineParams(params);
+
+  return url;
+};
+
+Wistia.prototype.createLongUrl = function(vi, params) {
+  if (!vi.id || vi.mediaType !== this.mediaTypes.VIDEO) {
+    return undefined;
+  }
+  var url = 'https://' + vi.channel + '.wistia.com/medias/' + vi.id;
+  return this.createUrl(vi, params, url);
+};
+
+Wistia.prototype.createEmbedUrl = function(vi, params) {
+  if (!vi.id || !(vi.mediaType === this.mediaTypes.VIDEO || vi.mediaType === this.mediaTypes.EMBEDVIDEO)) {
+    return undefined;
+  }
+  var url = 'https://fast.wistia.com/embed/iframe/' + vi.id;
+  return this.createUrl(vi, params, url);
+};
+
+Wistia.prototype.createEmbedJsonpUrl = function(vi) {
+  if (!vi.id || !(vi.mediaType === this.mediaTypes.VIDEO || vi.mediaType === this.mediaTypes.EMBEDVIDEO)) {
+    return undefined;
+  }
+  return 'https://fast.wistia.com/embed/medias/' + vi.id + '.jsonp';
+};
+
+require('../base').bind(new Wistia());

package/lib/provider/youku.d.ts

@@ -0,0 +1,13 @@
+import { VideoInfo } from '../urlParser';
+
+export interface YoukuUrlParameters {
+    [key: string]: any;
+}
+
+export type YoukuMediaTypes = 'video';
+
+export interface YoukuVideoInfo extends VideoInfo<YoukuUrlParameters, YoukuMediaTypes> {
+    provider: 'youku';
+}
+
+export type YoukuParseResult = YoukuVideoInfo | undefined;

package/lib/provider/youku.js

@@ -0,0 +1,83 @@
+const {combineParams} = require('../util');
+
+function Youku() {
+  this.provider = 'youku';
+  this.defaultFormat = 'long';
+  this.formats = {
+    embed: this.createEmbedUrl,
+    long: this.createLongUrl,
+    flash: this.createFlashUrl,
+    static: this.createStaticUrl,
+  };
+  this.mediaTypes = {
+    VIDEO: 'video',
+  };
+}
+
+module.exports = Youku;
+
+Youku.prototype.parseUrl = function(url) {
+  var match = url.match(
+    /(?:(?:embed|sid)\/|v_show\/id_|VideoIDS=)([a-zA-Z0-9]+)/
+  );
+  return match ? match[1] : undefined;
+};
+
+Youku.prototype.parseParameters = function(params) {
+  if (params.VideoIDS) {
+    delete params.VideoIDS;
+  }
+  return params;
+};
+
+Youku.prototype.parse = function(url, params) {
+  var _this = this;
+  var result = {
+    mediaType: this.mediaTypes.VIDEO,
+    id: _this.parseUrl(url),
+    params: _this.parseParameters(params),
+  };
+
+  if (!result.id) {
+    return undefined;
+  }
+  return result;
+};
+
+Youku.prototype.createUrl = function(baseUrl, vi, params) {
+  if (!vi.id || vi.mediaType !== this.mediaTypes.VIDEO) {
+    return undefined;
+  }
+  var url = baseUrl + vi.id;
+
+  url += combineParams(params);
+  return url;
+};
+
+
+Youku.prototype.createEmbedUrl = function(vi, params) {
+  return this.createUrl('http://player.youku.com/embed/', vi, params);
+};
+
+Youku.prototype.createLongUrl = function(vi, params) {
+  return this.createUrl('http://v.youku.com/v_show/id_', vi, params);
+};
+
+Youku.prototype.createStaticUrl = function(vi, params) {
+  return this.createUrl(
+    'http://static.youku.com/v1.0.0638/v/swf/loader.swf?VideoIDS=',
+    vi, params
+  );
+};
+
+Youku.prototype.createFlashUrl = function(vi, params) {
+  if (!vi.id || vi.mediaType !== this.mediaTypes.VIDEO) {
+    return undefined;
+  }
+  var url = 'http://player.youku.com/player.php/sid/' + vi.id + '/v.swf';
+
+  url += combineParams(params);
+  return url;
+};
+
+require('../base').bind(new Youku());

package/lib/provider/youtube.d.ts

@@ -0,0 +1,15 @@
+import { VideoInfo } from '../urlParser';
+
+export interface YouTubeUrlParameters {
+    start?: number;
+    [key: string]: any;
+}
+
+export type YouTubeMediaTypes = 'video' | 'playlist' | 'share' | 'channel';
+
+export interface YouTubeVideoInfo extends VideoInfo<YouTubeUrlParameters, YouTubeMediaTypes> {
+    provider: 'youtube';
+    list?: string;
+}
+
+export type YouTubeParseResult = YouTubeVideoInfo | undefined;

package/lib/provider/youtube.js

@@ -0,0 +1,205 @@
+const {
+  combineParams,
+  getTime,
+} = require('../util');
+
+function YouTube() {
+  this.provider = 'youtube';
+  this.alternatives = ['youtu', 'ytimg'];
+  this.defaultFormat = 'long';
+  this.formats = {
+    short: this.createShortUrl,
+    long: this.createLongUrl,
+    embed: this.createEmbedUrl,
+    shortImage: this.createShortImageUrl,
+    longImage: this.createLongImageUrl,
+  };
+  this.imageQualities = {
+    '0': '0',
+    '1': '1',
+    '2': '2',
+    '3': '3',
+    DEFAULT: 'default',
+    HQDEFAULT: 'hqdefault',
+    SDDEFAULT: 'sddefault',
+    MQDEFAULT: 'mqdefault',
+    MAXRESDEFAULT: 'maxresdefault',
+  };
+  this.defaultImageQuality = this.imageQualities.HQDEFAULT;
+  this.mediaTypes = {
+    VIDEO: 'video',
+    PLAYLIST: 'playlist',
+    SHARE: 'share',
+    CHANNEL: 'channel',
+  };
+}
+
+module.exports = YouTube;
+
+YouTube.prototype.parseVideoUrl = function(url) {
+  var match = url.match(
+    /(?:(?:v|vi|be|videos|embed)\/(?!videoseries)|(?:v|ci)=)([\w-]{11})/i
+  );
+  return match ? match[1] : undefined;
+};
+
+YouTube.prototype.parseChannelUrl = function(url) {
+  // Match an opaque channel ID
+  var match = url.match(/\/channel\/([\w-]+)/);
+  if (match) {
+    return { id: match[1], mediaType: this.mediaTypes.CHANNEL };
+  }
+
+  // Match a vanity channel name or a user name. User urls are deprecated and
+  // currently redirect to the channel of that same name.
+  match = url.match(/\/(?:c|user)\/([\w-]+)/);
+  if (match) {
+    return { name: match[1], mediaType: this.mediaTypes.CHANNEL };
+  }
+};
+
+YouTube.prototype.parseParameters = function(params, result) {
+  if (params.start || params.t) {
+    params.start = getTime(params.start || params.t);
+    delete params.t;
+  }
+  if (params.v === result.id) {
+    delete params.v;
+  }
+  if (params.list === result.id) {
+    delete params.list;
+  }
+
+  return params;
+};
+
+YouTube.prototype.parseMediaType = function(result) {
+  if (result.params.list) {
+    result.list = result.params.list;
+    delete result.params.list;
+  }
+  if (result.id && !result.params.ci) {
+    result.mediaType = this.mediaTypes.VIDEO;
+  } else if (result.list) {
+    delete result.id;
+    result.mediaType = this.mediaTypes.PLAYLIST;
+  } else if (result.params.ci) {
+    delete result.params.ci;
+    result.mediaType = this.mediaTypes.SHARE;
+  } else {
+    return undefined;
+  }
+  return result;
+};
+
+YouTube.prototype.parse = function(url, params) {
+  var channelResult = this.parseChannelUrl(url);
+  if (channelResult) {
+    return channelResult;
+  } else {
+    var result = {
+      params: params,
+      id: this.parseVideoUrl(url),
+    };
+    result.params = this.parseParameters(params, result);
+    result = this.parseMediaType(result);
+    return result;
+  }
+};
+
+YouTube.prototype.createShortUrl = function(vi, params) {
+  if (!vi.id || vi.mediaType !== this.mediaTypes.VIDEO) {
+    return undefined;
+  }
+
+  var url = 'https://youtu.be/' + vi.id;
+  if (params.start) {
+    url += '#t=' + params.start;
+  }
+  return url;
+};
+
+YouTube.prototype.createLongUrl = function(vi, params) {
+  var url = '';
+  var startTime = params.start;
+  delete params.start;
+
+  if (vi.mediaType === this.mediaTypes.CHANNEL) {
+    if (vi.id) {
+      url += 'https://www.youtube.com/channel/' + vi.id;
+    } else if (vi.name) {
+      url += 'https://www.youtube.com/c/' + vi.name;
+    } else {
+      return undefined;
+    }
+  }
+  else if (vi.mediaType === this.mediaTypes.PLAYLIST && vi.list) {
+    params.feature = 'share';
+    url += 'https://www.youtube.com/playlist';
+  }
+  else if (vi.mediaType === this.mediaTypes.VIDEO && vi.id) {
+    params.v = vi.id;
+    url += 'https://www.youtube.com/watch';
+  }
+  else if (vi.mediaType === this.mediaTypes.SHARE && vi.id) {
+    params.ci = vi.id;
+    url += 'https://www.youtube.com/shared';
+  } else {
+    return undefined;
+  }
+
+  if (vi.list) {
+    params.list = vi.list;
+  }
+
+  url += combineParams(params);
+
+  if (vi.mediaType !== this.mediaTypes.PLAYLIST && startTime) {
+    url += '#t=' + startTime;
+  }
+  return url;
+};
+
+YouTube.prototype.createEmbedUrl = function(vi, params) {
+  var url = 'https://www.youtube.com/embed';
+
+  if (vi.mediaType === this.mediaTypes.PLAYLIST && vi.list) {
+    params.listType = 'playlist';
+  } else if (vi.mediaType === this.mediaTypes.VIDEO && vi.id) {
+    url += '/' + vi.id;
+    //loop hack
+    if (params.loop === '1') {
+      params.playlist = vi.id;
+    }
+  } else {
+    return undefined;
+  }
+
+  if (vi.list) {
+    params.list = vi.list;
+  }
+
+  url += combineParams(params);
+
+  return url;
+};
+
+YouTube.prototype.createImageUrl = function(baseUrl, vi, params) {
+  if (!vi.id || vi.mediaType !== this.mediaTypes.VIDEO) {
+    return undefined;
+  }
+  var url = baseUrl + vi.id + '/';
+  var quality = params.imageQuality || this.defaultImageQuality;
+
+  return url + quality + '.jpg';
+};
+
+YouTube.prototype.createShortImageUrl = function(vi, params) {
+  return this.createImageUrl('https://i.ytimg.com/vi/', vi, params);
+};
+
+YouTube.prototype.createLongImageUrl = function(vi, params) {
+  return this.createImageUrl('https://img.youtube.com/vi/', vi, params);
+};
+
+require('../base').bind(new YouTube());

package/lib/testUrls.js

@@ -0,0 +1,11 @@
+exports.testUrls = (parser, obj) => {
+  const { urls, videoInfo, formats } = obj;
+  const { parse, create } = parser;
+  for (const url of urls) {
+    expect(parse(url), 'Parse Url: ' + url).toEqual(videoInfo);
+  }
+  for (const format of Object.keys(formats)) {
+    const createdUrl = create({ videoInfo, format, params: videoInfo.params });
+    expect(createdUrl, 'Created Url: ' + createdUrl).toBe(formats[format]);
+  }
+};

package/lib/urlParser.d.ts

@@ -0,0 +1,23 @@
+import Provider from './provider/base-provider';
+
+export interface Options {
+    videoInfo: VideoInfo;
+    params?: 'internal' | Record<string, any>;
+    format?: string;
+}
+
+export interface VideoInfo<UrlParameters = Record<string, any>, MediaTypes = string> {
+    provider?: string;
+    id: string;
+    mediaType?: MediaTypes;
+    params?: UrlParameters;
+}
+
+export default class UrlParser {
+    plugins: Record<string, Provider>;
+
+    parseProvider(url: string): string | undefined;
+    parse(url: string): VideoInfo | undefined;
+    bind(plugin: Provider): void;
+    create(op: Options): string | undefined;
+}

package/lib/urlParser.js

@@ -0,0 +1,81 @@
+const {
+  getQueryParams,
+} = require('./util');
+
+function UrlParser() {
+  for (const key of [
+    'parseProvider',
+    'parse',
+    'bind',
+    'create',
+  ]) {
+    this[key] = this[key].bind(this);
+  }
+  this.plugins = {};
+}
+
+module.exports = UrlParser;
+
+UrlParser.prototype.parseProvider = function(url) {
+  var match = url.match(
+    /(?:(?:https?:)?\/\/)?(?:[^.]+\.)?(\w+)\./i
+  );
+  return match ? match[1] : undefined;
+};
+
+UrlParser.prototype.parse = function(url) {
+  if (typeof url === 'undefined') {
+    return undefined;
+  }
+  var provider = this.parseProvider(url);
+  var result;
+  var plugin = this.plugins[provider];
+  if (!provider || !plugin || !plugin.parse) {
+    return undefined;
+  }
+  result = plugin.parse.call(
+    plugin, url, getQueryParams(url)
+  );
+  if (result) {
+    result = removeEmptyParameters(result);
+    result.provider = plugin.provider;
+  }
+  return result;
+};
+
+UrlParser.prototype.bind = function(plugin) {
+  this.plugins[plugin.provider] = plugin;
+  if (plugin.alternatives) {
+    for (var i = 0; i < plugin.alternatives.length; i += 1) {
+      this.plugins[plugin.alternatives[i]] = plugin;
+    }
+  }
+};
+
+UrlParser.prototype.create = function(op) {
+  if (typeof (op) !== 'object' || typeof (op.videoInfo) !== 'object') {
+    return undefined;
+  }
+
+  var vi = op.videoInfo;
+  var params = op.params;
+  var plugin = this.plugins[vi.provider];
+
+  params = (params === 'internal') ? vi.params : params || {};
+
+  if (plugin) {
+    op.format = op.format || plugin.defaultFormat;
+    // eslint-disable-next-line no-prototype-builtins
+    if (plugin.formats.hasOwnProperty(op.format)) {
+      return plugin.formats[op.format].apply(plugin, [vi, Object.assign({}, params)]);
+    }
+  }
+  return undefined;
+};
+
+function removeEmptyParameters(result) {
+  if (result.params && Object.keys(result.params).length === 0) {
+    delete result.params;
+  }
+  return result;
+}