@diplodoc/transform 4.0.0

package/src/transform/plugins/video/index.ts

@@ -0,0 +1,134 @@
+// Process @[youtube](youtubeVideoID)
+// Process @[vimeo](vimeoVideoID)
+// Process @[vine](vineVideoID)
+// Process @[prezi](preziID)
+// Process @[osf](guid)
+
+import type MarkdownIt from 'markdown-it';
+import type {PluginWithOptions} from 'markdown-it';
+import type ParserInline from 'markdown-it/lib/parser_inline';
+import type Renderer from 'markdown-it/lib/renderer';
+
+import type {VideoFullOptions, VideoPluginOptions, VideoToken} from './types';
+import {parseVideoUrl} from './parsers';
+import {defaults, VideoService} from './const';
+
+// eslint-disable-next-line valid-jsdoc
+/**
+ * Video plugin for markdown-it.
+ * Forked from https://github.com/CenterForOpenScience/markdown-it-video/tree/0.6.3
+ */
+const video: PluginWithOptions<VideoPluginOptions> = (md, options) => {
+    const theOptions: VideoFullOptions = {...defaults, ...options};
+    const theMd = md;
+
+    theMd.renderer.rules.video = tokenizeVideo(theMd, theOptions);
+    theMd.inline.ruler.before('emphasis', 'video', videoEmbed(theMd, theOptions));
+};
+
+function tokenizeVideo(md: MarkdownIt, options: VideoFullOptions): Renderer.RenderRule {
+    return (tokens, idx) => {
+        const videoID = md.utils.escapeHtml((tokens[idx] as VideoToken).videoID);
+        const service = md.utils.escapeHtml((tokens[idx] as VideoToken).service).toLowerCase();
+        const checkUrl =
+            /http(?:s?):\/\/(?:www\.)?[a-zA-Z0-9-:.]{1,}\/render(?:\/)?[a-zA-Z0-9.&;?=:%]{1,}url=http(?:s?):\/\/[a-zA-Z0-9 -:.]{1,}\/[a-zA-Z0-9]{1,5}\/\?[a-zA-Z0-9.=:%]{1,}/;
+        let num;
+
+        if (service === VideoService.Osf && videoID) {
+            num = Math.random() * 0x10000;
+
+            if (videoID.match(checkUrl)) {
+                return (
+                    '<div id="' +
+                    num +
+                    '" class="mfr mfr-file"></div><script>' +
+                    '$(document).ready(function () {new mfr.Render("' +
+                    num +
+                    '", "' +
+                    videoID +
+                    '");' +
+                    '    }); </script>'
+                );
+            }
+            return (
+                '<div id="' +
+                num +
+                '" class="mfr mfr-file"></div><script>' +
+                '$(document).ready(function () {new mfr.Render("' +
+                num +
+                '", "https://mfr.osf.io/' +
+                'render?url=https://osf.io/' +
+                videoID +
+                '/?action=download%26mode=render");' +
+                '    }); </script>'
+            );
+        }
+
+        const {width, height} = options[service as VideoService];
+
+        return videoID === ''
+            ? ''
+            : '<div class="embed-responsive embed-responsive-16by9"><iframe class="embed-responsive-item ' +
+                  service +
+                  '-player" type="text/html" width="' +
+                  width +
+                  '" height="' +
+                  height +
+                  '" src="' +
+                  options.url(service, videoID, options) +
+                  '" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe></div>';
+    };
+}
+
+const EMBED_REGEX = /@\[([a-zA-Z].+)]\([\s]*(.*?)[\s]*[)]/im;
+function videoEmbed(md: MarkdownIt, _options: VideoFullOptions): ParserInline.RuleInline {
+    return (state, silent) => {
+        const theState = state;
+        const oldPos = state.pos;
+
+        if (
+            state.src.charCodeAt(oldPos) !== 0x40 /* @ */ ||
+            state.src.charCodeAt(oldPos + 1) !== 0x5b /* [ */
+        ) {
+            return false;
+        }
+
+        const match = EMBED_REGEX.exec(state.src.slice(state.pos, state.src.length));
+
+        if (!match || match.length < 3) {
+            return false;
+        }
+
+        const service = match[1];
+        const videoID = parseVideoUrl(service, match[2]);
+
+        if (videoID === false) {
+            return false;
+        }
+
+        const serviceStart = oldPos + 2;
+        const serviceEnd = md.helpers.parseLinkLabel(state, oldPos + 1, false);
+
+        //
+        // We found the end of the link, and know for a fact it's a valid link;
+        // so all that's left to do is to call tokenizer.
+        //
+        if (!silent) {
+            theState.pos = serviceStart;
+            // @ts-expect-error
+            theState.service = theState.src.slice(serviceStart, serviceEnd);
+            const newState = new theState.md.inline.State(service, theState.md, theState.env, []);
+            newState.md.inline.tokenize(newState);
+
+            const token = theState.push('video', '', 0);
+            (token as VideoToken).videoID = videoID;
+            (token as VideoToken).service = service;
+            token.level = theState.level;
+        }
+
+        theState.pos += theState.src.indexOf(')', theState.pos);
+        return true;
+    };
+}
+
+export = video;

package/src/transform/plugins/video/parsers.ts

