@steambrew/ttc 1.0.0

package/Compiler.ts

@@ -0,0 +1,245 @@
+import { OutputOptions, RollupOptions, rollup } from "rollup";
+import json from '@rollup/plugin-json';
+import commonjs from '@rollup/plugin-commonjs';
+import replace from '@rollup/plugin-replace';
+import typescript from '@rollup/plugin-typescript';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import terser from '@rollup/plugin-terser';
+
+import chalk from 'chalk'
+import { Logger } from "./Logger";
+import fs from 'fs';
+
+declare global {
+    interface Window {
+        PLUGIN_LIST: any
+    }
+}
+
+declare const pluginName: string, millennium_main: any, MILLENNIUM_BACKEND_IPC: any
+
+export interface TranspilerProps {
+    bTersePlugin?: boolean,
+    strPluginInternalName: string
+}
+
+const WrappedCallServerMethod = "const __call_server_method__ = (methodName, kwargs) => Millennium.callServerMethod(pluginName, methodName, kwargs)"
+const WrappedCallable = "const __wrapped_callable__ = (route) => MILLENNIUM_API.callable(__call_server_method__, route)"
+
+/**
+ * @description Append the active plugin to the global plugin 
+ * list and notify that the frontend Loaded.
+ */
+function ExecutePluginModule() {
+	// Assign the plugin on plugin list. 
+	Object.assign(window.PLUGIN_LIST[pluginName], millennium_main)
+	// Run the rolled up plugins default exported function 
+	millennium_main["default"]();
+	MILLENNIUM_BACKEND_IPC.postMessage(1, { pluginName: pluginName })
+}
+
+/**
+ * @description Append the active plugin to the global plugin 
+ * list and notify that the frontend Loaded.
+ */
+function ExecuteWebkitModule() {
+	// Assign the plugin on plugin list. 
+	Object.assign(window.PLUGIN_LIST[pluginName], millennium_main)
+	// Run the rolled up plugins default exported function 
+	millennium_main["default"]();
+}
+
+/**
+ * @description Simple bootstrap function that initializes PLUGIN_LIST 
+ * for current plugin given that is doesnt exist. 
+ */
+function InitializePlugins() {
+	/** 
+	 * This function is called n times depending on n plugin count,
+	 * Create the plugin list if it wasn't already created 
+	 */
+	!window.PLUGIN_LIST && (window.PLUGIN_LIST = {})
+
+	// initialize a container for the plugin
+	if (!window.PLUGIN_LIST[pluginName]) {
+		window.PLUGIN_LIST[pluginName] = {};
+	}
+}
+
+function InsertMillennium(props: TranspilerProps) 
+{
+    const ContructFunctions = (parts: any) => { return parts.join('\n'); }
+
+    const generateBundle = (_: unknown, bundle: any) => {	
+
+		for (const fileName in bundle) 
+		{
+			if (bundle[fileName].type != 'chunk') {
+				continue 
+			}
+            Logger.Info("Injecting Millennium shims into module... " + chalk.green.bold("okay"))
+
+			bundle[fileName].code = ContructFunctions([    
+				`const pluginName = "${props.strPluginInternalName}";`,
+                // insert the bootstrap function and call it
+				InitializePlugins.toString(), InitializePlugins.name + "()",
+				WrappedCallServerMethod, 
+                WrappedCallable, 
+                bundle[fileName].code,
+				ExecutePluginModule.toString(), ExecutePluginModule.name + "()"
+			])
+		}
+    }
+
+    return {
+        name: 'add-plugin-main', generateBundle
+    };
+}
+
+function InsertWebkitMillennium(props: TranspilerProps) 
+{
+    const ContructFunctions = (parts: any) => { return parts.join('\n'); }
+
+    const generateBundle = (_: unknown, bundle: any) => {	
+
+		for (const fileName in bundle) 
+		{
+			if (bundle[fileName].type != 'chunk') {
+				continue 
+			}
+            Logger.Info("Injecting Millennium shims into webkit module... " + chalk.green.bold("okay"))
+
+			bundle[fileName].code = ContructFunctions([    
+                // define the plugin name at the top of the bundle, so it can be used in wrapped functions
+				`const pluginName = "${props.strPluginInternalName}";`,
+                // insert the bootstrap function and call it
+                InitializePlugins.toString(), InitializePlugins.name + "()",
+                // TODO
+				WrappedCallServerMethod, WrappedCallable, bundle[fileName].code,
+				ExecuteWebkitModule.toString(), ExecuteWebkitModule.name + "()"
+			])
+		}
+    }
+
+    return {
+        name: 'add-plugin-main', generateBundle
+    };
+}
+
+function GetPluginComponents(props: TranspilerProps) {
+	const pluginList = [
+        /**
+         * @brief resolve millennium, edit the exported bundle to work with millennium
+         */
+        InsertMillennium(props),
+		typescript(), nodeResolve(), commonjs(), json(),
+		replace({
+			preventAssignment: true,
+            'process.env.NODE_ENV': JSON.stringify('production'),
+			// replace callServerMethod with wrapped replacement function. 
+			'Millennium.callServerMethod': `__call_server_method__`,
+            'client.callable': `__wrapped_callable__`,
+			delimiters: ['', ''],
+			'client.pluginSelf': 'window.PLUGIN_LIST[pluginName]',
+            'client.Millennium.exposeObj(': 'client.Millennium.exposeObj(exports, '
+		}),
+	]
+	
+	if (props.bTersePlugin) {
+		pluginList.push(terser())
+	}
+	return pluginList
+}
+
+function GetWebkitPluginComponents(props: TranspilerProps) {
+	const pluginList = [
+        InsertWebkitMillennium(props), typescript(), nodeResolve(), commonjs(), json(),
+        replace({
+			preventAssignment: true,
+			// replace callServerMethod with wrapped replacement function. 
+			'Millennium.callServerMethod': `__call_server_method__`,
+            'client.callable': `__wrapped_callable__`,
+			delimiters: ['', ''],
+		}),
+	]
+	
+	if (props.bTersePlugin) {
+		pluginList.push(terser())
+	}
+	return pluginList
+}
+
+const GetFrontEndDirectory = () => {
+    const pluginJsonPath = './plugin.json';
+
+    try {
+        const pluginJson = JSON.parse(fs.readFileSync(pluginJsonPath, 'utf8'));
+        const frontendDirectory = pluginJson?.frontend;
+
+        return frontendDirectory ? frontendDirectory : "frontend";
+    } 
+    catch (error) {
+        return "frontend";
+    }
+}
+
+export const TranspilerPluginComponent = async (props: TranspilerProps) => {
+    
+    const frontendRollupConfig: RollupOptions = {
+        input: `./${GetFrontEndDirectory()}/index.tsx`,
+        plugins: GetPluginComponents(props),
+        context: 'window',
+        external: ['react', 'react-dom', '@steambrew/client'],
+        output: {
+            name: "millennium_main",
+            file: ".millennium/Dist/index.js",
+            globals: {
+                react: "window.SP_REACT",
+                "react-dom": "window.SP_REACTDOM",
+                "@steambrew/client": "window.MILLENNIUM_API"
+            },
+            exports: 'named',
+            format: 'iife'
+        }
+    }
+
+    const webkitRollupConfig: RollupOptions = {
+        input: `./webkit/index.ts`,
+        plugins: GetWebkitPluginComponents(props),
+        context: 'window',
+        external: ['@steambrew/client'],
+        output: {
+            name: "millennium_main",
+            file: ".millennium/Dist/webkit.js",
+            exports: 'named',
+            format: 'iife',
+            globals: {
+                "@steambrew/client": "window.MILLENNIUM_API"
+            },
+        }
+    }
+
+    Logger.Info("Starting build; this may take a few moments...")
+    // Load the Rollup configuration file
+    try {
+        const bundle = await rollup(frontendRollupConfig);
+        const outputOptions = frontendRollupConfig.output as OutputOptions;
+    
+        await bundle.write(outputOptions);
+
+        // check if the webkit file exists
+        if (fs.existsSync(`./webkit/index.ts`)) {
+            Logger.Info("Compiling webkit module...")
+
+            const bundle1 = await rollup(webkitRollupConfig);
+            const outputOptions1 = webkitRollupConfig.output as OutputOptions;
+        
+            await bundle1.write(outputOptions1);
+        }
+        
+        Logger.Info('Build succeeded!', Number((performance.now() - global.PerfStartTime).toFixed(3)), 'ms elapsed.')
+    }
+    catch (exception) {
+        Logger.Error('Build failed!', exception)
+    }
+}

