extension.js

'use strict';
var vscode = require('vscode');
var path = require('path');
var fs = require('fs');
var url = require('url');
var mdfilename = '';

function activate(context) {
  init();
  var disposable_command = vscode.commands.registerCommand('extension.markdown-pdf', function () { MarkdownPdf(); });
  context.subscriptions.push(disposable_command);

  var isConvertOnSave = vscode.workspace.getConfiguration('markdown-pdf')['convertOnSave'];
  if (isConvertOnSave) {
    var disposable_onsave = vscode.workspace.onDidSaveTextDocument(function () { MarkdownPdfOnSave(); });
    context.subscriptions.push(disposable_onsave);
  }
}
exports.activate = activate;

// this method is called when your extension is deactivated
function deactivate() {
}
exports.deactivate = deactivate;

function MarkdownPdf() {
  // check active window
  var editor = vscode.window.activeTextEditor;
  if (!editor) {
    vscode.window.showWarningMessage('No active Editor!');
    return;
  }

  // check markdown mode
  var mode = editor.document.languageId;
  if (mode != 'markdown') {
    vscode.window.showWarningMessage('It is not a markdown mode!');
    return;
  }

  mdfilename = editor.document.fileName;
  var ext = path.extname(mdfilename);
  if (!isExistsFile(mdfilename)) {
    if (editor.document.isUntitled) {
      vscode.window.showWarningMessage('Please save the file!');
      return;
    }
    vscode.window.showWarningMessage('File name does not get!');
    return;
  }

  vscode.window.setStatusBarMessage('$(markdown) Converting...');

  // convert markdown to html
  var content = convertMarkdownToHtml(mdfilename);

  // make html
  var html = makeHtml(content);

  var type = vscode.workspace.getConfiguration('markdown-pdf')['type'] || 'pdf';
  var types = ['html', 'pdf', 'png', 'jpeg'];
  var filename = '';
  // export html
  if (type == 'html') {
    filename = mdfilename.replace(ext, '.' + type);
    filename = getOutputDir(filename);
    exportHtml(html, filename);
  // export pdf/png/jpeg
  } else if (types.indexOf(type) >= 1) {
    filename = mdfilename.replace(ext, '.' + type);
    filename = getOutputDir(filename);
    exportPdf(html, filename);

    var debug = vscode.workspace.getConfiguration('markdown-pdf')['debug'] || false;
    if (debug) {
      var f = path.parse(mdfilename);
      filename = path.join(f.dir, f.name + '_debug.html');
      filename = getOutputDir(filename);
      exportHtml(html, filename);
    }
  } else {
    vscode.window.showErrorMessage('ERROR: Supported formats: html, pdf, png, jpeg.');
    vscode.window.setStatusBarMessage('');
    return;
  }
}

function MarkdownPdfOnSave () {
  var editor = vscode.window.activeTextEditor;
  var mode = editor.document.languageId;
  if (mode != 'markdown') {
    return;
  }
  if (!isMarkdownPdfOnSaveExclude()) {
    MarkdownPdf();
  }
}

function isMarkdownPdfOnSaveExclude () {
  var editor = vscode.window.activeTextEditor;
  var filename = path.basename(editor.document.fileName);
  var patterns = vscode.workspace.getConfiguration('markdown-pdf')['convertOnSaveExclude'] || '';
  var pattern;
  var i;
  if (patterns && Array.isArray(patterns) && patterns.length > 0) {
    for (i = 0; i < patterns.length; i++) {
      pattern = patterns[i];
      var re = new RegExp(pattern);
      if (re.test(filename)) {
        return true;
      }
    }
  }
  return false;
}

/*
 * convert markdown to html (markdown-it)
 */
