initial commit

fluxer_app/scripts/build/utils/assets.ts

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {ASSETS_DIR, DIST_DIR, PKGS_DIR, PUBLIC_DIR} from '../config';
+
+export async function copyPublicAssets(): Promise<void> {
+	if (!fs.existsSync(PUBLIC_DIR)) {
+		return;
+	}
+
+	const files = await fs.promises.readdir(PUBLIC_DIR, {recursive: true});
+	for (const file of files) {
+		const srcPath = path.join(PUBLIC_DIR, file.toString());
+		const destPath = path.join(DIST_DIR, file.toString());
+
+		const stat = await fs.promises.stat(srcPath);
+		if (stat.isFile()) {
+			await fs.promises.mkdir(path.dirname(destPath), {recursive: true});
+			await fs.promises.copyFile(srcPath, destPath);
+		}
+	}
+}
+
+export async function copyWasmFiles(): Promise<void> {
+	const libfluxcoreDir = path.join(PKGS_DIR, 'libfluxcore');
+	const wasmFile = path.join(libfluxcoreDir, 'libfluxcore_bg.wasm');
+
+	if (fs.existsSync(wasmFile)) {
+		await fs.promises.copyFile(wasmFile, path.join(ASSETS_DIR, 'libfluxcore_bg.wasm'));
+	}
+}
+
+export async function removeUnusedCssAssets(assetsDir: string, keepFiles: Array<string>): Promise<void> {
+	if (!fs.existsSync(assetsDir)) {
+		return;
+	}
+
+	const keepNames = new Set<string>();
+	for (const file of keepFiles) {
+		const base = path.basename(file);
+		keepNames.add(base);
+		if (base.endsWith('.css')) {
+			keepNames.add(`${base}.map`);
+		}
+	}
+
+	const entries = await fs.promises.readdir(assetsDir);
+	for (const entry of entries) {
+		if (!entry.endsWith('.css') && !entry.endsWith('.css.map')) {
+			continue;
+		}
+		if (keepNames.has(entry)) {
+			continue;
+		}
+		await fs.promises.rm(path.join(assetsDir, entry), {force: true});
+	}
+}

fluxer_app/scripts/build/utils/css-dts.ts