package/Linter.ts

@@ -0,0 +1,44 @@
+import chalk from 'chalk'
+import path from 'path'
+import { existsSync, readFile } from 'fs'
+
+export const ValidatePlugin = (target: string): Promise<any> => {
+
+    return new Promise<any>((resolve, reject) => {
+        if (!existsSync(target)) {
+            console.error(chalk.red.bold(`\n[-] --target [${target}] `) + chalk.red("is not a valid system path"))
+            reject() 
+            return
+        }
+        
+        const pluginModule = path.join(target, "plugin.json")
+        
+        if (!existsSync(pluginModule)) {
+            console.error(chalk.red.bold(`\n[-] --target [${target}] `) + chalk.red("is not a valid plugin (missing plugin.json)"))
+            reject()
+            return
+        }
+        
+        readFile(pluginModule, 'utf8', (err, data) => {
+            if (err) {
+                console.error(chalk.red.bold(`\n[-] couldn't read plugin.json from [${pluginModule}]`))
+                reject()
+                return
+            }
+        
+            try {
+                if (!("name" in JSON.parse(data))) {
+                    console.error(chalk.red.bold(`\n[-] target plugin doesn't contain "name" in plugin.json [${pluginModule}]`))
+                    reject()
+                }
+                else {
+                    resolve(JSON.parse(data)) 
+                }
+            } 
+            catch (parseError) {
+                console.error(chalk.red.bold(`\n[-] couldn't parse JSON in plugin.json from [${pluginModule}]`))
+                reject()
+            }
+        });
+    })
+}