@@ -0,0 +1,65 @@
+import {VideoService} from './const';
+
+const ytRegex = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
+export function youtubeParser(url: string) {
+    const match = url.match(ytRegex);
+    return match && match[7].length === 11 ? match[7] : url;
+}
+
+const vimeoRegex =
+    /https?:\/\/(?:www\.|player\.)?vimeo.com\/(?:channels\/(?:\w+\/)?|groups\/([^/]*)\/videos\/|album\/(\d+)\/video\/|)(\d+)(?:$|\/|\?)/;
+export function vimeoParser(url: string) {
+    const match = url.match(vimeoRegex);
+    return match && typeof match[3] === 'string' ? match[3] : url;
+}
+
+const vineRegex = /^http(?:s?):\/\/(?:www\.)?vine\.co\/v\/([a-zA-Z0-9]{1,13}).*/;
+export function vineParser(url: string) {
+    const match = url.match(vineRegex);
+    return match && match[1].length === 11 ? match[1] : url;
+}
+
+const preziRegex = /^https:\/\/prezi.com\/(.[^/]+)/;
+export function preziParser(url: string) {
+    const match = url.match(preziRegex);
+    return match ? match[1] : url;
+}
+
+// TODO: Write regex for staging and local servers.
+const mfrRegex =
+    /^http(?:s?):\/\/(?:www\.)?mfr\.osf\.io\/render\?url=http(?:s?):\/\/osf\.io\/([a-zA-Z0-9]{1,5})\/\?action=download/;
+export function mfrParser(url: string) {
+    const match = url.match(mfrRegex);
+    return match ? match[1] : url;
+}
+
+export function parseVideoUrl(service: string, url: string): string | false {
+    let videoID = '';
+
+    switch (service.toLowerCase()) {
+        case VideoService.YouTube:
+            videoID = youtubeParser(url);
+            break;
+        case VideoService.Vimeo:
+            videoID = vimeoParser(url);
+            break;
+        case VideoService.Vine:
+            videoID = vineParser(url);
+            break;
+        case VideoService.Prezi:
+            videoID = preziParser(url);
+            break;
+        case VideoService.Osf:
+            videoID = mfrParser(url);
+            break;
+        default:
+            return false;
+    }
+
+    // If the videoID field is empty, regex currently make it the close parenthesis.
+    if (videoID === ')') {
+        videoID = '';
+    }
+
+    return videoID;
+}

package/src/transform/plugins/video/types.ts

@@ -0,0 +1,27 @@
+import type Token from 'markdown-it/lib/token';
+import type {VideoService} from './const';
+
+export type VideoToken = Token & {
+    service: string;
+    videoID: string;
+};
+
+export type VideoServicesOptions = {
+    [VideoService.YouTube]: {width: number; height: number};
+    [VideoService.Vimeo]: {width: number; height: number};
+    [VideoService.Vine]: {width: number; height: number; embed: 'simple' | string};
+    [VideoService.Prezi]: {width: number; height: number};
+    [VideoService.Osf]: {width: string; height: string};
+};
+
+export type VideoFullOptions = VideoServicesOptions & {
+    url: VideoUrlFn;
+};
+
+export type VideoPluginOptions = Partial<VideoFullOptions>;
+
+export type VideoUrlFn = (
+    service: string,
+    videoID: string,
+    options: VideoServicesOptions,
+) => string;

package/src/transform/plugins/video/utils.ts

@@ -0,0 +1,24 @@
+import type {VideoUrlFn} from './types';
+
+export const videoUrl: VideoUrlFn = (service, videoID, options) => {
+    switch (service) {
+        case 'youtube':
+            return 'https://www.youtube.com/embed/' + videoID;
+        case 'vimeo':
+            return 'https://player.vimeo.com/video/' + videoID;
+        case 'vine':
+            return 'https://vine.co/v/' + videoID + '/embed/' + options.vine.embed;
+        case 'prezi':
+            return (
+                'https://prezi.com/embed/' +
+                videoID +
+                '/?bgcolor=ffffff&lock_to_path=0&autoplay=0&autohide_ctrls=0&' +
+                'landing_data=bHVZZmNaNDBIWnNjdEVENDRhZDFNZGNIUE43MHdLNWpsdFJLb2ZHanI5N1lQVHkxSHFxazZ0UUNCRHloSXZROHh3PT0&' +
+                'landing_sign=1kD6c0N6aYpMUS0wxnQjxzSqZlEB8qNFdxtdjYhwSuI'
+            );
+        case 'osf':
+            return 'https://mfr.osf.io/render?url=https://osf.io/' + videoID + '/?action=download';
+        default:
+            return service;
+    }
+};

package/src/transform/plugins.ts

@@ -0,0 +1,35 @@
+import type {MarkdownItPluginCb} from './plugins/typings';
+
+import meta from './plugins/meta';
+import deflist from './plugins/deflist';
+import cut from './plugins/cut';
+import notes from './plugins/notes';
+import anchors from './plugins/anchors';
+import tabs from './plugins/tabs';
+import code from './plugins/code';
+import sup from './plugins/sup';
+import video from './plugins/video';
+import monospace from './plugins/monospace';
+import yfmTable from './plugins/table';
+import file from './plugins/file';
+import imsize from './plugins/imsize';
+import term from './plugins/term';
+
+const defaultPlugins = [
+    meta,
+    deflist,
+    cut,
+    notes,
+    anchors,
+    tabs,
+    code,
+    sup,
+    video,
+    monospace,
+    yfmTable,
+    file,
+    imsize,
+    term,
+] as MarkdownItPluginCb[];
+
+export = defaultPlugins;