@steambrew/ttc 1.4.2 → 2.4.3

package/Compiler.ts

@@ -3,9 +3,14 @@ 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 resolve from '@rollup/plugin-node-resolve';
+import resolve, { nodeResolve } from '@rollup/plugin-node-resolve';
 import terser from '@rollup/plugin-terser';
 import babel from '@rollup/plugin-babel';
+import nodePolyfills from 'rollup-plugin-polyfill-node';
+import url from '@rollup/plugin-url';
+
+import scss from 'rollup-plugin-scss';
+import * as sass from 'sass';
 
 import chalk from 'chalk';
 import { Logger } from './Logger';
@@ -14,11 +19,12 @@ import fs from 'fs';
 import injectProcessEnv from 'rollup-plugin-inject-process-env';
 import dotenv from 'dotenv';
 import { ExecutePluginModule, InitializePlugins } from './PluginSetup';
+import constSysfsExpr from './StaticEmbed';
 
 const envConfig = dotenv.config().parsed || {};
 
 if (envConfig) {
-	Logger.Info('Injecting environment variables...');
+	Logger.Info('envVars', 'Processing ' + Object.keys(envConfig).length + ' environment variables... ' + chalk.green.bold('okay'));
 }
 
 const envVars = Object.keys(envConfig).reduce((acc: any, key) => {
@@ -64,7 +70,7 @@ function InsertMillennium(type: ComponentType, props: TranspilerProps) {
 				continue;
 			}
 
-			Logger.Info('Injecting Millennium shims into ' + ComponentType[type] + ' module... ' + chalk.green.bold('okay'));
+			Logger.Info('millenniumAPI', 'Bundling into ' + ComponentType[type] + ' module... ' + chalk.green.bold('okay'));
 
 			bundle[fileName].code = ConstructFunctions([
 				`const MILLENNIUM_IS_CLIENT_MODULE = ${type === ComponentType.Plugin ? 'true' : 'false'};`,
@@ -83,21 +89,71 @@ function InsertMillennium(type: ComponentType, props: TranspilerProps) {
 	return { name: String(), generateBundle };
 }
 
-function GetPluginComponents(props: TranspilerProps) {
-	let tsConfigPath = `./${GetFrontEndDirectory()}/tsconfig.json`;
+async function GetCustomUserPlugins() {
+	const ttcConfigPath = new URL(`file://${process.cwd().replace(/\\/g, '/')}/ttc.config.mjs`).href;
+
+	if (fs.existsSync('./ttc.config.mjs')) {
+		const { MillenniumCompilerPlugins } = await import(ttcConfigPath);
+
+		Logger.Info('millenniumAPI', 'Loading custom plugins from ttc.config.mjs... ' + chalk.green.bold('okay'));
+		return MillenniumCompilerPlugins;
+	}
+
+	return [];
+}
+
+async function MergePluginList(plugins: any[]) {
+	const customPlugins = await GetCustomUserPlugins();
+
+	// Filter out custom plugins that have the same name as input plugins
+	const filteredCustomPlugins = customPlugins.filter((customPlugin: any) => !plugins.some((plugin: any) => plugin.name === customPlugin.name));
+
+	// Merge input plugins with the filtered custom plugins
+	return [...plugins, ...filteredCustomPlugins];
+}
+
+async function GetPluginComponents(props: TranspilerProps) {
+	let tsConfigPath = '';
+	const frontendDir = GetFrontEndDirectory();
+
+	if (frontendDir === '.' || frontendDir === './') {
+		tsConfigPath = './tsconfig.json';
+	} else {
+		tsConfigPath = `./${frontendDir}/tsconfig.json`;
+	}
 
 	if (!fs.existsSync(tsConfigPath)) {
 		tsConfigPath = './tsconfig.json';
 	}
 
-	const pluginList = [
+	Logger.Info('millenniumAPI', 'Loading tsconfig from ' + chalk.cyan.bold(tsConfigPath) + '... ' + chalk.green.bold('okay'));
+
+	let pluginList = [
+		url({
+			include: ['**/*.gif', '**/*.webm', '**/*.svg'], // Add all non-JS assets you use
+			limit: 0, // Set to 0 to always copy the file instead of inlining as base64
+			fileName: '[hash][extname]', // Optional: custom output naming
+		}),
 		InsertMillennium(ComponentType.Plugin, props),
+		commonjs(),
+		nodePolyfills(),
+		nodeResolve({
+			browser: true,
+		}),
 		typescript({
+			include: ['**/*.ts', '**/*.tsx', 'src/**/*.ts', 'src/**/*.tsx'],
 			tsconfig: tsConfigPath,
 		}),
+		scss({
+			output: false,
+			outputStyle: 'compressed',
+			sourceMap: false,
+			watch: 'src/styles',
+			sass: sass,
+		}),
 		resolve(),
-		commonjs(),
 		json(),
+		constSysfsExpr(),
 		injectProcessEnv(envVars),
 		replace({
 			delimiters: ['', ''],
@@ -117,15 +173,22 @@ function GetPluginComponents(props: TranspilerProps) {
 	return pluginList;
 }
 
-function GetWebkitPluginComponents(props: TranspilerProps) {
-	const pluginList = [
+async function GetWebkitPluginComponents(props: TranspilerProps) {
+	let pluginList = [
 		InsertMillennium(ComponentType.Webkit, props),
 		typescript({
 			tsconfig: './webkit/tsconfig.json',
 		}),
+		url({
+			include: ['**/*.mp4', '**/*.webm', '**/*.ogg'],
+			limit: 0, // do NOT inline
+			fileName: '[name][extname]',
+			destDir: 'dist/assets', // or adjust as needed
+		}),
 		resolve(),
 		commonjs(),
 		json(),
+		constSysfsExpr(),
 		injectProcessEnv(envVars),
 		replace({
 			delimiters: ['', ''],
@@ -140,6 +203,8 @@ function GetWebkitPluginComponents(props: TranspilerProps) {
 		}),
 	];
 
+	pluginList = await MergePluginList(pluginList);
+
 	props.bTersePlugin && pluginList.push(terser());
 	return pluginList;
 }
@@ -156,7 +221,7 @@ const GetFrontEndDirectory = () => {
 export const TranspilerPluginComponent = async (props: TranspilerProps) => {
 	const frontendRollupConfig: RollupOptions = {
 		input: `./${GetFrontEndDirectory()}/index.tsx`,
-		plugins: GetPluginComponents(props),
+		plugins: await GetPluginComponents(props),
 		context: 'window',
 		external: (id) => {
 			if (id === '@steambrew/webkit') {
@@ -182,17 +247,13 @@ export const TranspilerPluginComponent = async (props: TranspilerProps) => {
 		},
 	};
 
-	Logger.Info('Starting build; this may take a few moments...');
-
 	try {
 		await (await rollup(frontendRollupConfig)).write(frontendRollupConfig.output as OutputOptions);
 
 		if (fs.existsSync(`./webkit/index.tsx`)) {
-			Logger.Info('Compiling webkit module...');
-
 			const webkitRollupConfig: RollupOptions = {
 				input: `./webkit/index.tsx`,
-				plugins: GetWebkitPluginComponents(props),
+				plugins: await GetWebkitPluginComponents(props),
 				context: 'window',
 				external: (id) => {
 					if (id === '@steambrew/client') {
@@ -218,9 +279,9 @@ export const TranspilerPluginComponent = async (props: TranspilerProps) => {
 			await (await rollup(webkitRollupConfig)).write(webkitRollupConfig.output as OutputOptions);
 		}
 
-		Logger.Info('Build succeeded!', Number((performance.now() - global.PerfStartTime).toFixed(3)), 'ms elapsed.');
+		Logger.Info('build', 'Succeeded passing all tests in', Number((performance.now() - global.PerfStartTime).toFixed(3)), 'ms elapsed.');
 	} catch (exception) {
-		Logger.Error('Build failed!', exception);
+		Logger.Error('error', 'Build failed!', exception);
 		process.exit(1);
 	}
 };

package/Logger.ts

@@ -1,49 +1,46 @@
-import chalk from 'chalk'
+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.error(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 }
+	Info: (name: string, ...LogMessage: any) => {
+		console.log(chalk.magenta.bold(name), ...LogMessage);
+	},
+
+	Warn: (...LogMessage: any) => {
+		console.log(chalk.yellow.bold('**'), ...LogMessage);
+	},
+
+	Error: (...LogMessage: any) => {
+		console.error(chalk.red.bold('!!'), ...LogMessage);
+	},
+
+	Tree: (name: string, strTitle: string, LogObject: any) => {
+		const fixedPadding = 15; // <-- always pad keys to 15 characters
+
+		console.log(chalk.greenBright.bold(name).padEnd(fixedPadding), strTitle);
+
+		const isLocalPath = (strTestPath: string): boolean => {
+			const filePathRegex = /^(\/|\.\/|\.\.\/|\w:\/)?([\w-.]+\/)*[\w-.]+\.\w+$/;
+			return filePathRegex.test(strTestPath);
+		};
+
+		for (const [key, value] of Object.entries(LogObject)) {
+			let color = chalk.white;
+
+			switch (typeof value) {
+				case 'string':
+					color = isLocalPath(value) ? chalk.blueBright : chalk.white;
+					break;
+				case 'boolean':
+					color = chalk.green;
+					break;
+				case 'number':
+					color = chalk.yellow;
+					break;
+			}
+
+			console.log(chalk.greenBright.bold(`${key}:        `).padEnd(fixedPadding), color(String(value)));
+		}
+	},
+};
+
+export { Logger };

package/PluginSetup.ts

@@ -141,11 +141,6 @@ function InitializePlugins() {
 	MillenniumStore.ignoreProxyFlag = false;
 
 	function DelegateToBackend(pluginName: string, name: string, value: any) {
-		console.log(`Delegating ${name} to backend`, value);
-		// print stack trace
-		const stack = new Error().stack?.split('\n').slice(2).join('\n');
-		console.log(stack);
-
 		return MILLENNIUM_BACKEND_IPC.postMessage(IPCType.CallServerMethod, {
 			pluginName,
 			methodName: '__builtins__.__update_settings_value__',

package/StaticEmbed.ts

@@ -0,0 +1,278 @@
+import { Plugin, SourceDescription, TransformPluginContext } from 'rollup';
+import fs from 'fs';
+import path from 'path';
+import { createFilter } from '@rollup/pluginutils';
+import MagicString from 'magic-string';
+import * as parser from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as glob from 'glob';
+import chalk from 'chalk';
+
+interface EmbedPluginOptions {
+	include?: string | RegExp | (string | RegExp)[];
+	exclude?: string | RegExp | (string | RegExp)[];
+	encoding?: BufferEncoding;
+}
+
+interface CallOptions {
+	basePath?: string;
+	include?: string;
+	encoding?: BufferEncoding;
+}
+
+interface FileInfo {
+	content: string;
+	filePath: string;
+	fileName: string;
+}
+
+const Log = (...message: any) => {
+	console.log(chalk.blueBright.bold('constSysfsExpr'), ...message);
+};
+
+export default function constSysfsExpr(options: EmbedPluginOptions = {}): Plugin {
+	const filter = createFilter(options.include, options.exclude);
+	const pluginName = 'millennium-const-sysfs-expr';
+
+	return {
+		name: pluginName,
+
+		transform(this: TransformPluginContext, code: string, id: string): SourceDescription | null {
+			if (!filter(id)) return null;
+			if (!code.includes('constSysfsExpr')) return null;
+
+			const magicString = new MagicString(code);
+			let hasReplaced = false;
+
+			try {
+				const stringVariables = new Map<string, string>();
+
+				const ast = parser.parse(code, {
+					sourceType: 'module',
+					plugins: ['typescript', 'jsx', 'objectRestSpread', 'classProperties', 'optionalChaining', 'nullishCoalescingOperator'],
+				});
+
+				traverse(ast, {
+					VariableDeclarator(path) {
+						const init = path.node.init;
+						const id = path.node.id;
+						if (id.type === 'Identifier' && init && init.type === 'StringLiteral') {
+							stringVariables.set(id.name, init.value);
+						}
+					},
+				});
+
+				traverse(ast, {
+					CallExpression: (nodePath) => {
+						const node = nodePath.node;
+						if (node.callee.type === 'Identifier' && node.callee.name === 'constSysfsExpr') {
+							if (typeof node.start !== 'number' || typeof node.end !== 'number') {
+								if (node.loc) {
+									this.warn(`Missing start/end offset info for constSysfsExpr call.`, node.loc.start.index);
+								}
+								return;
+							}
+
+							const args = node.arguments;
+							let pathOrPattern: string | null = null;
+							const callOptions: Required<Omit<CallOptions, 'fileName'>> = {
+								basePath: '',
+								include: '**/*',
+								encoding: options.encoding || 'utf8',
+							};
+
+							if (args.length >= 1 && (args[0].type === 'StringLiteral' || args[0].type === 'Identifier')) {
+								const firstArg = args[0];
+								if (firstArg.type === 'StringLiteral') {
+									pathOrPattern = firstArg.value;
+								} else if (firstArg.type === 'Identifier') {
+									const varName = firstArg.name;
+									if (stringVariables.has(varName)) {
+										pathOrPattern = stringVariables.get(varName) || null;
+									} else {
+										this.warn(
+											`Unable to resolve variable "${varName}" for constSysfsExpr path/pattern. Only simple string literal assignments are supported.`,
+											firstArg.loc?.start.index,
+										);
+										return;
+									}
+								}
+
+								if (args.length > 1 && args[1].type === 'ObjectExpression') {
+									const optionsObj = args[1];
+									for (const prop of optionsObj.properties) {
+										if (prop.type !== 'ObjectProperty') continue;
+										let keyName: string | undefined;
+										if (prop.key.type === 'Identifier') keyName = prop.key.name;
+										else if (prop.key.type === 'StringLiteral') keyName = prop.key.value;
+										else continue;
+
+										if (!['basePath', 'include', 'encoding'].includes(keyName)) continue;
+
+										const valueNode = prop.value;
+										if (valueNode.type === 'StringLiteral') {
+											const value = (valueNode as any).extra?.rawValue !== undefined ? (valueNode as any).extra.rawValue : valueNode.value;
+											if (keyName === 'basePath') callOptions.basePath = value;
+											else if (keyName === 'include') callOptions.include = value;
+											else if (keyName === 'encoding') callOptions.encoding = value as BufferEncoding;
+										} else {
+											this.warn(
+												`Option "${keyName}" for constSysfsExpr must be a string literal. Found type: ${valueNode.type}`,
+												valueNode.loc?.start.index,
+											);
+										}
+									}
+								}
+							} else if (args.length >= 1 && args[0].type === 'ObjectExpression') {
+								const optionsObj = args[0];
+								for (const prop of optionsObj.properties) {
+									if (prop.type !== 'ObjectProperty') continue;
+									let keyName: string | undefined;
+									if (prop.key.type === 'Identifier') keyName = prop.key.name;
+									else if (prop.key.type === 'StringLiteral') keyName = prop.key.value;
+									else continue;
+
+									// In this case, we need to look for 'basePath' and 'include' within the options object itself
+									if (!['basePath', 'include', 'encoding'].includes(keyName)) continue;
+
+									const valueNode = prop.value;
+									if (valueNode.type === 'StringLiteral') {
+										const value = (valueNode as any).extra?.rawValue !== undefined ? (valueNode as any).extra.rawValue : valueNode.value;
+										if (keyName === 'basePath') callOptions.basePath = value;
+										else if (keyName === 'include') callOptions.include = value;
+										else if (keyName === 'encoding') callOptions.encoding = value as BufferEncoding;
+									} else {
+										this.warn(
+											`Option "${keyName}" for constSysfsExpr must be a string literal. Found type: ${valueNode.type}`,
+											valueNode.loc?.start.index,
+										);
+									}
+								}
+
+								if (callOptions.include !== '**/*') {
+									pathOrPattern = callOptions.include;
+								} else {
+									if (!callOptions.basePath) {
+										this.warn(
+											`constSysfsExpr called with only an options object requires at least 'include' or 'basePath' for a pattern.`,
+											node.loc?.start.index,
+										);
+										return;
+									}
+									this.warn(`constSysfsExpr called with only an options object requires an explicit 'include' pattern.`, node.loc?.start.index);
+									return;
+								}
+							} else {
+								this.warn(`constSysfsExpr requires a path/pattern string/variable or an options object as the first argument.`, node.loc?.start.index);
+								return;
+							}
+
+							if (!pathOrPattern) {
+								this.warn(`Invalid or unresolved path/pattern argument for constSysfsExpr.`, args[0]?.loc?.start.index);
+								return;
+							}
+
+							try {
+								const currentLocString = node.loc?.start ? ` at ${id}:${node.loc.start.line}:${node.loc.start.column}` : ` in ${id}`;
+
+								const searchBasePath = callOptions.basePath
+									? path.isAbsolute(callOptions.basePath)
+										? callOptions.basePath
+										: path.resolve(path.dirname(id), callOptions.basePath)
+									: path.isAbsolute(pathOrPattern) && !/[?*+!@()[\]{}]/.test(pathOrPattern)
+									? path.dirname(pathOrPattern)
+									: path.resolve(path.dirname(id), path.dirname(pathOrPattern));
+
+								let embeddedContent: string;
+								let embeddedCount = 0;
+
+								const isPotentialPattern = /[?*+!@()[\]{}]/.test(pathOrPattern);
+
+								if (
+									!isPotentialPattern &&
+									fs.existsSync(path.resolve(searchBasePath, pathOrPattern)) &&
+									fs.statSync(path.resolve(searchBasePath, pathOrPattern)).isFile()
+								) {
+									const singleFilePath = path.resolve(searchBasePath, pathOrPattern);
+									Log(`Mode: Single file (first argument "${pathOrPattern}" resolved to "${singleFilePath}" relative to "${searchBasePath}")`);
+
+									try {
+										const rawContent: string | Buffer = fs.readFileSync(singleFilePath, callOptions.encoding);
+										const contentString = rawContent.toString();
+										const fileInfo: FileInfo = {
+											content: contentString,
+											filePath: singleFilePath,
+											fileName: path.relative(searchBasePath, singleFilePath),
+										};
+										embeddedContent = JSON.stringify(fileInfo);
+										embeddedCount = 1;
+										Log(`Embedded 1 specific file for call${currentLocString}`);
+									} catch (fileError: unknown) {
+										let message = String(fileError instanceof Error ? fileError.message : fileError ?? 'Unknown file read error');
+										this.error(`Error reading file ${singleFilePath}: ${message}`, node.loc?.start.index);
+										return;
+									}
+								} else {
+									Log(`Mode: Multi-file (first argument "${pathOrPattern}" is pattern or not a single file)`);
+
+									Log(`Searching with pattern "${pathOrPattern}" in directory "${searchBasePath}" (encoding: ${callOptions.encoding})`);
+
+									const matchingFiles = glob.sync(pathOrPattern, {
+										cwd: searchBasePath,
+										nodir: true,
+										absolute: true,
+									});
+
+									const fileInfoArray: FileInfo[] = [];
+									for (const fullPath of matchingFiles) {
+										try {
+											const rawContent: string | Buffer = fs.readFileSync(fullPath, callOptions.encoding);
+											const contentString = rawContent.toString();
+											fileInfoArray.push({
+												content: contentString,
+												filePath: fullPath,
+												fileName: path.relative(searchBasePath, fullPath),
+											});
+										} catch (fileError: unknown) {
+											let message = String(fileError instanceof Error ? fileError.message : fileError ?? 'Unknown file read error');
+											this.warn(`Error reading file ${fullPath}: ${message}`);
+										}
+									}
+									embeddedContent = JSON.stringify(fileInfoArray);
+									embeddedCount = fileInfoArray.length;
+									Log(`Embedded ${embeddedCount} file(s) matching pattern for call${currentLocString}`);
+								}
+
+								// Replace the call expression with the generated content string
+								magicString.overwrite(node.start, node.end, embeddedContent);
+								hasReplaced = true;
+							} catch (error: unknown) {
+								console.error(`Failed to process files for constSysfsExpr call in ${id}:`, error);
+								const message = String(error instanceof Error ? error.message : error ?? 'Unknown error during file processing');
+								this.error(`Could not process files for constSysfsExpr: ${message}`, node.loc?.start.index);
+								return;
+							}
+						}
+					},
+				});
+			} catch (error: unknown) {
+				console.error(`Error parsing or traversing ${id}:`, error);
+				const message = String(error instanceof Error ? error.message : error ?? 'Unknown parsing error');
+				this.error(`Failed to parse ${id}: ${message}`);
+				return null;
+			}
+
+			// If no replacements were made, return null
+			if (!hasReplaced) {
+				return null;
+			}
+
+			// Return the modified code and source map
+			const result: SourceDescription = {
+				code: magicString.toString(),
+				map: magicString.generateMap({ hires: true }),
+			};
+			return result;
+		},
+	};
+}

package/VersionMon.ts

@@ -5,24 +5,27 @@ 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/@steambrew/ttc").then(response => response.json()).then(json => {
+	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'));
 
-            if (json?.["dist-tags"]?.latest != packageJson.version) {
-  
-                Logger.Tree(`@steambrew/ttc@${packageJson.version} requires update to ${json?.["dist-tags"]?.latest}`, {
-                    cmd: `run "npm install @steambrew/ttc@${json?.["dist-tags"]?.latest}" to get latest updates!`
-                })
+		fetch('https://registry.npmjs.org/@steambrew/ttc')
+			.then((response) => response.json())
+			.then((json) => {
+				if (json?.['dist-tags']?.latest != packageJson.version) {
+					Logger.Tree('versionMon', `@steambrew/ttc@${packageJson.version} requires update to ${json?.['dist-tags']?.latest}`, {
+						cmd: `run "npm install @steambrew/ttc@${json?.['dist-tags']?.latest}" to get latest updates!`,
+					});
 
-                resolve(true)
-            }
-            else {
-                Logger.Info(`@steambrew/ttc@${packageJson.version} is up-to-date!`)
-                resolve(false)
-            }
-        })
-    })
-}
+					resolve(true);
+				} else {
+					Logger.Info('versionMon', `@steambrew/ttc@${packageJson.version} is up-to-date!`);
+					resolve(false);
+				}
+			})
+			.catch((exception) => {
+				Logger.Error('Failed to check for updates: ' + exception);
+				resolve(false);
+			});
+	});
+};