package/Logger.ts

@@ -0,0 +1,49 @@
+import chalk from 'chalk'
+
+const Logger = {
+
+    Info: (...LogMessage: any) => {
+        console.log(chalk.magenta.bold("[+]"), ...LogMessage)
+    },
+
+    Warn: (...LogMessage: any) => {
+        console.log(chalk.yellow.bold("[*]"), ...LogMessage)
+    },
+
+    Error: (...LogMessage: any) => {
+        console.log(chalk.red.bold("[-]"), ...LogMessage)
+    },
+
+    Tree: (strTitle: string, LogObject: any) => { 
+
+        console.log(chalk.magenta.bold("[┬]"), strTitle);
+
+        const isLocalPath = (strTestPath: string): boolean => {
+            // Regular expression to match common file path patterns
+            const filePathRegex = /^(\/|\.\/|\.\.\/|\w:\/)?([\w-.]+\/)*[\w-.]+\.\w+$/;
+            return filePathRegex.test(strTestPath);
+        }
+
+        const entries = Object.entries(LogObject);
+        const totalEntries = entries.length;
+
+        for (const [index, [key, value]] of entries.entries()) {
+
+            const connector = index === totalEntries - 1 ? "└" : "├"
+            let color = chalk.white
+
+            switch (typeof value) {
+                case typeof String(): {
+                    color = isLocalPath(value as string) ? chalk.blueBright : chalk.white; 
+                    break
+                }
+                case typeof Boolean(): color = chalk.green; break
+                case typeof Number(): color = chalk.yellow; break
+            }
+
+            console.log(chalk.magenta.bold(` ${connector}──${key}:`), color(value))
+        }
+    }
+}
+
+export { Logger }

package/Parameters.ts