function convertMarkdownToHtml(filename) {
  var hljs = require('highlight.js');
  var breaks = vscode.workspace.getConfiguration('markdown-pdf')['breaks'];
  try {
    var md = require('markdown-it')({
      html: true,
      breaks: breaks,
      highlight: function (str, lang) {
        if (lang && hljs.getLanguage(lang)) {
          try {
            str = hljs.highlight(lang, str, true).value;
          } catch (e) {
            str = md.utils.escapeHtml(str);

            vscode.window.showErrorMessage('ERROR: markdown-it:highlight');
            vscode.window.showErrorMessage(e.message);
            vscode.window.setStatusBarMessage('');
          }
        } else {
          str = md.utils.escapeHtml(str);
        }
        return '<pre class="hljs"><code><div>' + str + '</div></code></pre>';
      }
    });
  } catch (e) {
    vscode.window.showErrorMessage('ERROR: require(\'markdown-it\')');
    vscode.window.showErrorMessage(e.message);
    vscode.window.setStatusBarMessage('');
  }

  // convert the img src of the markdown
  var type = vscode.workspace.getConfiguration('markdown-pdf')['type'] || 'pdf';
  var cheerio = require('cheerio');
  var defaultRender = md.renderer.rules.image;
  md.renderer.rules.image = function (tokens, idx, options, env, self) {
    var token = tokens[idx];
    var href = token.attrs[token.attrIndex('src')][1];
    if (type === 'html') {
      href = decodeURIComponent(href).replace(/("|')/g, '');
    } else {
      href = convertImgPath(href, filename);
    }
    token.attrs[token.attrIndex('src')][1] = href;
    // pass token to default renderer.
    return defaultRender(tokens, idx, options, env, self);
  };

  if (type !== 'html') {
    // convert the img src of the html
    md.renderer.rules.html_block = function (tokens, idx) {
      var html = tokens[idx].content;
      var $ = cheerio.load(html);
      $('img').each(function () {
        var src = $(this).attr('src');
        var href = convertImgPath(src, filename);
        $(this).attr('src', href);
      });
      return $.html();
    };
  }
  
  
  // plantuml
  md.use(require('markdown-it-plantuml'));

  // fence plantuml should render with markdown-it-plantuml
  // otherwise use the default renderer.
  var defaultFenceRender = md.renderer.rules.fence;
  md.renderer.rules.fence = function (tokens, idx, options, env, self) {
    if (tokens[idx].info === 'plantuml') {
      var plantuml = tokens[idx].content;
      return md.render(plantuml);
    }

    // pass token to default fence renderer
    return defaultFenceRender(tokens, idx, options, env, self);
  }

  // checkbox
  md.use(require('markdown-it-checkbox'));

  // Toc
  var f = vscode.workspace.getConfiguration('markdown-pdf')['table-of-contents'];
  if (f) {
    md.use(require("markdown-it-anchor")); // Optional, but makes sense as you really want to link to something
    md.use(require("markdown-it-table-of-contents"),f);
  }


  // emoji
  var f = vscode.workspace.getConfiguration('markdown-pdf')['emoji'];
  if (f) {
    var emojies_defs = require(path.join(__dirname, 'data', 'emoji.json'));
    try {
      var options = {
        defs: emojies_defs
      };
    } catch (e) {
      vscode.window.showErrorMessage('ERROR: markdown-it-emoji:options');
      vscode.window.showErrorMessage(e.message);
      vscode.window.setStatusBarMessage('');
    }
    md.use(require('markdown-it-emoji'), options);
    md.renderer.rules.emoji = function(token, idx) {
      var emoji = token[idx].markup;
      var emojipath = path.join(__dirname, 'node_modules', 'emoji-images', 'pngs', emoji + '.png');
      var emojidata = readFile(emojipath, null).toString('base64');
      if (emojidata) {
        return '<img class="emoji" alt="' + emoji + '" src="data:image/png;base64,' + emojidata + '" />';
      } else {
        return ':' + emoji + ':';
      }
    };
  }
  return md.render(fs.readFileSync(filename, 'utf-8'));
}

/*
 * make html
 */
function makeHtml(data) {
  // read styles
  var style = '';
  style += readStyles();

  // read template
  var filename = path.join(__dirname, 'template', 'template.html');
  var template = readFile(filename);

  // compile template
  var mustache = require('mustache');

  try {
    var view = {
      style: style,
      content: data
    };
  } catch (e) {
    vscode.window.showErrorMessage('ERROR: mustache:view');
    vscode.window.showErrorMessage(e.message);
  }

  return mustache.render(template, view);
}

/*
 * export a html to a html file
 */
function exportHtml(data, filename) {
  vscode.window.setStatusBarMessage('$(markdown) Converting...');
  var StatusbarMessageTimeout = vscode.workspace.getConfiguration('markdown-pdf')['StatusbarMessageTimeout'];
  fs.writeFile(filename, data, 'utf-8', function(err) {
    if (err) {
      vscode.window.showErrorMessage('ERROR: exportHtml()');
      vscode.window.showErrorMessage(err.message);
      vscode.window.setStatusBarMessage('');
      return;
    }
    vscode.window.setStatusBarMessage('');
    vscode.window.setStatusBarMessage('$(markdown) OUTPUT : ' + filename, StatusbarMessageTimeout);
  });
}

/*
 * export a html to a pdf file (html-pdf)
 */
function exportPdf(data, filename) {
  vscode.window.setStatusBarMessage('$(markdown) Converting...');
  var StatusbarMessageTimeout = vscode.workspace.getConfiguration('markdown-pdf')['StatusbarMessageTimeout'];
  var phantomPath = getPhantomjsPath();
  if (!checkPhantomjs()) {
    installPhantomjsBinary();
  }
  if (!checkPhantomjs()) {
    vscode.window.showErrorMessage('ERROR: phantomjs binary does not exist: ' + phantomPath);
    vscode.window.setStatusBarMessage('');
    return;
  }

  var htmlpdf = require('html-pdf');
  try {
    var options = {
      "format": vscode.workspace.getConfiguration('markdown-pdf')['format'] || 'A4',
      "orientation": vscode.workspace.getConfiguration('markdown-pdf')['orientation'] || 'portrait',
      "border": {
        "top":  vscode.workspace.getConfiguration('markdown-pdf')['border']['top'] || '', 
        "right": vscode.workspace.getConfiguration('markdown-pdf')['border']['right'] || '',
        "bottom": vscode.workspace.getConfiguration('markdown-pdf')['border']['bottom'] || '',
        "left": vscode.workspace.getConfiguration('markdown-pdf')['border']['left'] || ''
      },
      "type": vscode.workspace.getConfiguration('markdown-pdf')['type'] || 'pdf',
      "quality": vscode.workspace.getConfiguration('markdown-pdf')['quality'] || 90,
      "header": {
        "height": vscode.workspace.getConfiguration('markdown-pdf')['header']['height'] || '',
        "contents": vscode.workspace.getConfiguration('markdown-pdf')['header']['contents'] || ''
      },
      "footer": {
        "height": vscode.workspace.getConfiguration('markdown-pdf')['footer']['height'] || '',
        "contents": vscode.workspace.getConfiguration('markdown-pdf')['footer']['contents'] || ''
      },
      "phantomPath": phantomPath,
      "renderDelay":  vscode.workspace.getConfiguration('markdown-pdf')['renderDelay'] || ''
    };
  } catch (e) {
    vscode.window.showErrorMessage('ERROR: html-pdf:options');
    vscode.window.showErrorMessage(e.message);
    vscode.window.setStatusBarMessage('');
  }

  try {
    htmlpdf.create(data, options).toBuffer(function(err, buffer) {
      fs.writeFile(filename, buffer, function(err) {
        if (err) {
          vscode.window.showErrorMessage('ERROR: exportPdf()');
          vscode.window.showErrorMessage(err.message);
          vscode.window.setStatusBarMessage('');
          return;
        }
        vscode.window.setStatusBarMessage('');
        vscode.window.setStatusBarMessage('$(markdown) OUTPUT : ' + filename, StatusbarMessageTimeout);
      });
    });
  } catch (e) {
    vscode.window.showErrorMessage('ERROR: htmlpdf.create()');
    vscode.window.showErrorMessage(e.message);
    vscode.window.setStatusBarMessage('');
  }
}

function isExistsFile(filename) {
  if (filename.length === 0) {
    return false;
  }
  try {
    if (fs.statSync(filename).isFile()) {
      return true;
    }
  } catch (e) {
    console.warn(e.message);
    return false;
  }
}

function isExistsDir(dirname) {
  if (dirname.length === 0) {
    return false;
  }
  try {
    if (fs.statSync(dirname).isDirectory()) {
      return true;
    } else {
      console.warn('undefined') ;
      return false;
    }
  } catch (e) {
    console.warn('false : ' + e.message);
    return false;
  }
}

function getOutputDir(filename) {
  var output_dir = vscode.workspace.getConfiguration('markdown-pdf')['outputDirectory'] || '';
  if (output_dir.length !== 0) {
    if (isExistsDir(output_dir)) {
      return path.join(output_dir, path.basename(filename));
    } else {
      vscode.window.showWarningMessage('Output directory does not exist! (markdown-pdf.outputDirectory) : ' + output_dir);
      return filename;
    }
  }
  return filename;
}

function readFile(filename, encode) {
  if (filename.length === 0) {
    return '';
  }
  if (!encode && encode !== null) {
    encode = 'utf-8';
  }
  if (filename.indexOf('file://') === 0) {
    if (process.platform === 'win32') {
      filename = filename.replace(/^file:\/\/\//, '')
                 .replace(/^file:\/\//, '');
    } else {
      filename = filename.replace(/^file:\/\//, '');
    }
  }
  if (isExistsFile(filename)) {
    return fs.readFileSync(filename, encode);
  } else {
    return '';
  }
}

function convertImgPath(src, filename) {
  var href = decodeURIComponent(src);
  href = href.replace(/("|')/g, '')
         .replace(/\\/g, '/')
         .replace(/#/g, '%23');
  var protocol = url.parse(href).protocol;
  if (protocol === 'file:' && href.indexOf('file:///') !==0) {
    return href.replace(/^file:\/\//, 'file:///');
  } else if (protocol === 'file:') {
    return href;
  } else if (!protocol || path.isAbsolute(href)) {
    href = path.resolve(path.dirname(filename), href).replace(/\\/g, '/')
                                                     .replace(/#/g, '%23');
    if (href.indexOf('//') === 0) {
      return 'file:' + href;
    } else if (href.indexOf('/') === 0) {
      return 'file://' + href;
    } else {
      return 'file:///' + href;
    }
  } else {
    return src;
  }
}

function makeCss(filename) {
  var css = readFile(filename);
  if (css) {
    return '\n<style>\n' + css + '\n</style>\n';
  } else {
    return '';
  }
}

function makeJs(filename) {
  var js = readFile(filename);
  if (js) {
    return '\n<script>\n' + js + '\n</script>\n';
  } else {
    return '';
  }
}

function readStyles() {
  var style = '';
  var styles = '';
  var filename = '';
  var i;

  // 1. read the style of the vscode.
  //filename = path.join(__dirname, 'js', 'MathJax.js');
  //style += makeJs(filename);
  var type = vscode.workspace.getConfiguration('markdown-pdf')['type'] || 'pdf';
  style += '<script type="text/javascript" src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"> </script>\n';
  style += '<script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [[\'$\',\'$\'], [\'\\\\(\',\'\\\\)\']]}});</script>\n';
  if(type!='html'){
    style += '<script type="text/x-mathjax-config">MathJax.Hub.Config({"HTML-CSS": {"availableFonts":["TeX"],"scale": 150}});</script>\n';
  }
  filename = path.join(__dirname, 'styles', 'markdown.css');
  style += makeCss(filename);
  
  // 2. read the style of the markdown.styles setting.
  styles = vscode.workspace.getConfiguration('markdown')['styles'];
  if (styles && Array.isArray(styles) && styles.length > 0) {
    for (i = 0; i < styles.length; i++) {
      var href = filename = styles[i];
      var protocol = url.parse(href).protocol;
      if (protocol === 'http:' || protocol === 'https:') {
        style += '<link rel=\"stylesheet\" href=\"" + href + "\" type=\"text/css\">';
      } else if (protocol === 'file:') {
        style += makeCss(filename);
      }
    }
  }

  // 3. read the style of the highlight.js.
  var highlightStyle = vscode.workspace.getConfiguration('markdown-pdf')['highlightStyle'] || '';
  var ishighlight = vscode.workspace.getConfiguration('markdown-pdf')['highlight'];
  if (ishighlight) {
    if (highlightStyle) {
      var css = vscode.workspace.getConfiguration('markdown-pdf')['highlightStyle'] || 'github.css';
      filename = path.join(__dirname, 'node_modules', 'highlight.js', 'styles', css);
      style += makeCss(filename);
    } else {
      filename = path.join(__dirname, 'styles', 'tomorrow.css');
      style += makeCss(filename);
    }
  }

  // 4. read the style of the markdown-pdf.
  filename = path.join(__dirname, 'styles', 'markdown-pdf.css');
  style += makeCss(filename);

  // 5. read the style of the markdown-pdf.styles settings.
  styles = vscode.workspace.getConfiguration('markdown-pdf')['styles'] || '';
  if (styles && Array.isArray(styles) && styles.length > 0) {
    for (i = 0; i < styles.length; i++) {
      filename = styles[i];
      if (!path.isAbsolute(filename)) {
        if (vscode.workspace.rootPath == undefined) {
          filename = path.join(path.dirname(mdfilename), filename);
        } else {
          filename = path.join(vscode.workspace.rootPath, filename);         
        }
      }
      style += makeCss(filename);
    }
  }

  return style;
}

function getPhantomjsPath () {
  // for reload phantomjs binary path
  delete require.cache[path.join(__dirname, 'node_modules', 'phantomjs-prebuilt', 'lib', 'location.js')];
  delete require.cache[path.join(__dirname, 'node_modules', 'phantomjs-prebuilt', 'lib', 'phantomjs.js')];
  // load phantomjs binary path
  var phantomPath = require(path.join(__dirname, 'node_modules', 'phantomjs-prebuilt', 'lib', 'phantomjs')).path;
  return phantomPath;
}

function checkPhantomjs () {
  var phantomPath = getPhantomjsPath();
  if (isExistsFile(phantomPath)) {
    return true;
  } else {
    return false;
  }
}

function installPhantomjsBinary() {
  // which npm
  var which = require('which');
  var npm = '';
  try {
    npm = which.sync('npm');
  } catch (e) {
    console.warn(e.message);
  }

  // which node
  var node = '';
  try {
    node = which.sync('node');
  } catch (e) {
    console.warn(e.message);
  }

  // npm rebuild phantomjs-prebuilt
  var execSync = require('child_process').execSync;
  if (isExistsFile(npm) && isExistsFile(node)) {
    try {
      var std = execSync('npm rebuild phantomjs-prebuilt', {cwd: __dirname});
      console.log(std.toString());
    } catch (e) {
      vscode.window.showErrorMessage('ERROR: "npm rebuild phantomjs-prebuilt"');
      vscode.window.showErrorMessage(e.message);
      vscode.window.setStatusBarMessage('');
    }
  } else {
  // node_modules/phantomjs-prebuilt/install.js
    var install = path.join(__dirname, 'node_modules', 'phantomjs-prebuilt', 'install.js').replace(/\\/g, '/');
    try {
      if (isExistsFile(install)) {
        require(install);
      }
    } catch (e) {
      console.error(e.message);
    }
  }

  if (checkPhantomjs()) {
    return;
  }
}

function init () {
  if (!checkPhantomjs()) {
    installPhantomjsBinary();
  }
}

// for './node_modules/phantomjs-prebuilt/install.js'
// 'An extension called process.exit() and this was prevented.'
process.exit = function() {
  console.info('process.exit');
};