const isMemberExpression = require('estree-is-member-expression')

const cssResolve = require('style-resolve').sync

const transformAst = require('transform-ast')

const staticEval = require('static-eval')

const parse = require('fast-json-parse')

const findup = require('@choojs/findup')

const mapLimit = require('map-limit')

const through = require('through2')

const path = require('path')

const fs = require('fs')

const sheetify = require('./index')

const SUPPORTED_SYNONYMS = require('./lib/supported-synonyms')

module.exports = transform

function isBabelTemplateDefinition (node) {

return node.type === 'CallExpression' &&

node.callee.type === 'Identifier' && node.callee.name === '_taggedTemplateLiteral'

}

function isBubleTemplateDefinition (node) {

return node.type === 'CallExpression' &&

isMemberExpression(node.callee, 'Object.freeze') &&

node.arguments[0] && node.arguments[0].type === 'ArrayExpression' &&

node.arguments[0].elements.every(function (el) { return el.type === 'Literal' })

}

// inline sheetify transform for browserify

// obj -> (str, opts) -> str

function transform (filename, options) {

if (/\.json$/i.test(filename)) return through()

const opts = Object.assign({}, options || {

basedir: process.cwd(),

transform: [],

out: ''

})

opts.transform = [].concat(opts.transform || []).concat(opts.t || []).map(function (plugin) {

// resolve subarg syntax

if (typeof plugin === 'object' && Array.isArray(plugin._)) {

return [

plugin._[0],

plugin

]

}

return plugin

})

const bufs = []

const transformStream = through(write, end)

return transformStream

// aggregate all AST nodes

// (buf, str, fn) -> null

function write (buf, enc, next) {

bufs.push(buf)

next()

}

// parse and push AST nodes

// null -> null

function end () {

const self = this

// cool, you've made it this far. We know this is gross,

// but tough times call for tough measure. Please don't

// judge us too harshly, we'll work on perf ✨soon✨ -yw

const nodes = []

const babelTemplateDeclarations = {}

const bubleTemplateDeclarations = {}

const src = Buffer.concat(bufs).toString('utf8')

var mname = null

var ast

// Skip transforming any files that do not contain synonyms for sheetify

if (!SUPPORTED_SYNONYMS.some(name => src.includes(name))) {

self.push(src)

self.push(null)

return

}

findTransforms(filename, function (err, transforms) {

if (err) return self.emit('error', err)

opts.transform = transforms.concat(opts.transform || []).concat(opts.t || [])

try {

ast = transformAst(src, {

parser: require('acorn-node'),

inputFilename: path.basename(filename)

}, identifyModuleName)

ast.walk(extractNodes)

} catch (err) {

return self.emit('error', err)

}

// transform all detected nodes and

// close stream when done

mapLimit(nodes, Infinity, iterate, function (err) {

if (err) return self.emit('error', err)

self.push(ast.toString({

map: opts && opts._flags && opts._flags.debug

}))

self.push(null)

})

})

function identifyModuleName (node) {

if (mname) return

if (node.type === 'CallExpression' &&

node.callee && node.callee.name === 'require' &&

node.arguments.length === 1 &&

SUPPORTED_SYNONYMS.includes(node.arguments[0].value)) {

node.update('0')

mname = node.parent.id.name

}

}

function extractNodes (node) {

extractTemplateNodes(node)

extractImportNodes(node)

}

function extractTemplateNodes (node) {

var css

var elements

if (node.type === 'VariableDeclarator' && node.init) {

if (isBabelTemplateDefinition(node.init)) {

// Babel generates helper calls like

// _taggedTemplateLiteral([":host .class { color: hotpink; }"], [":host .class { color: hotpink; }"])

// we only keep the "cooked" part

babelTemplateDeclarations[node.id.name] = node

} else if (isBubleTemplateDefinition(node.init)) {

// Buble generates helper calls like

// Object.freeze([":host .class { color: hotpink; }"])

bubleTemplateDeclarations[node.id.name] = node

}

}

if (node.type === 'TemplateLiteral' && node.parent && node.parent.tag) {

if (node.parent.tag.name !== mname) return

css = [ node.quasis.map(cooked) ]

.concat(node.expressions.map(expr)).join('').trim()

nodes.push({

css: css,

filename: filename,

opts: Object.assign({}, opts),

node: node.parent

})

}

if (node.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === mname) {

if (node.arguments[0] && node.arguments[0].type === 'ArrayExpression') {

// Buble generates code like

// sheetify([":host .class { color: hotpink; }"])

elements = node.arguments[0].elements

} else if (node.arguments[0] && node.arguments[0].type === 'Identifier') {

// Babel generates code like

// sheetify(_templateObject)

var arg = node.arguments[0].name

var templateDeclaration =

babelTemplateDeclarations[arg] || bubleTemplateDeclarations[arg]

if (templateDeclaration) {

var template = templateDeclaration.init.arguments[0]

elements = template.elements

/*

We want to remove transpiled var declaration for minification to work.

var ...,

_templateObject2 = _taggedTemplateLiteral(['.foo { color: blue; }'], ['.foo { color: blue; }']),

...;

*/

removeVariableDeclarator(templateDeclaration)

}

}

if (elements) {

nodes.push({

css: elements.map(function (part) { return part.value }).join(''),

filename: filename,

opts: Object.assign({}, opts),

node: node

})

}

}

}

function removeVariableDeclarator (node) {

/*

Remove `a` declaration from compound `var` statement:

var ...,

a = B,

...

*/

var parent = node.parent

var offset = parent.start

var at = parent.declarations.indexOf(node)

var total = parent.declarations.length

var str = parent.getSource()

var prevNode, nextNode

var stripped

if (total === 1) {

stripped = ' '.repeat(str.length) // remove whole "var ...;" statement

} else if (at < total - 1) { // not last

nextNode = parent.declarations[at + 1]

stripped =

str.slice(0, node.start - offset) +

' '.repeat(nextNode.start - node.start) +

str.slice(nextNode.start - offset)

} else { // last one

prevNode = parent.declarations[at - 1]

stripped =

str.slice(0, prevNode.end - offset) +

' '.repeat(node.end - prevNode.end) +

str.slice(node.end - offset)

}

parent.update(stripped)

}

function extractImportNodes (node) {

if (node.type !== 'CallExpression') return

if (!node.callee || node.callee.type !== 'Identifier') return

if (node.callee.name !== mname) return

if (!node.arguments[0] || !node.arguments[0].value) return

var pathOpts = { basedir: path.dirname(filename) }

try {

var resolvePath = cssResolve(node.arguments[0].value, pathOpts)

} catch (err) {

return self.emit('error', err)

}

const iOpts = node.arguments[1]

? Object.assign({}, opts, staticEval(node.arguments[1]))

: opts

transformStream.emit('file', resolvePath)

const val = {

filename: resolvePath,

opts: iOpts,

node: node

}

nodes.push(val)

}

}

// iterate over nodes, and apply sheetify transformation

// then replace the AST nodes with new values

// (obj, fn) -> null

function iterate (val, done) {

if (typeof val.css === 'string') return handleCss(val)

if (/\.js$/.test(val.filename)) {

delete require.cache[require.resolve(val.filename)]

val.css = require(val.filename)

handleCss(val)

} else {

fs.readFile(val.filename, 'utf8', function (err, css) {

if (err) return done(err)

val.css = css

handleCss(val)

})

}

function handleCss (val) {

sheetify(val.css, val.filename, val.opts, function (err, result, prefix) {

if (err) return done(err)

const str = [

"((require('sheetify/insert')(" + JSON.stringify(result.css) + ')',

' || true) && ' + JSON.stringify(prefix) + ')'

].join('')

const parentNodeType = val.node.parent.type

const lolSemicolon = parentNodeType === 'VariableDeclarator' ||

parentNodeType === 'AssignmentExpression'

? ''

: ';'

val.node.update(lolSemicolon + str)

result.files.forEach(function (includedFile) {

transformStream.emit('file', includedFile)

})

done()

})

}

}

function findTransforms (filename, done) {

findup(filename, 'package.json', function (err, pathname) {

// no package.json found - just run local transforms

if (err) return done(null, [])

var filename = path.join(pathname, 'package.json')

fs.readFile(filename, function (err, file) {

if (err) return done(err)

var parsed = parse(file)

if (parsed.err) return done(parsed.err)

var json = parsed.value

var d = json.sheetify

if (!d) return done(null, [])

var t = d.transform

if (!t || !Array.isArray(t)) return done(null, [])

return done(null, t)

})

})

}

}

function cooked (node) { return node.value.cooked }

function expr (ex) { return { _expr: ex.source() } }