blaze/wrapper/blaze_wrapper.mjs

import { spawnSync } from "child_process";
import { existsSync, readFileSync } from "fs";
import path from "path";

const colors = {
    red: "\x1b[31m",
    green: "\x1b[32m",
    yellow: "\x1b[33m",
    blue: "\x1b[34m",
    magenta: "\x1b[35m",
    cyan: "\x1b[36m",
    bold: "\x1b[1m",
    reset: "\x1b[0m"
};

function getVersion() {
    return getProperty("blaze.version", "1.0.0-alpha.1");
}

function usage() {
    console.log("Usage: %s [file] --- [args...]", process.argv0);
    process.exit(1);
}

function startup() {
    console.log(
        `${colors.bold}${colors.blue}BlazeBuild Wrapper version ${getVersion()}${colors.reset}\n`
    );
}

function help() {
    startup();

    console.log(`${colors.bold}Usage:${colors.reset}\n  %s [file] --- [args...]\n`, process.argv0);

    console.log(`${colors.bold}Options:${colors.reset}`);
    console.log("  --help, -h       Show this help message and exit.");
    console.log("  --version, -v    Show the version number and exit.");
    console.log("  --quiet, -q      Disable output.");
    console.log("  --debug          Enable debug mode.");

    process.exit(0);
}

function version() {
    console.log(getVersion());
    process.exit(0);
}

const PROPERTIES_PATH = path.resolve(__dirname, "blaze_wrapper.properties");
const PROJECT_DIR = path.resolve(__dirname, "..", "..");
let properties = {};

function readProperties() {
    if (!existsSync(PROPERTIES_PATH)) {
        return;
    }

    const contents = readFileSync(PROPERTIES_PATH, {
        encoding: "utf8"
    });

    properties = contents.split("\n").reduce((acc, line) => {
        if (!line?.trim() || line.startsWith("#")) {
            return acc;
        }
        
        const [key, value] = line.split("=");
        acc[key.trim()] = value.trim();
        return acc;
    }, {});
}

/**
 * Get a property from the blaze configuration.
 *
 * @param {string} name The name of the property.
 * @returns {string} The value of the property.
 */
function getProperty(name, def) {
    return properties[name] ?? def;
}

function determineIndexFile() {
    const blazeSrcPath = getProperty("blaze.srcpath", "build_src");
    return path.resolve(PROJECT_DIR, blazeSrcPath, "src/main/typescript/cli.ts");
}


function getBunPath() {
    if (process.isBun) {
        return process.argv[0];
    }

    throw new Error("Node.js is not supported. Please use Bun.");
}

/**
 * Execute a file with the given arguments.
 *
 * @param {string} file
 * @param {...string} args
 */
function execute(file, ...args) {
    const { status } = spawnSync(getBunPath(), [file, ...args], {
        stdio: process.env.BLAZE_QUIET === "1" ? "ignore" : "inherit",
        env: {
            ...process.env,
            PATH: `${process.env.PATH}:${path.resolve(process.cwd(), "node_modules/.bin")}`
        }
    });

    if (status !== 0) {
        process.exit(status);
    }
}

function initialize() {
    readProperties();
}

function main() {
    const OPTIONS = ["--help", "-h", "--version", "-v", "--quiet", "-q", "--debug"];

    if (process.argv.length < 3) {
        usage();
    }

    const index = process.argv.indexOf("---");

    if (index === -1) {
        usage();
    }

    initialize();

    const args = process.argv.slice(index + 1).filter(arg => !OPTIONS.includes(arg));
    const file =
        process.argv.at(index - 1) === __filename
            ? determineIndexFile()
            : process.argv.at(index - 1);

    if (process.argv.includes("--help") || process.argv.includes("-h")) {
        help();
    } else if (process.argv.includes("--version") || process.argv.includes("-v")) {
        version();
    } else if (process.argv.includes("--quiet") || process.argv.includes("-q")) {
        process.env.BLAZE_QUIET = "1";
    } else if (process.argv.includes("--debug")) {
        process.env.DEBUG = "1";
    }

    execute(file, ...args);
}

