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() } }