transform.js

var falafel = require('falafel')
var duplexify = require('duplexify')
var through = require('through2')
var concat = require('concat-stream')
var from = require('from2')
var gdeps = require('glslify-deps')
var glslBundle = require('glslify-bundle')
var path = require('path')
var seval = require('static-eval')
var resolve = require('resolve')
var gresolve = require('glsl-resolve')
var extend = require('xtend')

var glslfile0 = path.join(__dirname,'index.js')
var glslfile1 = path.join(__dirname,'index')
var parseOptions = {
  ecmaVersion: 10,
  sourceType: 'module',
  allowReturnOutsideFunction: true,
  allowImportExportEverywhere: true,
  allowHashBang: true
}

module.exports = function (file, opts) {
  if (path.extname(file) == '.json') return through()
  if (!opts) opts = {}
  var dir = path.dirname(file)
  var glvar = null, mdir = dir
  var evars = {
    __dirname: dir,
    __filename: file,
    require: { resolve: resolve }
  }

  var sharedPosts = []
  var sharedTransforms = updateSharedTransforms()

  function evaluate (expr) {
    return seval(expr, evars)
  }

  function updateSharedTransforms () {
    ;[]
      .concat(opts.post || [])
      .concat(opts.p || [])
      .forEach(function (post) {
        post = Array.isArray(post) ? post : [post]
        var name = post[0]
        var opts = post[1] || {}
        sharedPosts.push({ name: name, opts: opts, base: process.cwd() })
      })

    return []
      .concat(opts.transform || [])
      .concat(opts.t || [])
      .filter(function (tr) {
        var name = tr[0]
        var opts = tr[1] || {}
        if (!opts.post) return true
        sharedPosts.push({ name: name, opts: opts, base: process.cwd() })
      })
  }

  var d = duplexify()
  var out = from(function () {})
  d.setReadable(out)
  d.setWritable(concat({ encoding: 'string' }, function (src) {
    var pending = 1
    if (src.indexOf('glslify') === -1) {
      out.push(src)
      out.push(null)
      return
    }

    try { var fout = falafel(src, parseOptions, onnode) }
    catch (err) { return d.emit('error', err) }
    done()

    function onnode (node) {
      // case: path = require('path')
      if (isRequirePath(node)) {
        evars.path = path
      } else if (isRequireGlslify(node, dir)) {
        var p = node.parent.parent, pp = p.parent
        if (isReqCallExpression(p, pp)) {
          // case: require('glslify')(...)
          pending++
          callexpr(p, done)
        } else if (p.type === 'AssignmentExpression') {
          // case: var glvar;
          //       glvar = require('glslify')
          glvar = p.left.name
        } else if (p.type === 'VariableDeclarator') {
          // case: var glvar = require('glslify')
          glvar = p.id.name
        } else if (isReqCallFile(p, pp)) {
          // case: require('glslify').file(...)
          pending++
          callfile(pp, pp.callee.object.source(), done)
        } else if (isReqCallCompile(p, pp)) {
          // case: require('glslify').compile(...)
          pending++
          callcompile(pp, pp.callee.object.source(), done)
        } else if (p.type === 'TaggedTemplateExpression') {
          // case: require('glslify')`...`
          pending++
          tagexpr(p, done)
        }
      } else if (isCallExpression(node, glvar)) {
        // case: glvar(...)
        pending++
        callexpr(node.parent, done)
      } else if (isTagExpression(node, glvar)) {
        // case: glvar`...`
        pending++
        tagexpr(node, done)
      } else if (isCallFile(node, glvar)) {
        // case: glvar.file(...)
        pending++
        callfile(node.parent.parent, glvar, done)
      } else if (isCallCompile(node, glvar)) {
        // case: glvar.compile(...)
        pending++
        callcompile(node.parent.parent, glvar, done)
      }
    }

    function tagexpr (node, cb) {
      var q = node.quasi
      var shadersrc = q.quasis.map(function (s) {
        return s.value.raw + '__GLX_PLACEHOLDER__'
      }).join('')
      var d = createDeps({ cwd: mdir })
      d.inline(shadersrc, mdir, function (err, deps) {
        if (err) return d.emit('error', err)
        applyPostTransforms(null, deps, {}, function (err, bsrc) {
          if (err) return d.emit('error', err)
          node.update(node.tag.source() + '('
            + JSON.stringify(bsrc.split('__GLX_PLACEHOLDER__'))
            + [''].concat(q.expressions.map(function (e) {
              return e.source()
            })).join(',')
            + ')')
          cb()
        })
      })
    }
    function callexpr (p, cb) {
      var marg = evaluate(p.arguments[0])
      var mopts = p.arguments[1] ? evaluate(p.arguments[1]) || {} : {}
      var d = createDeps({ cwd: mdir })
      var resolved = null
      if (/(void\s+main\s?\(.*\)|\n)/.test(marg)) { // source string
        d.inline(marg, mdir, ondeps)
      } else gresolve(marg, { basedir: mdir }, function (err, res) {
        if (err) d.emit('error', err)
        else d.add(resolved = res, ondeps)
      })
      function ondeps (err, deps) {
        if (err) return d.emit('error', err)
        applyPostTransforms(resolved, deps, mopts, function (err, bsrc) {
          if (err) return d.emit('error', err)
          p.update(p.callee.source()+'(['+JSON.stringify(bsrc)+'])')
          cb()
        })
      }
    }
    function callcompile (p, glvar, cb) {
      var mfile = evaluate(p.arguments[0])
      var mopts = p.arguments[1] ? evaluate(p.arguments[1]) || {} : {}
      var d = createDeps({ cwd: mdir })
      d.inline(mfile, mdir, ondeps)
      function ondeps (err, deps) {
        if (err) return d.emit('error', err)
        applyPostTransforms(null, deps, mopts, function (err, bsrc) {
          if (err) return d.emit('error', err)
          p.update(glvar + '([' + JSON.stringify(bsrc) + '])')
          cb()
        })
      }
    }
    function callfile (p, glvar, cb) {
      var mfile = evaluate(p.arguments[0])
      gresolve(mfile, { basedir: mdir }, function (err, res) {
        if (err) return d.emit('error', err)
        var mopts = p.arguments[1] ? evaluate(p.arguments[1]) || {} : {}
        var d = createDeps({ cwd: path.dirname(res) })
        d.add(res, ondeps)
        function ondeps (err, deps) {
          if (err) return d.emit('error', err)
          applyPostTransforms(res, deps, mopts, function (err, bsrc) {
            if (err) return d.emit('error', err)
            p.update(glvar + '([' + JSON.stringify(bsrc) + '])')
            cb()
          })
        }
      })
    }
    function done () {
      if (--pending === 0) {
        out.push(fout.toString())
        out.push(null)
      }
    }
  }))
  return d

  function createDeps (opts) {
    var depper = gdeps(opts)
    depper.on('error', function (err) { d.emit('error', err) })
    depper.on('file', function (file) { d.emit('file', file) })
    var transforms = sharedTransforms
    transforms = Array.isArray(transforms) ? transforms : [transforms]
    transforms.forEach(function(transform) {
      transform = Array.isArray(transform) ? transform : [transform]
      var name = transform[0]
      var opts = transform[1] || {}
      if (!opts.post) {
        depper.transform(name, extend({}, opts))
      }
    })
    return depper
  }

  function applyPostTransforms (rootFile, deps, mopts, done) {
    var source = glslBundle(deps)
    var localPosts = [].concat(mopts.transform || []).concat(mopts.t || [])
      .map(function (transform) {
        transform = Array.isArray(transform) ? transform : [transform]
        var name = transform[0]
        var opts = transform[1] || {}
        return opts.post && { name: name, opts: opts, base: path.dirname(rootFile) }
      })
      .filter(Boolean)
      .concat(sharedPosts)
      .map(function (tr) {
        if (typeof tr.name === "function") {
          tr.tr = tr.name
        } else {
          var target = resolve.sync(tr.name, { basedir: tr.base || mdir })
          tr.tr = require(target)
        }
        return tr
      })

    gdeps.prototype.applyTransforms(rootFile, source, localPosts, done);
  }
}

