return function(key, value, isTree) {
if ( !isTree ) {
value = guessValue(value);
}
const path = _path.join(ROOT, 'src', 'conf', '900-custom.json');
var newTree = isTree ? value : getNewTree(key, value);
var oldTree = {};
try {
oldTree = JSON.parse(_fs.readFileSync(path).toString());
} catch ( e ) {
oldTree = {};
}
var result = _utils.mergeObject(oldTree, newTree);
removeNulls(result);
_fs.writeFileSync(path, JSON.stringify(result, null, 2));
console.warn(String.color('Remember to run \'osjs build:config\' to update your build(s)...', 'green'));
return result;
};
return new Promise(function(resolve) {
console.log('Building icon pack', String.color(n, 'blue,bold'));
const src = _path.join(ROOT, 'src', 'client', 'themes', 'icons', n);
const dst = _path.join(ROOT, 'dist', 'themes', 'icons', n);
_utils.mkdirSilent(dst);
function _next() {
_utils.removeSilent(_path.join(dst, 'metadata.json'));
_fs.copySync(src, dst);
resolve();
}
const metafile = _path.join(src, 'metadata.json');
const metadata = JSON.parse(_fs.readFileSync(metafile));
if ( !metadata.parent ) {
return _next();
}
const psrc = _path.join(ROOT, 'src', 'client', 'themes', 'icons', metadata.parent);
_fs.copySync(psrc, dst);
_next();
})
/*
* Reads given template file and replaces example strings
*/
function _replaceInExample(name, file, dest) {
dest = dest ? dest : file;
var c = _fs.readFileSync(file).toString();
c = _utils.replaceAll(c, 'EXAMPLE', name);
_fs.writeFileSync(dest, c);
}
stylesheet: function(src) {
const css = _fs.readFileSync(src).toString();
const min = new Cleancss({
sourceMap: true
}).minify(css);
return [cssh + min.styles, min.sourceMap];
},
///////////////////////////////////////////////////////////////////////////////
// HELPERS
///////////////////////////////////////////////////////////////////////////////
/*
* Reads given config template and replaces any required strings
*/
function _createWebserverConfig(cfg, target, src, mimecb) {
const mimes = mimecb(cfg.mime);
var tpl = _fs.readFileSync(src).toString();
tpl = tpl.replace(/%DISTDIR%/, _path.join(ROOT, target));
tpl = tpl.replace(/%MIMES%/, mimes);
return tpl;
}
function generate_htaccess(t, d) {
const src = _path.join(ROOT, 'src', 'templates', t);
const dst = _path.join(ROOT, d, '.htaccess');
var tpl = _fs.readFileSync(src).toString();
tpl = tpl.replace(/%MIMES%/, mimes.join('\n'));
tpl = tpl.replace(/%PROXIES%/, proxies.join('\n'));
_fs.writeFileSync(dst, tpl);
}
module.exports.createStandaloneScheme = function createStandaloneScheme(src, name, dest) {
var data = module.exports.addslashes(_fs.readFileSync(src).toString().replace(/\n/g, ''));
var tpl = module.exports.readTemplate('dist/schemes.js');
tpl = tpl.replace('%DATA%', data);
tpl = tpl.replace('%NAME%', name);
_fs.writeFileSync(dest, tpl);
};
found.forEach(function(f) {
var src = f.split(/<gui\-fragment\s+?data\-fragment\-external=\"(.*)\"\s+?\/>/)[1];
src = _path.join(dest, src);
if ( src && _fs.existsSync(src) ) {
scheme = scheme.replace(f, String(_fs.readFileSync(src)));
remove.push(src);
}
});
files.forEach(function(file) {
const json = JSON.parse(_fs.readFileSync(file));
try {
object = _utils.mergeObject(object, json);
} catch ( e ) {
console.warn('Failed to read JSON file', _path.basename(file), 'Syntax error ?', e);
}
});
return new Promise(function(resolve, reject) {
const src = _path.join(ROOT, 'src', 'templates', 'dist', 'settings.js');
const tpl = _fs.readFileSync(src).toString();
const dest = _path.join(ROOT, dist, 'settings.js');
generateClientConfiguration(dist, cli, cfg).then(function(settings) {
const data = tpl.replace('%CONFIG%', JSON.stringify(settings, null, 4));
resolve(_fs.writeFileSync(dest, data));
}).catch(reject);
});
fs.createFile(path.toString(), function(err){
if (err) {
throw err;
}
if (!fileExisted && options.src) {
fs.writeFileSync(path, fs.readFileSync(options.src));
}
callback && callback();
});
const concated = cfg.themes.fonts.map(function(iter) {
const src = _path.join(ROOT, 'src', 'client', 'themes', 'fonts', iter);
const dst = _path.join(ROOT, 'dist', 'themes', 'fonts', iter);
_fs.copySync(src, dst);
_utils.removeSilent(_path.join(dst, 'metadata.json'));
const file = _path.join(dst, 'style.css');
const css = _fs.readFileSync(file).toString();
return css.replace(/\%FONTURI\%/g, rep);
});
return new Promise(function(resolve, reject) {
const dest = _path.join(ROOT, target, 'packages.js');
var tpl = _fs.readFileSync(_path.join(ROOT, 'src/templates/dist/packages.js'));
tpl = tpl.toString().replace('%PACKAGES%', JSON.stringify(manifest, null, 4));
_fs.writeFile(dest, tpl, function(err) {
/*eslint no-unused-expressions: "off"*/
err ? reject(err) : resolve();
});
});
extensions[e].conf.forEach(function(c) {
try {
const p = _path.join(src, 'packages', extensions[e].path, c);
try {
const s = JSON.parse(_fs.readFileSync(p));
settings = _utils.mergeObject(settings, s);
} catch ( e ) {
_utils.log(String.color('Failed reading:', 'yellow'), p);
}
} catch ( e ) {
console.warn('createConfigurationFiles()', e, e.stack);
}
});
var getLocalization = function (filePath, fileName) {
var data = null;
// read template
if (fs.existsSync(filePath + path.sep + templateLocale + '.js')) {
data = fs.readFileSync(
filePath + path.sep + templateLocale + '.js',
{
encoding: 'utf8'
}
);
/* jshint ignore:start */
sourceLocale = eval(data);
/* jshint ignore:end */
} else {
grunt.fail.fatal(
'Couldn\'t read template localization:',
filePath + path.sep + templateLocale + '.js'
);
}
// Read old locale
targetFile = filePath + path.sep + fileName;
if (fs.existsSync(targetFile)) {
data = fs.readFileSync(targetFile, {
encoding: 'utf8'
});
/* jshint ignore:start */
translation = eval(data);
/* jshint ignore:end */
} else {
grunt.log.warn(
'Couldn\'t find old translation: ',
filePath + path.sep + fileName
);
}
initLocalization(sourceLocale);
};
return new Promise(function(resolve, reject) {
const name = [repo, _path.basename(_path.dirname(file))].join('/');
const meta = JSON.parse(_fs.readFileSync(file));
meta.type = meta.type || 'application';
meta.path = name;
meta.build = meta.build || {};
meta.repo = repo;
meta.preload = (meta.preload ? meta.preload : []).map(parsePreloads);
if ( typeof meta.sources !== 'undefined' ) {
meta.preload = meta.preload.concat(meta.sources.map(parsePreloads));
}
resolve(Object.freeze(meta));
});
iter.preload.forEach(function(p) {
if ( p.combine === false || p.src.match(/^(ftp|https?\:)?\/\//) ) {
return;
}
try {
if ( Object.keys(combined).indexOf(p.type) !== -1 ) {
const path = _path.join(dest, p.src);
try {
combined[p.type].push(_fs.readFileSync(path).toString());
} catch ( e ) {
_utils.log(String.color('Failed reading:', 'yellow'), path);
}
remove.push(path);
}
} catch ( e ) {
console.error(e);
}
});
module.exports.compileLess = function compileLess(src, dest, opts, cb, onRead) {
console.log('$ less', src.replace(ROOT + '/', ''), dest.replace(ROOT + '/', ''))
try {
var css = _fs.readFileSync(src).toString();
if ( typeof onRead === 'function' ) {
css = onRead(css);
}
_less.render(css, opts).then(function(result) {
_fs.writeFileSync(dest, result.css);
_fs.writeFileSync(dest + '.map', result.map);
cb(false, true);
}, function(error) {
console.warn(error);
cb(error);
});
} catch ( e ) {
console.warn(e, e.stack);
cb(e);
}
};
return new Promise(function(resolve, reject) {
iter.preload.forEach(function(p) {
if ( p.combine === false || p.src.match(/^(ftp|https?\:)?\/\//) ) {
return;
}
try {
if ( Object.keys(combined).indexOf(p.type) !== -1 ) {
const path = _path.join(dest, p.src);
try {
combined[p.type].push(_fs.readFileSync(path).toString());
} catch ( e ) {
_utils.log(String.color('Failed reading:', 'yellow'), path);
}
remove.push(path);
}
} catch ( e ) {
console.error(e);
}
});
if ( combined.javascript.length ) {
_fs.writeFileSync(_path.join(dest, 'combined.js'), combined.javascript.join('\n'));
}
if ( combined.stylesheet.length ) {
_fs.writeFileSync(_path.join(dest, 'combined.css'), combined.stylesheet.join('\n'));
}
const sfile = _path.join(dest, 'scheme.html');
if ( _fs.existsSync(sfile) ) {
var scheme = String(_fs.readFileSync(sfile));
const found = scheme.match(/<gui\-fragment\s+?data\-fragment\-external=\"(.*)\"\s+?\/>/g);
if ( found ) {
found.forEach(function(f) {
var src = f.split(/<gui\-fragment\s+?data\-fragment\-external=\"(.*)\"\s+?\/>/)[1];
src = _path.join(dest, src);
if ( src && _fs.existsSync(src) ) {
scheme = scheme.replace(f, String(_fs.readFileSync(src)));
remove.push(src);
}
});
}
_fs.writeFileSync(sfile, scheme);
}
remove.forEach(function(f) {
_fs.removeSync(f);
_fs.removeSync(f + '.map');
});
if ( standalone ) {
createStandaloneScheme(iter, dest);
}
iter.preload = _manifest.combinePreloads(iter);
_fs.writeFileSync(_path.join(dest, 'metadata.json'), JSON.stringify(iter, null, 4));
resolve(iter);
});
}).map(function(check) {
var raw = _fs.readFileSync(check);
return JSON.parse(raw);
});
/*
* Creates the HTTP, WebSocket and Proxy servers for OS.js
*/
function createServer(env, resolve, reject) {
const config = _instance.getConfig();
const httpConfig = config.http || {};
const logger = _instance.getLogger();
const tmpdir = (function() {
try {
return require('os').tmpdir();
} catch ( e ) {
return '/tmp';
}
})();
function onRequest(request, response) {
const rurl = request.url === '/' ? '/index.html' : request.url;
const url = _url.parse(rurl, true);
const path = decodeURIComponent(url.pathname);
const session_id = _session.init(request, response);
const contentType = request.headers['content-type'] || '';
if ( proxyCall(env, proxyServer, request, response) ) {
logger.log('VERBOSE', logger.colored('PROXY', 'bold'), path);
return;
}
logger.log('VERBOSE', logger.colored(request.method, 'bold'), path);
const respond = createHttpResponder(env, request, response);
if ( request.method === 'POST' ) {
if ( contentType.indexOf('application/json') !== -1 ) {
var body = [];
request.on('data', function(data) {
body.push(data);
});
request.on('end', function() {
const data = JSON.parse(Buffer.concat(body));
handleRequest(createHttpObject(request, response, path, data, respond, session_id));
});
} else if ( contentType.indexOf('multipart/form-data') !== -1 ) {
const form = new _formidable.IncomingForm({
uploadDir: tmpdir
});
form.parse(request, function(err, fields, files) {
handleRequest(createHttpObject(request, response, path, fields, respond, session_id, files));
});
}
} else {
handleRequest(createHttpObject(request, response, path, {}, respond, session_id));
}
}
// Proxy servers
try {
proxyServer = require('http-proxy').createProxyServer({});
proxyServer.on('error', function(err) {
console.warn(err);
});
} catch ( e ) {}
// HTTP servers
if ( httpConfig.mode === 'http2' || httpConfig.mode === 'https' ) {
const rdir = httpConfig.cert.path || env.SERVERDIR;
const cname = httpConfig.cert.name || 'localhost';
const copts = httpConfig.cert.options || {};
copts.key = _fs.readFileSync(_path.join(rdir, cname + '.key'));
copts.cert = _fs.readFileSync(_path.join(rdir, cname + '.crt'));
httpServer = require(httpConfig.mode).createServer(copts, onRequest);
} else {
httpServer = require('http').createServer(onRequest);
}
// Websocket servers
if ( httpConfig.connection === 'ws' ) {
const opts = {
server: httpServer
};
const port = httpConfig.ws ? httpConfig.ws.port : 'upgrade';
if ( port !== 'upgrade' ) {
opts.port = port;
}
websocketServer = new (require('ws')).Server(opts);
websocketServer.on('connection', function(ws) {
logger.log('VERBOSE', logger.colored('WS', 'bold'), 'New connection...');
const cookie = _cookie.parse(ws.upgradeReq.headers.cookie);
const sid = cookie.session;
ws.on('message', function(data) {
const message = JSON.parse(data);
const path = message.path;
const respond = createWebsocketResponder(ws, message._index);
handleRequest(createHttpObject({
method: 'POST',
url: path
}, null, path, message.args, respond, sid));
});
ws.on('close', function() {
logger.log('VERBOSE', logger.colored('WS', 'bold'), 'Connection closed...');
if ( typeof websocketMap[sid] !== 'undefined' ) {
delete websocketMap[sid];
}
});
websocketMap[sid] = ws;
});
}
// Middleware
const servers = {
httpServer: httpServer,
websocketServer: websocketServer,
proxyServer: proxyServer
};
const middleware = _instance.getMiddleware();
middleware.forEach(function(m) {
if ( typeof m.register === 'function' ) {
m.register(servers);
}
});
resolve(servers);
}
module.exports.readTemplate = function readTemplate(name) {
const tpls = _path.join(ROOT, 'src', 'templates');
return _fs.readFileSync(_path.join(tpls, name)).toString();
};