index.js

const cssPrefix = require('postcss-prefix')
const nodeResolve = require('resolve')
const mapLimit = require('map-limit')
const postcss = require('postcss')
const assert = require('assert')
const crypto = require('crypto')
const stackTrace = require('stack-trace')
const cssResolve = require('style-resolve').sync
const fs = require('fs')
const path = require('path')

module.exports = sheetify
module.exports.getPrefix = getPrefix

// transform css
// (str, str, obj?, fn) -> str
function sheetify (src, filename, options, done) {
 // browserify transform
 if (typeof src === 'string' && !/\n/.test(src) && filename && filename._flags) {
 var args = Array.prototype.slice.apply(arguments)
 return require('./transform.js').apply(this, args)
 }

 // handle tagged template calls directly from Node
 const isTemplate = Array.isArray(src)
 if (isTemplate) src = src.join('')
 assert.equal(typeof src, 'string', 'src must be a string')
 src = src.trim()

 // Ensure prefix is always correct when run from inside node
 var css
 if (!isTemplate && (!filename || typeof filename === 'object')) {
 // module or file name via tagged template call w or w/out options
 const callerDirname = path.dirname(stackTrace.get()[1].getFileName())
 const resolved = cssResolve(src, { basedir: callerDirname })
 css = fs.readFileSync(resolved, 'utf8')
 } else {
 // it better be some css
 css = src
 }

 const prefix = getPrefix(css)

 // only parse if in a browserify transform
 if (typeof filename === 'string') parseCss(src, filename, prefix, options, done)

 return prefix
}

function getPrefix (css) {
 const prefix = '_' + crypto.createHash('md5')
 .update(css.trim())
 .digest('hex')
 .slice(0, 8)
 return prefix
}

// parse css
// (str, str, str, obj, fn) -> null
function parseCss (src, filename, prefix, options, done) {
 assert.equal(typeof filename, 'string', 'filename must be a string')
 assert.equal(typeof prefix, 'string', 'prefix must be a string')
 assert.equal(typeof options, 'object', 'options must be a object')
 assert.equal(typeof done, 'function', 'done must be a function')

 applyTransforms(filename, String(src), Object.assign({}, options), function (err, result) {
 if (err) return done(err)
 var p = postcss()
 p = p.use(cssPrefix('.' + prefix))

 try {
 result.css = p.process(result.css).toString()

 return done(null, result, prefix)
 } catch (e) {
 return done(e)
 }
 })

 // apply transforms to a string of css,
 // one at the time
 // (str, str, obj, fn) -> null
 function applyTransforms (filename, src, options, done) {
 var current = { css: src, files: [] }
 mapLimit(options.transform, 1, iterate, function (err) {
 if (err) return done(err)
 done(null, current)
 })

 // find and apply a transform to a string of css
 // (fn, fn) -> null
 function iterate (plugin, next) {
 if (typeof plugin === 'string' || typeof plugin === 'function') {
 plugin = [ plugin, {} ]
 } else if (!Array.isArray(plugin)) {
 return done(new Error('Plugin must be a string or array'))
 }

 const name = plugin[0]
 const opts = plugin[1] || {}
 if (typeof name === 'function') {
 return transformLoaded(name, opts)
 }

 const resolveOpts = {
 basedir: opts.basedir || options.basedir || process.cwd()
 }
 nodeResolve(name, resolveOpts, function (err, transformPath) {
 if (err) return done(err)

 const transform = require(transformPath)
 transformLoaded(transform, opts)
 })

 function transformLoaded (transform, opts) {
 transform(filename, current.css, opts, function (err, result) {
 if (err) return next(err)
 if (typeof result === 'string') {
 current.css = result
 } else {
 current.css = result.css
 current.files = current.files.concat(result.files)
 }
 next()
 })
 }
 }
 }
}