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	rakinar2	577	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();