gulp-useref-import/index.js

Gulp plugin for useref with html5 import support

"use strict";

const _ = require("lodash"),
  gulp = require("gulp"),
  path = require("path"),
  fs = require("fs"),
  useref = require("gulp-useref"),
  cheerio = require('cheerio'),
  vinyl = require("vinyl"),
  crypto = require("crypto")

module.exports = function (opts) {

  if (!opts)
    opts = {}
  opts.base = path.normalize(opts.base || "")
  const stream = useref(_.extend(opts, {
    import: function importer (content, target, options, alternateSearchPath, basePath) {
      opts.basePath = basePath
      let elements = cheerio.load(content).root().children(),
        parsed = parseContent(elements, undefined, opts)
      if (opts.fingerprint) {
        let sum = crypto.createHash('md5').update(parsed.buffer).digest("hex")
        target = target.replace(".js", `-${sum}.js`).replace(".css", `-${sum}.css`)
      }
      let filepath = path.join(opts.base, target),
        file = new vinyl({
          base: opts.relativePath || basePath,
          path: filepath,
          contents: parsed.buffer,
        })
      //console.log("filepath::", filepath)
      //console.log("basepath::", basePath)
      //console.log("target::", target)
      stream.push(file)
      switch (parsed.type) {
        case "script":
          return `<script src="${target}"></script>`
        case "stylesheet":
          return `<link rel="stylesheet" type="text/css" href="${target}"></link>`
        default:
          return content
      }
    }
  }))
  return stream
}

function parseContent (elements, parsed, opts) {

  if (!parsed)
    parsed = {
      buffer: new Buffer("", "utf-8"),
      type: undefined,
    }
  _.each(elements, element => {
    let buffer
    switch (element.name) {
      case "link":
        if (element.attribs.href) {
          let filepath = getPathToResource(element.attribs.href, opts)
          switch (element.attribs.rel) {
            case "import":
              parsed = parseImport(filepath, parsed, opts)
            break;

            case "stylesheet":
              buffer = parseResource(filepath)
              parsed.type = element.attribs.rel
            break;
          }
        }
      break;

      case "script":
        if (element.attribs.src) {
          let filepath = getPathToResource(element.attribs.src, opts)
          buffer = parseResource(filepath)
          parsed.type = element.name
        }
      break;
    }
    if (buffer)
      parsed.buffer = Buffer.concat([parsed.buffer, buffer])
  })
  return parsed
}

function getPathToResource (attr, opts)  {

  return opts.base != "."
    ? path.join(opts.base, attr)
    : path.join(opts.basePath, attr)
}

function parseResource (filepath) {

  return fs.readFileSync(filepath)
}

function parseImport (filepath, parsed, opts) {

    let content = fs.readFileSync(filepath),
      elements = cheerio.load(content).root().children()
    return parseContent(elements, parsed, opts)
}