@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import postcss from 'postcss';
+import postcssModules from 'postcss-modules';
+import {PKGS_DIR, SRC_DIR} from '../config';
+
+const RESERVED_KEYWORDS = new Set([
+	'break',
+	'case',
+	'catch',
+	'continue',
+	'debugger',
+	'default',
+	'delete',
+	'do',
+	'else',
+	'export',
+	'extends',
+	'finally',
+	'for',
+	'function',
+	'if',
+	'import',
+	'in',
+	'instanceof',
+	'new',
+	'return',
+	'super',
+	'switch',
+	'this',
+	'throw',
+	'try',
+	'typeof',
+	'var',
+	'void',
+	'while',
+	'with',
+	'yield',
+	'enum',
+	'implements',
+	'interface',
+	'let',
+	'package',
+	'private',
+	'protected',
+	'public',
+	'static',
+	'await',
+	'class',
+	'const',
+]);
+
+function isValidIdentifier(name: string): boolean {
+	if (RESERVED_KEYWORDS.has(name)) {
+		return false;
+	}
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+
+function generateDtsContent(classNames: Record<string, string>): string {
+	const validClassNames = Object.keys(classNames).filter(isValidIdentifier);
+	const typeMembers = validClassNames.map((name) => `\treadonly ${name}: string;`).join('\n');
+	const defaultExportType =
+		validClassNames.length > 0 ? `{\n${typeMembers}\n\treadonly [key: string]: string;\n}` : 'Record<string, string>';
+
+	return `declare const styles: ${defaultExportType};\nexport default styles;\n`;
+}
+
+async function findCssModuleFiles(dir: string): Promise<Array<string>> {
+	const files: Array<string> = [];
+
+	async function walk(currentDir: string): Promise<void> {
+		const entries = await fs.promises.readdir(currentDir, {withFileTypes: true});
+
+		for (const entry of entries) {
+			const fullPath = path.join(currentDir, entry.name);
+
+			if (entry.isDirectory()) {
+				if (entry.name !== 'node_modules' && entry.name !== 'dist' && entry.name !== '.git') {
+					await walk(fullPath);
+				}
+			} else if (entry.name.endsWith('.module.css')) {
+				files.push(fullPath);
+			}
+		}
+	}
+
+	await walk(dir);
+	return files;
+}
+
+async function generateDtsForFile(cssPath: string): Promise<void> {
+	const cssContent = await fs.promises.readFile(cssPath, 'utf-8');
+	let exportedClassNames: Record<string, string> = {};
+
+	await postcss([
+		postcssModules({
+			localsConvention: 'camelCaseOnly',
+			generateScopedName: '[name]__[local]___[hash:base64:5]',
+			getJSON(_cssFileName: string, json: Record<string, string>) {
+				exportedClassNames = json;
+			},
+		}),
+	]).process(cssContent, {from: cssPath});
+
+	const dtsPath = `${cssPath}.d.ts`;
+	const dtsContent = generateDtsContent(exportedClassNames);
+	await fs.promises.writeFile(dtsPath, dtsContent);
+}
+
+export async function generateCssDtsForFile(cssPath: string): Promise<void> {
+	if (!cssPath.endsWith('.module.css')) {
+		return;
+	}
+	await generateDtsForFile(cssPath);
+}
+
+export async function generateAllCssDts(): Promise<void> {
+	const srcFiles = await findCssModuleFiles(SRC_DIR);
+	const pkgsFiles = await findCssModuleFiles(PKGS_DIR);
+	const allFiles = [...srcFiles, ...pkgsFiles];
+
+	console.log(`Generating .d.ts files for ${allFiles.length} CSS modules...`);
+
+	await Promise.all(allFiles.map(generateDtsForFile));
+
+	console.log(`Generated ${allFiles.length} CSS module type definitions.`);
+}

fluxer_app/scripts/build/utils/html.ts

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {ASSETS_DIR, CDN_ENDPOINT, ROOT_DIR} from '../config';
+
+interface BuildOutput {
+	mainScript: string | null;
+	cssFiles: Array<string>;
+	jsFiles: Array<string>;
+	cssBundleFile: string | null;
+	vendorScripts: Array<string>;
+}
+
+interface GenerateHtmlOptions {
+	buildOutput: BuildOutput;
+	production: boolean;
+}
+
+async function findCssModulesFile(): Promise<string | null> {
+	if (!fs.existsSync(ASSETS_DIR)) {
+		return null;
+	}
+	const files = await fs.promises.readdir(ASSETS_DIR);
+	const stylesFiles = files.filter((name) => name.startsWith('styles.') && name.endsWith('.css'));
+	if (stylesFiles.length === 0) {
+		return null;
+	}
+
+	let latestFile: string | null = null;
+	let latestMtime = 0;
+
+	for (const fileName of stylesFiles) {
+		const filePath = path.join(ASSETS_DIR, fileName);
+		const stats = await fs.promises.stat(filePath);
+		if (latestFile === null || stats.mtimeMs > latestMtime) {
+			latestFile = fileName;
+			latestMtime = stats.mtimeMs;
+		}
+	}
+
+	return latestFile ? `assets/${latestFile}` : null;
+}
+
+export async function generateHtml(options: GenerateHtmlOptions): Promise<string> {
+	const {buildOutput, production} = options;
+
+	const indexHtmlPath = path.join(ROOT_DIR, 'index.html');
+	let html = await fs.promises.readFile(indexHtmlPath, 'utf-8');
+
+	const baseUrl = production ? `${CDN_ENDPOINT}/` : '/';
+
+	const cssModulesFile = buildOutput.cssBundleFile ?? (await findCssModulesFile());
+	const cssFiles = cssModulesFile ? [cssModulesFile] : buildOutput.cssFiles;
+
+	const cssLinks = cssFiles.map((file) => `<link rel="stylesheet" href="${baseUrl}${file}">`).join('\n');
+
+	const crossOriginAttr = production && baseUrl.startsWith('http') ? ' crossorigin="anonymous"' : '';
+
+	const jsScripts = buildOutput.mainScript
+		? `<script type="module" src="${baseUrl}${buildOutput.mainScript}"${crossOriginAttr}></script>`
+		: '';
+
+	const buildScriptPreload = (file: string): string =>
+		`<link rel="preload" as="script" href="${baseUrl}${file}"${crossOriginAttr}>`;
+
+	const preloadScripts = [
+		...(buildOutput.vendorScripts ?? []).map(buildScriptPreload),
+		...buildOutput.jsFiles.filter((file) => !file.includes('messages')).map(buildScriptPreload),
+	].join('\n');
+
+	html = html.replace(/<script type="module" src="\/src\/index\.tsx"><\/script>/, jsScripts);
+	const headInsert = [cssLinks, preloadScripts].filter(Boolean).join('\n');
+	html = html.replace('</head>', `${headInsert}\n</head>`);
+
+	return html;
+}

fluxer_app/scripts/build/utils/index.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+export {copyPublicAssets, copyWasmFiles, removeUnusedCssAssets} from './assets';
+export {generateAllCssDts, generateCssDtsForFile} from './css-dts';
+export {generateHtml} from './html';
+export {tryResolveWithExtensions} from './resolve';
+export {buildServiceWorker} from './service-worker';
+export {cleanEmptySourceMaps} from './sourcemaps';

fluxer_app/scripts/build/utils/resolve.ts

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {RESOLVE_EXTENSIONS} from '../config';
+
+export function tryResolveWithExtensions(basePath: string): string | null {
+	if (fs.existsSync(basePath)) {
+		const stat = fs.statSync(basePath);
+		if (stat.isFile()) {
+			return basePath;
+		}
+		if (stat.isDirectory()) {
+			for (const ext of RESOLVE_EXTENSIONS) {
+				const indexPath = path.join(basePath, `index${ext}`);
+				if (fs.existsSync(indexPath)) {
+					return indexPath;
+				}
+			}
+		}
+	}
+
+	for (const ext of RESOLVE_EXTENSIONS) {
+		const withExt = `${basePath}${ext}`;
+		if (fs.existsSync(withExt)) {
+			return withExt;
+		}
+	}
+
+	return null;
+}

fluxer_app/scripts/build/utils/service-worker.ts

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as path from 'node:path';
+import * as esbuild from 'esbuild';
+import {DIST_DIR, SRC_DIR} from '../config';
+
+export async function buildServiceWorker(production: boolean): Promise<void> {
+	await esbuild.build({
+		entryPoints: [path.join(SRC_DIR, 'sw', 'worker.ts')],
+		bundle: true,
+		format: 'iife',
+		outfile: path.join(DIST_DIR, 'sw.js'),
+		minify: production,
+		sourcemap: true,
+		target: 'esnext',
+		define: {
+			__WB_MANIFEST: '[]',
+		},
+	});
+}

fluxer_app/scripts/build/utils/sourcemaps.ts

@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2026 Fluxer Contributors
+ *
+ * This file is part of Fluxer.
+ *
+ * Fluxer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fluxer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Fluxer. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+async function fileExists(filePath: string): Promise<boolean> {
+	try {
+		await fs.promises.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function traverseDir(dir: string, callback: (filePath: string) => Promise<void>): Promise<void> {
+	const entries = await fs.promises.readdir(dir, {withFileTypes: true});
+	await Promise.all(
+		entries.map(async (entry) => {
+			const entryPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				await traverseDir(entryPath, callback);
+				return;
+			}
+			await callback(entryPath);
+		}),
+	);
+}
+
+export async function cleanEmptySourceMaps(dir: string): Promise<void> {
+	if (!(await fileExists(dir))) {
+		return;
+	}
+
+	await traverseDir(dir, async (filePath) => {
+		if (!filePath.endsWith('.js.map')) {
+			return;
+		}
+
+		let parsed: unknown;
+		try {
+			const raw = await fs.promises.readFile(filePath, 'utf-8');
+			parsed = JSON.parse(raw);
+		} catch {
+			return;
+		}
+
+		if (typeof parsed !== 'object' || parsed === null) {
+			return;
+		}
+
+		const sources = (parsed as {sources?: Array<unknown>}).sources ?? [];
+		if (Array.isArray(sources) && sources.length > 0) {
+			return;
+		}
+
+		await fs.promises.rm(filePath, {force: true});
+
+		const jsPath = filePath.slice(0, -4);
+		if (!(await fileExists(jsPath))) {
+			return;
+		}
+
+		const jsContent = await fs.promises.readFile(jsPath, 'utf-8');
+		const cleaned = jsContent.replace(/(?:\r?\n)?\/\/# sourceMappingURL=.*$/, '');
+		if (cleaned !== jsContent) {
+			await fs.promises.writeFile(jsPath, cleaned);
+		}
+	});
+}