main();
1	import { spawnSync } from "child_process";
2	import { existsSync, readFileSync } from "fs";
3	import path from "path";
4
5	const colors = {
6	red: "\x1b[31m",
7	green: "\x1b[32m",
8	yellow: "\x1b[33m",
9	blue: "\x1b[34m",
10	magenta: "\x1b[35m",
11	cyan: "\x1b[36m",
12	bold: "\x1b[1m",
13	reset: "\x1b[0m"
14	};
15
16	function getVersion() {
17	return getProperty("blaze.version", "1.0.0-alpha.1");
18	}
19
20	function usage() {
21	console.log("Usage: %s [file] --- [args...]", process.argv0);
22	process.exit(1);
23	}
24
25	function startup() {
26	console.log(
27	`${colors.bold}${colors.blue}BlazeBuild Wrapper version ${getVersion()}${colors.reset}\n`
28	);
29	}
30
31	function help() {
32	startup();
33
34	console.log(`${colors.bold}Usage:${colors.reset}\n %s [file] --- [args...]\n`, process.argv0);
35
36	console.log(`${colors.bold}Options:${colors.reset}`);
37	console.log(" --help, -h Show this help message and exit.");
38	console.log(" --version, -v Show the version number and exit.");
39	console.log(" --quiet, -q Disable output.");
40	console.log(" --debug Enable debug mode.");
41
42	process.exit(0);
43	}
44
45	function version() {
46	console.log(getVersion());
47	process.exit(0);
48	}
49
50	const PROPERTIES_PATH = path.resolve(__dirname, "blaze_wrapper.properties");
51	const PROJECT_DIR = path.resolve(__dirname, "..", "..");
52	let properties = {};
53
54	function readProperties() {
55	if (!existsSync(PROPERTIES_PATH)) {
56	return;
57	}
58
59	const contents = readFileSync(PROPERTIES_PATH, {
60	encoding: "utf8"
61	});
62
63	properties = contents.split("\n").reduce((acc, line) => {
64	if (!line?.trim() \|\| line.startsWith("#")) {
65	return acc;
66	}
67
68	const [key, value] = line.split("=");
69	acc[key.trim()] = value.trim();
70	return acc;
71	}, {});
72	}
73
74	/**
75	* Get a property from the blaze configuration.
76	*
77	* @param {string} name The name of the property.
78	* @returns {string} The value of the property.
79	*/
80	function getProperty(name, def) {
81	return properties[name] ?? def;
82	}
83
84	function determineIndexFile() {
85	const blazeSrcPath = getProperty("blaze.srcpath", "build_src");
86	return path.resolve(PROJECT_DIR, blazeSrcPath, "src/main/typescript/cli.ts");
87	}
88
89
90	function getBunPath() {
91	if (process.isBun) {
92	return process.argv[0];
93	}
94
95	throw new Error("Node.js is not supported. Please use Bun.");
96	}
97
98	/**
99	* Execute a file with the given arguments.
100	*
101	* @param {string} file
102	* @param {...string} args
103	*/
104	function execute(file, ...args) {
105	const { status } = spawnSync(getBunPath(), [file, ...args], {
106	stdio: process.env.BLAZE_QUIET === "1" ? "ignore" : "inherit",
107	env: {
108	...process.env,
109	PATH: `${process.env.PATH}:${path.resolve(process.cwd(), "node_modules/.bin")}`
110	}
111	});
112
113	if (status !== 0) {
114	process.exit(status);
115	}
116	}
117
118	function initialize() {
119	readProperties();
120	}
121
122	function main() {
123	const OPTIONS = ["--help", "-h", "--version", "-v", "--quiet", "-q", "--debug"];
124
125	if (process.argv.length < 3) {
126	usage();
127	}
128
129	const index = process.argv.indexOf("---");
130
131	if (index === -1) {
132	usage();
133	}
134
135	initialize();
136
137	const args = process.argv.slice(index + 1).filter(arg => !OPTIONS.includes(arg));
138	const file =
139	process.argv.at(index - 1) === __filename
140	? determineIndexFile()
141	: process.argv.at(index - 1);
142
143	if (process.argv.includes("--help") \|\| process.argv.includes("-h")) {
144	help();
145	} else if (process.argv.includes("--version") \|\| process.argv.includes("-v")) {
146	version();
147	} else if (process.argv.includes("--quiet") \|\| process.argv.includes("-q")) {
148	process.env.BLAZE_QUIET = "1";
149	} else if (process.argv.includes("--debug")) {
150	process.env.DEBUG = "1";
151	}
152
153	execute(file, ...args);
154	}
155
156	main();