0.0.1

resources/[cfx-default]/[system]/[builders]/webpack/.gitignore

@@ -0,0 +1,2 @@
+.yarn.installed
+node_modules/

resources/[cfx-default]/[system]/[builders]/webpack/fxmanifest.lua

@@ -0,0 +1,13 @@
+-- This resource is part of the default Cfx.re asset pack (cfx-server-data)
+-- Altering or recreating for local use only is strongly discouraged.
+
+version '1.0.0'
+author 'Cfx.re <root@cfx.re>'
+description 'Builds resources with webpack. To learn more: https://webpack.js.org'
+repository 'https://github.com/citizenfx/cfx-server-data'
+
+dependency 'yarn'
+server_script 'webpack_builder.js'
+
+fx_version 'adamant'
+game 'common'

resources/[cfx-default]/[system]/[builders]/webpack/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "webpack-builder",
+  "version": "1.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "async": "^3.1.0",
+    "webpack": "^4.41.2",
+    "worker-farm": "^1.7.0"
+  }
+}

resources/[cfx-default]/[system]/[builders]/webpack/webpack_builder.js

@@ -0,0 +1,173 @@
+const fs = require('fs');
+const path = require('path');
+const workerFarm = require('worker-farm');
+const async = require('async');
+let buildingInProgress = false;
+let currentBuildingModule = '';
+
+// some modules will not like the custom stack trace logic
+const ops = Error.prepareStackTrace;
+Error.prepareStackTrace = undefined;
+
+const webpackBuildTask = {
+    shouldBuild(resourceName) {
+        const numMetaData = GetNumResourceMetadata(resourceName, 'webpack_config');
+
+        if (numMetaData > 0) {
+            for (let i = 0; i < numMetaData; i++) {
+                const configName = GetResourceMetadata(resourceName, 'webpack_config');
+
+                if (shouldBuild(configName)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+
+        function loadCache(config) {
+            const cachePath = `cache/${resourceName}/${config.replace(/\//g, '_')}.json`;
+
+            try {
+                return JSON.parse(fs.readFileSync(cachePath, {encoding: 'utf8'}));
+            } catch {
+                return null;
+            }
+        }
+
+        function shouldBuild(config) {
+            const cache = loadCache(config);
+
+            if (!cache) {
+                return true;
+            }
+
+            for (const file of cache) {
+                const stats = getStat(file.name);
+
+                if (!stats ||
+                    stats.mtime !== file.stats.mtime ||
+                    stats.size !== file.stats.size ||
+                    stats.inode !== file.stats.inode) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        function getStat(path) {
+            try {
+                const stat = fs.statSync(path);
+
+                return stat ? {
+                    mtime: stat.mtimeMs,
+                    size: stat.size,
+                    inode: stat.ino,
+                } : null;
+            } catch {
+                return null;
+            }
+        }
+    },
+
+    build(resourceName, cb) {
+        let buildWebpack = async () => {
+            let error = null;
+            const configs = [];
+            const promises = [];
+            const numMetaData = GetNumResourceMetadata(resourceName, 'webpack_config');
+
+            for (let i = 0; i < numMetaData; i++) {
+                configs.push(GetResourceMetadata(resourceName, 'webpack_config', i));
+            }
+
+            for (const configName of configs) {
+                const configPath = GetResourcePath(resourceName) + '/' + configName;
+
+                const cachePath = `cache/${resourceName}/${configName.replace(/\//g, '_')}.json`;
+
+                try {
+                    fs.mkdirSync(path.dirname(cachePath));
+                } catch {
+                }
+
+                const config = require(configPath);
+
+                const workers = workerFarm(require.resolve('./webpack_runner'));
+
+                if (config) {
+                    const resourcePath = path.resolve(GetResourcePath(resourceName));
+
+                    while (buildingInProgress) {
+                        console.log(`webpack is busy: we are waiting to compile ${resourceName} (${configName})`);
+                        await sleep(3000);
+                    }
+
+                    console.log(`${resourceName}: started building ${configName}`);
+
+                    buildingInProgress = true;
+                    currentBuildingModule = resourceName;
+
+                    promises.push(new Promise((resolve, reject) => {
+                        workers({
+                            configPath,
+                            resourcePath,
+                            cachePath
+                        }, (err, outp) => {
+                            workerFarm.end(workers);
+
+                            if (err) {
+                                console.error(err.stack || err);
+                                if (err.details) {
+                                    console.error(err.details);
+                                }
+
+                                buildingInProgress = false;
+                                currentBuildingModule = '';
+                                currentBuildingScript = '';
+                                reject("worker farm webpack errored out");
+                                return;
+                            }
+
+                            if (outp.errors) {
+                                for (const error of outp.errors) {
+                                    console.log(error);
+                                }
+                                buildingInProgress = false;
+                                currentBuildingModule = '';
+                                currentBuildingScript = '';
+                                reject("webpack got an error");
+                                return;
+                            }
+
+                            console.log(`${resourceName}: built ${configName}`);
+                            buildingInProgress = false;
+                            resolve();
+                        });
+                    }));
+                }
+            }
+
+            try {
+                await Promise.all(promises);
+            } catch (e) {
+                error = e.toString();
+            }
+
+            buildingInProgress = false;
+            currentBuildingModule = '';
+
+            if (error) {
+                cb(false, error);
+            } else cb(true);
+        };
+        buildWebpack().then();
+    }
+};
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+RegisterResourceBuildTaskFactory('z_webpack', () => webpackBuildTask);

resources/[cfx-default]/[system]/[builders]/webpack/webpack_runner.js

@@ -0,0 +1,75 @@
+const webpack = require('webpack');
+const path = require('path');
+const fs = require('fs');
+
+function getStat(path) {
+	try {
+		const stat = fs.statSync(path);
+
+		return stat ? {
+			mtime: stat.mtimeMs,
+			size: stat.size,
+			inode: stat.ino,
+		} : null;
+	} catch {
+		return null;
+	}
+}
+
+class SaveStatePlugin {
+	constructor(inp) {
+		this.cache = [];
+		this.cachePath = inp.cachePath;
+	}
+
+	apply(compiler) {
+		compiler.hooks.afterCompile.tap('SaveStatePlugin', (compilation) => {
+			for (const file of compilation.fileDependencies) {
+				this.cache.push({
+					name: file,
+					stats: getStat(file)
+				});
+			}
+		});
+
+		compiler.hooks.done.tap('SaveStatePlugin', (stats) => {
+			if (stats.hasErrors()) {
+				return;
+			}
+
+			fs.writeFile(this.cachePath, JSON.stringify(this.cache), () => {
+
+			});
+		});
+	}
+}
+
+module.exports = (inp, callback) => {
+	const config = require(inp.configPath);
+	
+	config.context = inp.resourcePath;
+	
+	if (config.output && config.output.path) {
+		config.output.path = path.resolve(inp.resourcePath, config.output.path);
+	}
+
+	if (!config.plugins) {
+		config.plugins = [];
+	}
+
+	config.plugins.push(new SaveStatePlugin(inp));
+	
+	webpack(config, (err, stats) => {
+		if (err) {
+			callback(err);
+			return;
+		}
+		
+		if (stats.hasErrors()) {
+			callback(null, stats.toJson());
+			return;
+		}
+		
+		callback(null, {});
+	});
+};