@@ -0,0 +1,72 @@
+import chalk from 'chalk'
+import { Logger } from "./Logger"
+
+/***
+ * @brief print the parameter list to the stdout
+ */
+export const PrintParamHelp = () => {
+
+    console.log(
+        "millennium-ttc parameter list:" +
+        "\n\t" + chalk.magenta("--help") + ": display parameter list" +
+        "\n\t" + chalk.bold.red("--build") + ": " + chalk.bold.red("(required)") + ": build type [dev, prod] (prod minifies code)" +
+        "\n\t" + chalk.magenta("--target") + ": path to plugin, default to cwd"
+    );
+}
+
+export enum BuildType {
+    DevBuild, ProdBuild
+}
+
+export interface ParameterProps {
+    type: BuildType, 
+    targetPlugin: string // path
+}
+
+export const ValidateParameters = (args: Array<string>): ParameterProps => {
+
+    let typeProp: BuildType = BuildType.DevBuild, targetProp: string = process.cwd()
+
+    if (args.includes("--help")) {
+        PrintParamHelp()
+        process.exit();
+    }
+    
+    // startup args are invalid
+    if (!args.includes("--build")) {
+        Logger.Error("Received invalid arguments...");
+        PrintParamHelp();
+        process.exit();
+    }
+    
+    for (let i = 0; i < args.length; i++) 
+    {
+        if (args[i] === "--build") 
+        {
+            const BuildMode: string = args[i + 1]
+
+            switch (BuildMode) {
+                case "dev": typeProp = BuildType.DevBuild; break
+                case "prod": typeProp = BuildType.ProdBuild; break
+                default: {
+                    Logger.Error('--build parameter must be preceded by build type [dev, prod]');
+                    process.exit();
+                }
+            }
+        }
+    
+        if (args[i] == "--target") {
+            if (args[i + 1] === undefined) {
+                Logger.Error('--target parameter must be preceded by system path');
+                process.exit();
+            }
+
+            targetProp = args[i + 1]
+        }
+    }
+
+    return {
+        type: typeProp,
+        targetPlugin: targetProp
+    }
+}

package/VersionMon.ts

@@ -0,0 +1,28 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { readFile } from 'fs/promises';
+import { dirname } from 'path';
+import { Logger } from './Logger';
+
+export const CheckForUpdates = async (): Promise<boolean> => {
+    return new Promise<boolean>(async (resolve) => {
+        const packageJsonPath = path.resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+        const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+    
+        fetch("https://registry.npmjs.org/millennium-lib").then(response => response.json()).then(json => {
+
+            if (json?.["dist-tags"]?.latest != packageJson.version) {
+  
+                Logger.Tree(`millennium-lib@${packageJson.version} requires update to ${json?.["dist-tags"]?.latest}`, {
+                    cmd: "run `npm i millennium-lib` to get latest updates!"
+                })
+
+                resolve(true)
+            }
+            else {
+                Logger.Info(`millennium-lib@${packageJson.version} is up-to-date!`)
+                resolve(false)
+            }
+        })
+    })
+}

