Weishen/Hydro
2
0 Fork 0
mirror of https://gitcode.com/gh_mirrors/hy/Hydro.git synced 2026-10-20 01:38:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

简化模块加载

Browse Source 
deprecated hydro-build
This commit is contained in:
undefined committed 2020-07-15 20:46:45 +08:00
1 parent 8aef05a375
commit 8f6968bbbd
41 files changed
+1361 -1957
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

build/buildModule.js
-108
View File
@@ -1,108 +0,0 @@
/* eslint-disable import/no-dynamic-require */
/* eslint-disable import/no-extraneous-dependencies */
/* eslint-disable no-await-in-loop */
const fs = require('fs');
const zlib = require('zlib');
const webpack = require('webpack');
const yaml = require('js-yaml');
const FriendlyErrorsPlugin = require('friendly-errors-webpack-plugin');
const { root, exist } = require('./utils');
const template = require('./template');
const prepare = ['model', 'lib', 'handler', 'service', 'script'];
const build = async (type) => {
const modules = fs.readdirSync(root('module'));
const failed = [];
const config = {
mode: type,
entry: {},
output: {
filename: 'module/[name].js',
path: root('.build'),
},
target: 'node',
module: {},
plugins: [
new webpack.ProgressPlugin(),
new FriendlyErrorsPlugin({
clearConsole: false,
}),
],
};
for (const i of modules) {
if (!i.startsWith('.')) {
try {
if (exist(`module/${i}/build.js`)) {
const builder = require(root(`module/${i}/build.js`));
if (builder.prebuild) await builder.prebuild();
}
for (const j of prepare) {
if (exist(`module/${i}/${j}.js`)) {
config.entry[`${i}/${j}`] = root(`module/${i}/${j}.js`);
}
}
} catch (e) {
console.error(`Module build fail: ${i}`);
console.error(e);
failed.push(i);
}
}
}
const compiler = webpack(config);
await new Promise((resolve, reject) => {
compiler.run((err, stats) => {
if (err) {
console.error(err.stack || err);
if (err.details) console.error(err.details);
reject();
}
if (stats.hasErrors()) process.exitCode = 1;
resolve();
});
});
for (const i of modules) {
if (!i.startsWith('.') && !failed.includes(i)) {
try {
const current = {};
for (const j of prepare) {
if (exist(`module/${i}/${j}.js`)) {
current[j] = fs.readFileSync(root(`.build/module/${i}/${j}.js`)).toString();
}
}
if (exist(`module/${i}/locale`)) {
const locales = fs.readdirSync(root(`module/${i}/locale`));
const lang = {};
for (const j of locales) {
const content = fs.readFileSync(root(`module/${i}/locale/${j}`)).toString();
lang[j.split('.')[0]] = yaml.safeLoad(content);
}
current.locale = lang;
}
if (exist(`module/${i}/template`)) {
current.template = template(`module/${i}/template`);
}
if (exist(`module/${i}/file`)) {
const files = fs.readdirSync(root(`module/${i}/file`));
current.file = {};
for (const file of files) {
current.file[file] = fs.readFileSync(root(`module/${i}/file/${file}`)).toString('base64');
}
}
const m = require(root(`module/${i}/hydro.json`));
current.description = m.description || '';
current.requirements = m.requirements || [];
current.version = m.version || 'unknown';
current.id = m.id;
if (m.os) current.os = m.os;
const data = zlib.gzipSync(Buffer.from(yaml.safeDump(current)), { level: -1 });
fs.writeFileSync(root(`.build/module/${i}.hydro`), data);
} catch (e) {
console.error(`Module build fail: ${i}`);
console.error(e);
}
}
}
};
module.exports = build;
build/index.js
+5 -76
View File
@@ -1,88 +1,17 @@
/* eslint-disable no-await-in-loop */
const fs = require('fs');
const path = require('path');
const zlib = require('zlib');
const yaml = require('js-yaml');
const fs = require('fs-extra');
const argv = require('yargs-parser')(process.argv.slice(2));
const { root, ignoreFailure, rmdir } = require('./utils');
const template = require('./template');
const hack = require('./hack');
const wikiBuild = require('./wiki');
const fsp = fs.promises;
function getFiles(folder) {
const res = [];
const files = fs.readdirSync(root(folder));
for (const filename of files) {
res.push(filename);
if (fs.statSync(root(path.join(folder, filename))).isDirectory()) {
res.push(...(getFiles(path.join(folder, filename)).map((i) => path.join(filename, i))));
}
}
return res;
}
async function build(type) {
if (!['development', 'production'].includes(type)) throw new Error(`Unknown type: ${type}`);
ignoreFailure(fs.mkdirSync, root('.build'));
ignoreFailure(fs.mkdirSync, root('.build/module'));
for (const task in hack) {
hack[task]();
}
const langs = fs.readdirSync(root('locales'));
const locale = {};
for (const i of langs) {
const content = fs.readFileSync(root(`locales/${i}`)).toString();
locale[i.split('.')[0]] = yaml.safeLoad(content);
}
const builtin = {
id: 'builtin',
locale,
template: template('templates'),
public: {},
};
const wiki = wikiBuild();
builtin.lib = `Object.assign(global.Hydro.wiki,${JSON.stringify(wiki)})`;
const files = getFiles('.uibuild');
for (const f of files) {
if (fs.statSync(root(`.uibuild/${f}`)).isDirectory()) {
builtin.public[f] = null;
} else {
builtin.public[f] = fs.readFileSync(root(`.uibuild/${f}`)).toString('base64');
}
}
const data = zlib.gzipSync(Buffer.from(yaml.safeDump(builtin)), { level: -1 });
fs.writeFileSync(root('.build/module/builtin.hydro'), data);
console.log('Build::Module');
await require('./buildModule')(type);
fs.ensureDirSync(path.resolve(__dirname, '..', '.build'));
for (const task in hack) hack[task]();
console.log('Build::Main');
await require('./webpack')(type);
const t = fs.readdirSync(root('.build/module'));
for (const f of t) {
if (fs.statSync(root(`.build/module/${f}`)).isDirectory()) {
rmdir(root(`.build/module/${f}`));
}
}
const modules = await fsp.readdir(root('.build/module'));
const j = {};
for (const m of modules) {
try {
const d = await fsp.readFile(root(`.build/module/${m}`));
j[m] = d.toString('base64');
} catch (e) {
console.error(`Module pack failed: ${m}`);
}
}
const f = fs.readFileSync(root('.build/app.js')).toString();
const installer = fs.readFileSync(root('tool/install.js')).toString();
const hydro = {};
hydro.app = Buffer.from(f).toString('base64');
hydro.modules = j;
const d = zlib.gzipSync(Buffer.from(JSON.stringify(hydro)), { level: -1 }).toString('base64');
fs.writeFileSync(root('.build/install.js'), `global.Hydro="${d}"; ${installer}`);
console.log('Build::Resources');
require('./resource')(type);
}
build(argv.development ? 'development' : 'production').catch((e) => {
build/resource.js
+13
View File
@@ -0,0 +1,13 @@
const AdmZip = require('adm-zip');
function build() {
const zip = new AdmZip();
zip.addLocalFolder('public', 'public');
zip.addLocalFolder('locales', 'locales');
zip.addLocalFolder('templates', 'templates');
zip.addLocalFolder('wiki', 'wiki');
zip.addLocalFile('package.json');
zip.writeZip('.build/builtin.hydro');
}
module.exports = build;
build/template.js
-30
View File
@@ -1,30 +0,0 @@
const fs = require('fs');
const { root } = require('./utils');
function getFiles(folder) {
const files = [];
const f = fs.readdirSync(root(folder));
for (const i of f) {
if (!i.startsWith('.')) {
if (fs.statSync(root(`${folder}/${i}`)).isDirectory()) {
const g = getFiles(`${folder}/${i}`);
for (const j of g) files.push(`${i}/${j}`);
} else files.push(i);
}
}
return files;
}
const build = (dirOrObject) => {
let templates = {};
if (typeof dirOrObject === 'string') {
const files = getFiles(dirOrObject);
for (const i of files) {
const template = fs.readFileSync(root(`${dirOrObject}/${i}`)).toString();
templates[i] = template;
}
} else templates = dirOrObject;
return templates;
};
module.exports = build;
build/utils.js
-28
View File
@@ -1,28 +0,0 @@
const fs = require('fs');
const path = require('path');
exports.root = (name) => path.resolve(__dirname, '..', name);
exports.exist = (name) => {
try {
fs.statSync(exports.root(name));
} catch (e) {
return false;
}
return true;
};
exports.rmdir = function rmdir(p, recursive = true) {
if (!fs.existsSync(p)) return;
if (recursive) {
fs.readdirSync(p).forEach((file) => {
const curPath = `${p}/${file}`;
if (fs.statSync(curPath).isDirectory()) rmdir(curPath);
else fs.unlinkSync(curPath);
});
}
fs.rmdirSync(p);
};
exports.ignoreFailure = function ignoreFailure(func, ...params) {
try {
func(...params);
} catch (e) { } // eslint-disable-line no-empty
};
build/webpack.js
+2 -3
View File
@@ -2,17 +2,16 @@
const path = require('path');
const webpack = require('webpack');
const FriendlyErrorsPlugin = require('friendly-errors-webpack-plugin');
const { root } = require('./utils');
const build = async (type) => {
const config = {
mode: type,
entry: {
app: root('hydro/loader.ts'),
app: path.resolve(__dirname, '..', 'hydro', 'loader.ts'),
},
output: {
filename: '[name].js',
path: root('.build'),
path: path.resolve(__dirname, '..', '.build'),
},
target: 'node',
module: {
build/wiki.js
-31
View File
@@ -1,31 +0,0 @@
const fs = require('fs');
const { root } = require('./utils');
module.exports = () => {
const categories = fs.readdirSync(root('wiki'));
const r = {};
for (const category of categories) {
const pages = fs.readdirSync(root(`wiki/${category}`));
const res = {};
for (const page of pages) {
const c = fs.readFileSync(root(`wiki/${category}/${page}`)).toString().split('\n');
const pagename = page.split('.')[0];
res[pagename] = [];
let content = null;
for (let i = 0; i < c.length; i++) {
const line = c[i];
if (line.startsWith('# ')) {
if (content) res[pagename].push(content);
content = {};
const t = line.split('# ')[1].split('|');
[content.title, content.id] = t.map((q) => q.trim());
content.content = '';
} else {
content.content = `${content.content}${line}\n`;
}
}
}
r[category] = res;
}
return r;
};