function isRequirePath (node) {
  return node.type === 'Identifier' && node.name === 'require'
    && node.parent.type === 'CallExpression'
    && node.parent.arguments[0]
    && node.parent.arguments[0].type === 'Literal'
    && node.parent.arguments[0].value === 'path'
    && node.parent.parent.type === 'VariableDeclarator'
}

function isRequireGlslify (node, dir) {
  return node.type === 'Identifier' && node.name === 'require'
    && node.parent.type === 'CallExpression'
    && node.parent.arguments[0]
    && node.parent.arguments[0].type === 'Literal'
    && (/^glslify(?:\/index(?:\.js)?)?/.test(node.parent.arguments[0].value)
    || path.resolve(dir,node.parent.arguments[0].value) === __dirname
    || path.resolve(dir,node.parent.arguments[0].value) === glslfile0
    || path.resolve(dir,node.parent.arguments[0].value) === glslfile1)
}

function isReqCallExpression (node, parent) {
  return node.type === 'CallExpression'
    && parent.type === 'CallExpression'
}

function isReqCallFile (node, parent) {
  return node.type === 'MemberExpression'
    && node.property.name === 'file'
    && parent.type === 'CallExpression'
}

function isReqCallCompile (node, parent) {
  return node.type === 'MemberExpression'
    && node.property.name === 'compile'
    && parent.type === 'CallExpression'
}

function isCallExpression (node, glvar) {
  return node.type === 'Identifier'
    && node.name === glvar
    && node.parent.type === 'CallExpression'
}

function isTagExpression (node, glvar) {
  return node.type === 'TaggedTemplateExpression'
    && node.tag.name === glvar
}

function isCallFile (node, glvar) {
  return node.type === 'Identifier' && node.name === glvar
    && node.parent.type === 'MemberExpression'
    && node.parent.property.name === 'file'
    && node.parent.parent.type === 'CallExpression'
    && node.parent.parent.arguments[0]
}

function isCallCompile (node, glvar) {
  return node.type === 'Identifier' && node.name === glvar
    && node.parent.type === 'MemberExpression'
    && node.parent.property.name === 'compile'
    && node.parent.parent.type === 'CallExpression'
    && node.parent.parent.arguments[0]
}