package/dist/index.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { readFile } from 'fs/promises';
+import fs, { existsSync, readFile as readFile$1 } from 'fs';
+import { rollup } from 'rollup';
+import json from '@rollup/plugin-json';
+import commonjs from '@rollup/plugin-commonjs';
+import replace from '@rollup/plugin-replace';
+import typescript from '@rollup/plugin-typescript';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import terser from '@rollup/plugin-terser';
+import { performance as performance$1 } from 'perf_hooks';
+
+const Logger = {
+    Info: (...LogMessage) => {
+        console.log(chalk.magenta.bold("[+]"), ...LogMessage);
+    },
+    Warn: (...LogMessage) => {
+        console.log(chalk.yellow.bold("[*]"), ...LogMessage);
+    },
+    Error: (...LogMessage) => {
+        console.log(chalk.red.bold("[-]"), ...LogMessage);
+    },
+    Tree: (strTitle, LogObject) => {
+        console.log(chalk.magenta.bold("[┬]"), strTitle);
+        const isLocalPath = (strTestPath) => {
+            // Regular expression to match common file path patterns
+            const filePathRegex = /^(\/|\.\/|\.\.\/|\w:\/)?([\w-.]+\/)*[\w-.]+\.\w+$/;
+            return filePathRegex.test(strTestPath);
+        };
+        const entries = Object.entries(LogObject);
+        const totalEntries = entries.length;
+        for (const [index, [key, value]] of entries.entries()) {
+            const connector = index === totalEntries - 1 ? "└" : "├";
+            let color = chalk.white;
+            switch (typeof value) {
+                case typeof String(): {
+                    color = isLocalPath(value) ? chalk.blueBright : chalk.white;
+                    break;
+                }
+                case typeof Boolean():
+                    color = chalk.green;
+                    break;
+                case typeof Number():
+                    color = chalk.yellow;
+                    break;
+            }
+            console.log(chalk.magenta.bold(` ${connector}──${key}:`), color(value));
+        }
+    }
+};
+
+/***
+ * @brief print the parameter list to the stdout
+ */
+const PrintParamHelp = () => {
+    console.log("millennium-ttc parameter list:" +
+        "\n\t" + chalk.magenta("--help") + ": display parameter list" +
+        "\n\t" + chalk.bold.red("--build") + ": " + chalk.bold.red("(required)") + ": build type [dev, prod] (prod minifies code)" +
+        "\n\t" + chalk.magenta("--target") + ": path to plugin, default to cwd");
+};
+var BuildType;
+(function (BuildType) {
+    BuildType[BuildType["DevBuild"] = 0] = "DevBuild";
+    BuildType[BuildType["ProdBuild"] = 1] = "ProdBuild";
+})(BuildType || (BuildType = {}));
+const ValidateParameters = (args) => {
+    let typeProp = BuildType.DevBuild, targetProp = process.cwd();
+    if (args.includes("--help")) {
+        PrintParamHelp();
+        process.exit();
+    }
+    // startup args are invalid
+    if (!args.includes("--build")) {
+        Logger.Error("Received invalid arguments...");
+        PrintParamHelp();
+        process.exit();
+    }
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--build") {
+            const BuildMode = args[i + 1];
+            switch (BuildMode) {
+                case "dev":
+                    typeProp = BuildType.DevBuild;
+                    break;
+                case "prod":
+                    typeProp = BuildType.ProdBuild;
+                    break;
+                default: {
+                    Logger.Error('--build parameter must be preceded by build type [dev, prod]');
+                    process.exit();
+                }
+            }
+        }
+        if (args[i] == "--target") {
+            if (args[i + 1] === undefined) {
+                Logger.Error('--target parameter must be preceded by system path');
+                process.exit();
+            }
+            targetProp = args[i + 1];
+        }
+    }
+    return {
+        type: typeProp,
+        targetPlugin: targetProp
+    };
+};
+
+const CheckForUpdates = async () => {
+    return new Promise(async (resolve) => {
+        const packageJsonPath = path.resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
+        const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'));
+        fetch("https://registry.npmjs.org/millennium-lib").then(response => response.json()).then(json => {
+            if (json?.["dist-tags"]?.latest != packageJson.version) {
+                Logger.Tree(`millennium-lib@${packageJson.version} requires update to ${json?.["dist-tags"]?.latest}`, {
+                    cmd: "run `npm i millennium-lib` to get latest updates!"
+                });
+                resolve(true);
+            }
+            else {
+                Logger.Info(`millennium-lib@${packageJson.version} is up-to-date!`);
+                resolve(false);
+            }
+        });
+    });
+};
+
+const ValidatePlugin = (target) => {
+    return new Promise((resolve, reject) => {
+        if (!existsSync(target)) {
+            console.error(chalk.red.bold(`\n[-] --target [${target}] `) + chalk.red("is not a valid system path"));
+            reject();
+            return;
+        }
+        const pluginModule = path.join(target, "plugin.json");
+        if (!existsSync(pluginModule)) {
+            console.error(chalk.red.bold(`\n[-] --target [${target}] `) + chalk.red("is not a valid plugin (missing plugin.json)"));
+            reject();
+            return;
+        }
+        readFile$1(pluginModule, 'utf8', (err, data) => {
+            if (err) {
+                console.error(chalk.red.bold(`\n[-] couldn't read plugin.json from [${pluginModule}]`));
+                reject();
+                return;
+            }
+            try {
+                if (!("name" in JSON.parse(data))) {
+                    console.error(chalk.red.bold(`\n[-] target plugin doesn't contain "name" in plugin.json [${pluginModule}]`));
+                    reject();
+                }
+                else {
+                    resolve(JSON.parse(data));
+                }
+            }
+            catch (parseError) {
+                console.error(chalk.red.bold(`\n[-] couldn't parse JSON in plugin.json from [${pluginModule}]`));
+                reject();
+            }
+        });
+    });
+};
+
+const WrappedCallServerMethod = "const __call_server_method__ = (methodName, kwargs) => Millennium.callServerMethod(pluginName, methodName, kwargs)";
+const WrappedCallable = "const __wrapped_callable__ = (route) => MILLENNIUM_API.callable(__call_server_method__, route)";
+/**
+ * @description Append the active plugin to the global plugin
+ * list and notify that the frontend Loaded.
+ */
+function ExecutePluginModule() {
+    // Assign the plugin on plugin list. 
+    Object.assign(window.PLUGIN_LIST[pluginName], millennium_main);
+    // Run the rolled up plugins default exported function 
+    millennium_main["default"]();
+    MILLENNIUM_BACKEND_IPC.postMessage(1, { pluginName: pluginName });
+}
+/**
+ * @description Append the active plugin to the global plugin
+ * list and notify that the frontend Loaded.
+ */
+function ExecuteWebkitModule() {
+    // Assign the plugin on plugin list. 
+    Object.assign(window.PLUGIN_LIST[pluginName], millennium_main);
+    // Run the rolled up plugins default exported function 
+    millennium_main["default"]();
+}
+/**
+ * @description Simple bootstrap function that initializes PLUGIN_LIST
+ * for current plugin given that is doesnt exist.
+ */
+function InitializePlugins() {
+    /**
+     * This function is called n times depending on n plugin count,
+     * Create the plugin list if it wasn't already created
+     */
+    !window.PLUGIN_LIST && (window.PLUGIN_LIST = {});
+    // initialize a container for the plugin
+    if (!window.PLUGIN_LIST[pluginName]) {
+        window.PLUGIN_LIST[pluginName] = {};
+    }
+}
+function InsertMillennium(props) {
+    const ContructFunctions = (parts) => { return parts.join('\n'); };
+    const generateBundle = (_, bundle) => {
+        for (const fileName in bundle) {
+            if (bundle[fileName].type != 'chunk') {
+                continue;
+            }
+            Logger.Info("Injecting Millennium shims into module... " + chalk.green.bold("okay"));
+            bundle[fileName].code = ContructFunctions([
+                `const pluginName = "${props.strPluginInternalName}";`,
+                // insert the bootstrap function and call it
+                InitializePlugins.toString(), InitializePlugins.name + "()",
+                WrappedCallServerMethod,
+                WrappedCallable,
+                bundle[fileName].code,
+                ExecutePluginModule.toString(), ExecutePluginModule.name + "()"
+            ]);
+        }
+    };
+    return {
+        name: 'add-plugin-main', generateBundle
+    };
+}
+function InsertWebkitMillennium(props) {
+    const ContructFunctions = (parts) => { return parts.join('\n'); };
+    const generateBundle = (_, bundle) => {
+        for (const fileName in bundle) {
+            if (bundle[fileName].type != 'chunk') {
+                continue;
+            }
+            Logger.Info("Injecting Millennium shims into webkit module... " + chalk.green.bold("okay"));
+            bundle[fileName].code = ContructFunctions([
+                // define the plugin name at the top of the bundle, so it can be used in wrapped functions
+                `const pluginName = "${props.strPluginInternalName}";`,
+                // insert the bootstrap function and call it
+                InitializePlugins.toString(), InitializePlugins.name + "()",
+                // TODO
+                WrappedCallServerMethod, WrappedCallable, bundle[fileName].code,
+                ExecuteWebkitModule.toString(), ExecuteWebkitModule.name + "()"
+            ]);
+        }
+    };
+    return {
+        name: 'add-plugin-main', generateBundle
+    };
+}
+function GetPluginComponents(props) {
+    const pluginList = [
+        /**
+         * @brief resolve millennium, edit the exported bundle to work with millennium
+         */
+        InsertMillennium(props),
+        typescript(), nodeResolve(), commonjs(), json(),
+        replace({
+            preventAssignment: true,
+            'process.env.NODE_ENV': JSON.stringify('production'),
+            // replace callServerMethod with wrapped replacement function. 
+            'Millennium.callServerMethod': `__call_server_method__`,
+            'client.callable': `__wrapped_callable__`,
+            delimiters: ['', ''],
+            'client.pluginSelf': 'window.PLUGIN_LIST[pluginName]',
+            'client.Millennium.exposeObj(': 'client.Millennium.exposeObj(exports, '
+        }),
+    ];
+    if (props.bTersePlugin) {
+        pluginList.push(terser());
+    }
+    return pluginList;
+}
+function GetWebkitPluginComponents(props) {
+    const pluginList = [
+        InsertWebkitMillennium(props), typescript(), nodeResolve(), commonjs(), json(),
+        replace({
+            preventAssignment: true,
+            // replace callServerMethod with wrapped replacement function. 
+            'Millennium.callServerMethod': `__call_server_method__`,
+            'client.callable': `__wrapped_callable__`,
+            delimiters: ['', ''],
+        }),
+    ];
+    if (props.bTersePlugin) {
+        pluginList.push(terser());
+    }
+    return pluginList;
+}
+const GetFrontEndDirectory = () => {
+    const pluginJsonPath = './plugin.json';
+    try {
+        const pluginJson = JSON.parse(fs.readFileSync(pluginJsonPath, 'utf8'));
+        const frontendDirectory = pluginJson?.frontend;
+        return frontendDirectory ? frontendDirectory : "frontend";
+    }
+    catch (error) {
+        return "frontend";
+    }
+};
+const TranspilerPluginComponent = async (props) => {
+    const frontendRollupConfig = {
+        input: `./${GetFrontEndDirectory()}/index.tsx`,
+        plugins: GetPluginComponents(props),
+        context: 'window',
+        external: ['react', 'react-dom', '@steambrew/client'],
+        output: {
+            name: "millennium_main",
+            file: ".millennium/Dist/index.js",
+            globals: {
+                react: "window.SP_REACT",
+                "react-dom": "window.SP_REACTDOM",
+                "@steambrew/client": "window.MILLENNIUM_API"
+            },
+            exports: 'named',
+            format: 'iife'
+        }
+    };
+    const webkitRollupConfig = {
+        input: `./webkit/index.ts`,
+        plugins: GetWebkitPluginComponents(props),
+        context: 'window',
+        external: ['@steambrew/client'],
+        output: {
+            name: "millennium_main",
+            file: ".millennium/Dist/webkit.js",
+            exports: 'named',
+            format: 'iife',
+            globals: {
+                "@steambrew/client": "window.MILLENNIUM_API"
+            },
+        }
+    };
+    Logger.Info("Starting build; this may take a few moments...");
+    // Load the Rollup configuration file
+    try {
+        const bundle = await rollup(frontendRollupConfig);
+        const outputOptions = frontendRollupConfig.output;
+        await bundle.write(outputOptions);
+        // check if the webkit file exists
+        if (fs.existsSync(`./webkit/index.ts`)) {
+            Logger.Info("Compiling webkit module...");
+            const bundle1 = await rollup(webkitRollupConfig);
+            const outputOptions1 = webkitRollupConfig.output;
+            await bundle1.write(outputOptions1);
+        }
+        Logger.Info('Build succeeded!', Number((performance.now() - global.PerfStartTime).toFixed(3)), 'ms elapsed.');
+    }
+    catch (exception) {
+        Logger.Error('Build failed!', exception);
+    }
+};
+
+/**
+ * this component serves as:
+ * - typescript transpiler
+ * - rollup configurator
+ */
+const CheckModuleUpdates = async () => {
+    return await CheckForUpdates();
+};
+const StartCompilerModule = () => {
+    const parameters = ValidateParameters(process.argv.slice(2));
+    const bTersePlugin = parameters.type == BuildType.ProdBuild;
+    Logger.Tree("Transpiler config: ", {
+        target: parameters.targetPlugin,
+        build: BuildType[parameters.type],
+        minify: bTersePlugin
+    });
+    ValidatePlugin(parameters.targetPlugin).then((json) => {
+        const props = {
+            bTersePlugin: bTersePlugin,
+            strPluginInternalName: json?.name
+        };
+        TranspilerPluginComponent(props);
+    })
+        /**
+         * plugin is invalid, we close the proccess as it has already been handled
+         */
+        .catch(() => {
+        process.exit();
+    });
+};
+const Initialize = () => {
+    global.PerfStartTime = performance$1.now();
+    CheckModuleUpdates().then((needsUpdate) => {
+        needsUpdate ? process.exit() : StartCompilerModule();
+    });
+};
+Initialize();

