mirror of
https://github.com/fooflington/selfdefined.git
synced 2025-06-13 05:55:26 +00:00
update
This commit is contained in:
tatianamac
437
node_modules/browser-sync/dist/server/utils.js
generated
vendored
Normal file
437
node_modules/browser-sync/dist/server/utils.js
generated
vendored
Normal file
@ -0,0 +1,437 @@
|
||||
"use strict";
|
||||
var fs = require("fs");
|
||||
var path = require("path");
|
||||
var join = require("path").join;
|
||||
var connect = require("connect");
|
||||
var Immutable = require("immutable");
|
||||
var http = require("http");
|
||||
var https = require("https");
|
||||
var Map = require("immutable").Map;
|
||||
var fromJS = require("immutable").fromJS;
|
||||
var List = require("immutable").List;
|
||||
var snippet = require("./../snippet").utils;
|
||||
var _ = require("../lodash.custom");
|
||||
var serveStatic = require("./serve-static-wrapper").default();
|
||||
var serveIndex = require("serve-index");
|
||||
var logger = require("../logger");
|
||||
var snippetUtils = require("../snippet").utils;
|
||||
var lrSnippet = require("resp-modifier");
|
||||
var certPath = join(__dirname, "..", "..", "certs");
|
||||
function getCa(options) {
|
||||
var caOption = options.getIn(["https", "ca"]);
|
||||
// if not provided, use Browsersync self-signed
|
||||
if (typeof caOption === "undefined") {
|
||||
return fs.readFileSync(join(certPath, "server.csr"));
|
||||
}
|
||||
// if a string was given, read that file from disk
|
||||
if (typeof caOption === "string") {
|
||||
return fs.readFileSync(caOption);
|
||||
}
|
||||
// if an array was given, read all
|
||||
if (List.isList(caOption)) {
|
||||
return caOption.toArray().map(function (x) {
|
||||
return fs.readFileSync(x);
|
||||
});
|
||||
}
|
||||
}
|
||||
function getKey(options) {
|
||||
return fs.readFileSync(options.getIn(["https", "key"]) || join(certPath, "server.key"));
|
||||
}
|
||||
function getCert(options) {
|
||||
return fs.readFileSync(options.getIn(["https", "cert"]) || join(certPath, "server.crt"));
|
||||
}
|
||||
function getHttpsServerDefaults(options) {
|
||||
return fromJS({
|
||||
key: getKey(options),
|
||||
cert: getCert(options),
|
||||
ca: getCa(options),
|
||||
passphrase: ""
|
||||
});
|
||||
}
|
||||
function getPFXDefaults(options) {
|
||||
return fromJS({
|
||||
pfx: fs.readFileSync(options.getIn(["https", "pfx"]))
|
||||
});
|
||||
}
|
||||
var serverUtils = {
|
||||
/**
|
||||
* @param options
|
||||
* @returns {{key, cert}}
|
||||
*/
|
||||
getHttpsOptions: function (options) {
|
||||
var userOption = options.get("https");
|
||||
if (Map.isMap(userOption)) {
|
||||
if (userOption.has("pfx")) {
|
||||
return userOption.mergeDeep(getPFXDefaults(options));
|
||||
}
|
||||
return userOption.mergeDeep(getHttpsServerDefaults(options));
|
||||
}
|
||||
return getHttpsServerDefaults(options);
|
||||
},
|
||||
/**
|
||||
* Get either http or https server
|
||||
* or use the httpModule provided in options if present
|
||||
*/
|
||||
getServer: function (app, options) {
|
||||
return {
|
||||
server: (function () {
|
||||
var httpModule = serverUtils.getHttpModule(options);
|
||||
if (options.get("scheme") === "https" ||
|
||||
options.get("httpModule") === "http2") {
|
||||
var opts = serverUtils.getHttpsOptions(options);
|
||||
return httpModule.createServer(opts.toJS(), app);
|
||||
}
|
||||
return httpModule.createServer(app);
|
||||
})(),
|
||||
app: app
|
||||
};
|
||||
},
|
||||
getHttpModule: function (options) {
|
||||
/**
|
||||
* Users may provide a string to be used by nodes
|
||||
* require lookup.
|
||||
*/
|
||||
var httpModule = options.get("httpModule");
|
||||
if (typeof httpModule === "string") {
|
||||
/**
|
||||
* Note, this could throw, but let that happen as
|
||||
* the error message good enough.
|
||||
*/
|
||||
var maybe = require.resolve(httpModule);
|
||||
return require(maybe);
|
||||
}
|
||||
if (options.get("scheme") === "https") {
|
||||
return https;
|
||||
}
|
||||
return http;
|
||||
},
|
||||
getMiddlewares: function (bs) {
|
||||
var clientJs = bs.pluginManager.hook("client:js", {
|
||||
port: bs.options.get("port"),
|
||||
options: bs.options
|
||||
});
|
||||
var scripts = bs.pluginManager.get("client:script")(bs.options.toJS(), clientJs, "middleware");
|
||||
var defaultMiddlewares = [
|
||||
{
|
||||
id: "Browsersync HTTP Protocol",
|
||||
route: require("../config").httpProtocol.path,
|
||||
handle: require("../http-protocol").middleware(bs)
|
||||
},
|
||||
{
|
||||
id: "Browsersync IE8 Support",
|
||||
route: "",
|
||||
handle: snippet.isOldIe(bs.options.get("excludedFileTypes").toJS())
|
||||
},
|
||||
{
|
||||
id: "Browsersync Response Modifier",
|
||||
route: "",
|
||||
handle: serverUtils.getSnippetMiddleware(bs)
|
||||
},
|
||||
{
|
||||
id: "Browsersync Client - versioned",
|
||||
route: bs.options.getIn(["scriptPaths", "versioned"]),
|
||||
handle: scripts
|
||||
},
|
||||
{
|
||||
id: "Browsersync Client",
|
||||
route: bs.options.getIn(["scriptPaths", "path"]),
|
||||
handle: scripts
|
||||
}
|
||||
];
|
||||
/**
|
||||
* Add cors middleware to the front of the stack
|
||||
* if a user provided a 'cors' flag
|
||||
*/
|
||||
if (bs.options.get("cors")) {
|
||||
defaultMiddlewares.unshift({
|
||||
id: "Browsersync CORS support",
|
||||
route: "",
|
||||
handle: serverUtils.getCorsMiddlewware()
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Add connect-history-api-fallback if 'single' argument given
|
||||
*/
|
||||
if (bs.options.get("single")) {
|
||||
defaultMiddlewares.unshift({
|
||||
id: "Browsersync SPA support",
|
||||
route: "",
|
||||
handle: require("connect-history-api-fallback")()
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Add serve static middleware
|
||||
*/
|
||||
if (bs.options.get("serveStatic")) {
|
||||
var ssMiddlewares = serverUtils.getServeStaticMiddlewares(bs.options.get("serveStatic"), bs.options.get("serveStaticOptions", Immutable.Map({})).toJS());
|
||||
var withErrors = ssMiddlewares.filter(function (x) {
|
||||
return x.get("errors").size > 0;
|
||||
});
|
||||
var withoutErrors = ssMiddlewares.filter(function (x) {
|
||||
return x.get("errors").size === 0;
|
||||
});
|
||||
if (withErrors.size) {
|
||||
withErrors.forEach(function (item) {
|
||||
logger.logger.error("{red:Warning!} %s", item.getIn(["errors", 0, "data", "message"]));
|
||||
});
|
||||
}
|
||||
if (withoutErrors.size) {
|
||||
withoutErrors.forEach(function (item) {
|
||||
defaultMiddlewares.push.apply(defaultMiddlewares, item.get("items").toJS());
|
||||
});
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Add user-provided middlewares
|
||||
*/
|
||||
var userMiddlewares = bs.options
|
||||
.get("middleware")
|
||||
.map(normaliseMiddleware)
|
||||
.toArray();
|
||||
var beforeMiddlewares = userMiddlewares.filter(function (x) {
|
||||
return x.override;
|
||||
});
|
||||
var afterMiddlewares = userMiddlewares
|
||||
.filter(function (x) {
|
||||
return !x.override;
|
||||
})
|
||||
.concat(bs.options.get("mode") !== "proxy" &&
|
||||
userMiddlewares.length === 0 && {
|
||||
id: "Browsersync 404/index support",
|
||||
route: "",
|
||||
handle: serveIndex(bs.options.get("cwd"), {
|
||||
icons: true,
|
||||
view: "details"
|
||||
})
|
||||
});
|
||||
var mwStack = []
|
||||
.concat(beforeMiddlewares, defaultMiddlewares, afterMiddlewares)
|
||||
.filter(Boolean);
|
||||
return mwStack;
|
||||
function normaliseMiddleware(item) {
|
||||
/**
|
||||
* Object given in options, which
|
||||
* ended up being a Map
|
||||
*/
|
||||
if (Map.isMap(item)) {
|
||||
return item.toJS();
|
||||
}
|
||||
/**
|
||||
* Single function
|
||||
*/
|
||||
if (typeof item === "function") {
|
||||
return {
|
||||
route: "",
|
||||
handle: item
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Plain obj
|
||||
*/
|
||||
if (item.route !== undefined && item.handle) {
|
||||
return item;
|
||||
}
|
||||
}
|
||||
},
|
||||
getBaseApp: function (bs) {
|
||||
var app = connect();
|
||||
var middlewares = serverUtils.getMiddlewares(bs);
|
||||
/**
|
||||
* Add all internal middlewares
|
||||
*/
|
||||
middlewares.forEach(function (item) {
|
||||
app.stack.push(item);
|
||||
});
|
||||
return app;
|
||||
},
|
||||
getSnippetMiddleware: function (bs) {
|
||||
var rules = [];
|
||||
var blacklist = List([])
|
||||
.concat(bs.options.getIn(["snippetOptions", "ignorePaths"]))
|
||||
.concat(bs.options.getIn(["snippetOptions", "blacklist"]))
|
||||
.filter(Boolean);
|
||||
var whitelist = List([]).concat(bs.options.getIn(["snippetOptions", "whitelist"]));
|
||||
// Snippet
|
||||
rules.push(snippetUtils.getRegex(bs.options.get("snippet"), bs.options.get("snippetOptions")));
|
||||
// User
|
||||
bs.options.get("rewriteRules").forEach(function (rule) {
|
||||
if (Map.isMap(rule)) {
|
||||
rules.push(rule.toJS());
|
||||
}
|
||||
if (_.isPlainObject(rule)) {
|
||||
rules.push(rule);
|
||||
}
|
||||
});
|
||||
// Proxy
|
||||
if (bs.options.get("proxy")) {
|
||||
var proxyRule = require("./proxy-utils").rewriteLinks(bs.options.getIn(["proxy", "url"]).toJS());
|
||||
rules.push(proxyRule);
|
||||
}
|
||||
var lr = lrSnippet.create({
|
||||
rules: rules,
|
||||
blacklist: blacklist.toArray(),
|
||||
whitelist: whitelist.toArray()
|
||||
});
|
||||
return lr.middleware;
|
||||
},
|
||||
getCorsMiddlewware: function () {
|
||||
return function (req, res, next) {
|
||||
// Website you wish to allow to connect
|
||||
res.setHeader("Access-Control-Allow-Origin", "*");
|
||||
// Request methods you wish to allow
|
||||
res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS, PUT, PATCH, DELETE");
|
||||
// Request headers you wish to allow
|
||||
res.setHeader("Access-Control-Allow-Headers", "X-Requested-With,content-type");
|
||||
// Set to true if you need the website to include cookies in the requests sent
|
||||
// to the API (e.g. in case you use sessions)
|
||||
res.setHeader("Access-Control-Allow-Credentials", true);
|
||||
next();
|
||||
};
|
||||
},
|
||||
/**
|
||||
* @param ssOption
|
||||
* @param serveStaticOptions
|
||||
* @returns {*}
|
||||
*/
|
||||
getServeStaticMiddlewares: function (ssOption, serveStaticOptions) {
|
||||
return ssOption.map(function (dir, i) {
|
||||
/**
|
||||
* When a user gives a plain string only, eg:
|
||||
* serveStatic: ['./temp']
|
||||
* ->
|
||||
* This means a middleware will be created with
|
||||
* route: ''
|
||||
* handle: serveStatic('./temp', options)
|
||||
*/
|
||||
if (_.isString(dir)) {
|
||||
return getFromString(dir);
|
||||
}
|
||||
/**
|
||||
* If a user gave an object eg:
|
||||
* serveStatic: [{route: "", dir: ["test", "./tmp"]}]
|
||||
* ->
|
||||
* This means we need to create a middle for each route + dir combo
|
||||
*/
|
||||
if (Immutable.Map.isMap(dir)) {
|
||||
return getFromMap(dir, i);
|
||||
}
|
||||
/**
|
||||
* At this point, an item in the serveStatic array was not a string
|
||||
* or an object so we return an error that can be logged
|
||||
*/
|
||||
return fromJS({
|
||||
items: [],
|
||||
errors: [
|
||||
{
|
||||
type: "Invalid Type",
|
||||
data: {
|
||||
message: "Only strings and Objects (with route+dir) are supported for the ServeStatic option"
|
||||
}
|
||||
}
|
||||
]
|
||||
});
|
||||
});
|
||||
/**
|
||||
* @param {string} x
|
||||
* @returns {string}
|
||||
*/
|
||||
function getRoute(x) {
|
||||
if (x === "")
|
||||
return "";
|
||||
return x[0] === "/" ? x : "/" + x;
|
||||
}
|
||||
/**
|
||||
* @param dir
|
||||
* @returns {Map}
|
||||
*/
|
||||
function getFromString(dir) {
|
||||
return fromJS({
|
||||
items: [
|
||||
{
|
||||
route: "",
|
||||
handle: serveStatic(dir, serveStaticOptions)
|
||||
}
|
||||
],
|
||||
errors: []
|
||||
});
|
||||
}
|
||||
/**
|
||||
* @param dir
|
||||
* @returns {Map}
|
||||
*/
|
||||
function getFromMap(dir) {
|
||||
var ssOptions = (function () {
|
||||
if (dir.get("options")) {
|
||||
return dir.get("options").toJS();
|
||||
}
|
||||
return {};
|
||||
})();
|
||||
var route = Immutable.List([])
|
||||
.concat(dir.get("route"))
|
||||
.filter(_.isString);
|
||||
var _dir = Immutable.List([])
|
||||
.concat(dir.get("dir"))
|
||||
.filter(_.isString);
|
||||
if (_dir.size === 0) {
|
||||
return fromJS({
|
||||
items: [],
|
||||
errors: [
|
||||
{
|
||||
type: "Invalid Object",
|
||||
data: {
|
||||
message: "Serve Static requires a 'dir' property when using an Object"
|
||||
}
|
||||
}
|
||||
]
|
||||
});
|
||||
}
|
||||
var ssItems = (function () {
|
||||
/**
|
||||
* iterate over every 'route' item
|
||||
* @type {Immutable.List<any>|Immutable.List<*>|Immutable.List<any>|*}
|
||||
*/
|
||||
var routeItems = (function () {
|
||||
/**
|
||||
* If no 'route' was given, assume we want to match all
|
||||
* paths
|
||||
*/
|
||||
if (route.size === 0) {
|
||||
return _dir.map(function (dirString) {
|
||||
return Map({
|
||||
route: "",
|
||||
dir: dirString
|
||||
});
|
||||
});
|
||||
}
|
||||
return route.reduce(function (acc, routeString) {
|
||||
/**
|
||||
* For each 'route' item, also iterate through 'dirs'
|
||||
* @type {Immutable.Iterable<K, M>}
|
||||
*/
|
||||
var perDir = _dir.map(function (dirString) {
|
||||
return Map({
|
||||
route: getRoute(routeString),
|
||||
dir: dirString
|
||||
});
|
||||
});
|
||||
return acc.concat(perDir);
|
||||
}, List([]));
|
||||
})();
|
||||
/**
|
||||
* Now create a serverStatic Middleware for each item
|
||||
*/
|
||||
return routeItems.map(function (routeItem) {
|
||||
return routeItem.merge({
|
||||
handle: serveStatic(routeItem.get("dir"), ssOptions)
|
||||
});
|
||||
});
|
||||
})();
|
||||
return fromJS({
|
||||
items: ssItems,
|
||||
errors: []
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
module.exports = serverUtils;
|
||||
//# sourceMappingURL=utils.js.map
|
||||
Reference in New Issue
Block a user