144 lines
3.3 KiB
JavaScript
144 lines
3.3 KiB
JavaScript
"use strict";
|
|
|
|
var etag = require("etag");
|
|
var fresh = require("fresh");
|
|
var fs = require("fs");
|
|
var path = require("path");
|
|
var zlib = require("zlib");
|
|
|
|
var minifiedScript = path.join(__dirname, "/dist/index.min.js");
|
|
var unminifiedScript = path.join(__dirname, "/dist/index.js");
|
|
|
|
/**
|
|
* Does the current request support compressed encoding?
|
|
* @param {Object} req
|
|
* @returns {boolean}
|
|
*/
|
|
function supportsGzip (req) {
|
|
var accept = req.headers['accept-encoding'];
|
|
return accept && accept.indexOf('gzip') > -1;
|
|
}
|
|
|
|
/**
|
|
* Set headers on the response
|
|
* @param {Object} res
|
|
* @param {String} body
|
|
*/
|
|
function setHeaders(res, body) {
|
|
|
|
res.setHeader("Cache-Control", "public, max-age=0");
|
|
res.setHeader("Content-Type", "text/javascript");
|
|
res.setHeader("ETag", etag(body));
|
|
}
|
|
|
|
/**
|
|
* @param {Object} options
|
|
* @param {String} connector
|
|
* @returns {String}
|
|
*/
|
|
function getScriptBody(options, connector) {
|
|
|
|
var script = minifiedScript;
|
|
|
|
if (options && !options.minify) {
|
|
script = unminifiedScript;
|
|
}
|
|
|
|
return connector + fs.readFileSync(script);
|
|
}
|
|
|
|
/**
|
|
* @param {Object} req
|
|
* @returns {String}
|
|
*/
|
|
function isConditionalGet(req) {
|
|
return req.headers["if-none-match"] || req.headers["if-modified-since"];
|
|
}
|
|
|
|
/**
|
|
* Return a not-modified response
|
|
* @param {Object} res
|
|
*/
|
|
function notModified(res) {
|
|
res.removeHeader("Content-Type");
|
|
res.statusCode = 304;
|
|
res.end();
|
|
}
|
|
|
|
/**
|
|
* Public method for returning either a middleware fn
|
|
* or the content as a string
|
|
* @param {Object} options
|
|
* @param {String} connector - content to be prepended
|
|
* @param {String} type - either `file` or `middleware`
|
|
* @returns {*}
|
|
*/
|
|
function init(options, connector, type) {
|
|
|
|
var gzipCached;
|
|
|
|
/**
|
|
* Combine string to create the final version
|
|
* @type {String}
|
|
*/
|
|
var requestBody = getScriptBody(options, connector);
|
|
|
|
/**
|
|
* If the user asked for a file, simply return the string.
|
|
*/
|
|
if (type && type === "file") {
|
|
return requestBody;
|
|
}
|
|
|
|
/**
|
|
* Otherwise return a function to be used a middleware
|
|
*/
|
|
return function (req, res) {
|
|
|
|
/**
|
|
* default to using the uncompressed string
|
|
* @type {String}
|
|
*/
|
|
var output = requestBody;
|
|
|
|
/**
|
|
* Set the appropriate headers for caching
|
|
*/
|
|
setHeaders(res, output);
|
|
|
|
if (isConditionalGet(req) && fresh(req.headers, res._headers)) {
|
|
return notModified(res);
|
|
}
|
|
|
|
/**
|
|
* If gzip is supported, compress the string once
|
|
* and save for future requests
|
|
*/
|
|
if (supportsGzip(req)) {
|
|
|
|
res.setHeader("Content-Encoding", "gzip");
|
|
|
|
if (!gzipCached) {
|
|
var buf = new Buffer(output, "utf-8");
|
|
zlib.gzip(buf, function (_, result) {
|
|
gzipCached = result;
|
|
res.end(result);
|
|
});
|
|
} else {
|
|
res.end(gzipCached);
|
|
}
|
|
|
|
} else {
|
|
res.end(output);
|
|
}
|
|
};
|
|
}
|
|
|
|
module.exports.middleware = init;
|
|
module.exports.plugin = init;
|
|
module.exports.minified = function () {
|
|
return fs.readFileSync(minifiedScript, 'utf8');
|
|
};
|
|
module.exports.unminified = function () {
|
|
return fs.readFileSync(unminifiedScript, 'utf8');
|
|
} |