package/index.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * this component serves as:
+ * - typescript transpiler
+ * - rollup configurator
+ */
+import { BuildType, ValidateParameters } from "./Parameters"
+import { CheckForUpdates } from "./VersionMon"
+import { ValidatePlugin } from './Linter'
+import { TranspilerPluginComponent, TranspilerProps } from './Compiler'
+import { performance } from 'perf_hooks';
+import { Logger } from './Logger'
+
+declare global {
+    var PerfStartTime: number;
+}
+
+const CheckModuleUpdates = async () => {
+    return await CheckForUpdates()
+}
+
+const StartCompilerModule = () => {
+
+    const parameters   = ValidateParameters( process.argv.slice(2) );
+    const bTersePlugin = parameters.type == BuildType.ProdBuild
+
+    Logger.Tree("Transpiler config: ", {
+        target: parameters.targetPlugin,
+        build: BuildType[parameters.type],
+        minify: bTersePlugin
+    })
+
+    ValidatePlugin(parameters.targetPlugin).then((json: any) => {
+
+        const props: TranspilerProps = {
+            bTersePlugin: bTersePlugin,
+            strPluginInternalName: json?.name
+        }
+
+        TranspilerPluginComponent(props)
+    })
+
+    /**
+     * plugin is invalid, we close the proccess as it has already been handled
+     */
+    .catch(() => {
+        process.exit()
+    }) 
+}
+
+const Initialize = () => {
+    global.PerfStartTime = performance.now();
+
+    CheckModuleUpdates().then((needsUpdate: boolean) => {
+        needsUpdate ? process.exit() : StartCompilerModule()
+    })
+}
+
+Initialize();

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@steambrew/ttc",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "bin": {
+    "millennium-ttc": "dist/index.js"
+  },
+  "scripts": {
+    "build": "rollup -c"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "A tiny typescript compiler for Millennium plugins.",
+  "dependencies": {
+    "@rollup/plugin-commonjs": "^28.0.1",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-replace": "^6.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.1",
+    "chalk": "^5.3.0",
+    "fs": "^0.0.1-security",
+    "rollup": "^4.27.4",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.1"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,28 @@
+import commonjs from '@rollup/plugin-commonjs';
+import typescript from '@rollup/plugin-typescript';
+import json from '@rollup/plugin-json';
+
+export default {
+  input: 'index.ts',
+  context: 'window',
+  output: {
+    file: 'dist/index.js'
+  },
+  plugins: [commonjs(), typescript(), json()],
+  external: [
+    "chalk", 
+    "path", 
+    "url", 
+    "fs/promises", 
+    "fs", 
+    "rollup", 
+    "@rollup/plugin-json", 
+    "@rollup/plugin-commonjs", 
+    "@rollup/plugin-replace", 
+    "@rollup/plugin-typescript", 
+    "@rollup/plugin-node-resolve",
+    "rollup-plugin-import-css",
+    "@rollup/plugin-terser",
+    "perf_hooks",
+  ]
+};

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+      "outDir": "dist",
+      "module": "ESNext",
+      "target": "ES2020",
+      "jsx": "react",
+      "jsxFactory": "window.SP_REACT.createElement",
+      "declaration": false,
+      "moduleResolution": "node",
+      "noUnusedLocals": true,
+      "noUnusedParameters": true,
+      "esModuleInterop": true,
+      "noImplicitReturns": true,
+      "noImplicitThis": true,
+      "noImplicitAny": true,
+      "strict": true,
+      "ignoreDeprecations": "5.0",
+      "allowSyntheticDefaultImports": true,
+      "skipLibCheck": true
+    },
+    "include": ["./"],
+    "exclude": ["node_modules"]
+}
+