boss-css 0.0.1 → 0.0.3

package/dist/compile/index.mjs

@@ -0,0 +1,235 @@
+import { createApi } from "../api/server.mjs";
+import { resolveContentPaths } from "../shared/file.mjs";
+import { resolveBoundaryOutputs } from "../shared/boundaries.mjs";
+import { emitSession, resolveSessionPayload } from "../tasks/session.mjs";
+import { getClassNameProp } from "../shared/framework.mjs";
+import { collectBossClassTokensInSource, collectBossClassTokensInText, rewriteClassNameTokensInSource, rewriteClassNameTokensInText } from "./classname.mjs";
+import { createClassNameMapper } from "./classname-strategy.mjs";
+import { scanPrepared } from "./prepared.mjs";
+import { transformSource } from "./transform.mjs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { transform } from "lightningcss";
+
+//#region src/compile/index.ts
+const supportedExtensions = new Set([
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".mjs",
+	".cjs"
+]);
+async function compileProject(options) {
+	const { config, prod } = options;
+	const compileConfig = {
+		stats: "quick",
+		...config.compile ?? {}
+	};
+	const content = config.content;
+	const baseDir = process.cwd();
+	if (!content) throw new Error("compile: config.content is required");
+	const root = baseDir;
+	const tempOutDir = compileConfig.tempOutDir;
+	if (!prod && !tempOutDir) throw new Error("compile.tempOutDir is required when not running in prod mode.");
+	const outputRoot = prod ? root : path.resolve(root, tempOutDir);
+	const inputPaths = (await resolveContentPaths(content)).sort();
+	const sourceCache = /* @__PURE__ */ new Map();
+	const preparedByFile = /* @__PURE__ */ new Map();
+	const preparedRegistry = /* @__PURE__ */ new Map();
+	const preparedUsages = [];
+	const api = await createApi(config, true);
+	api.baseDir = baseDir;
+	const classNameStrategy = compileConfig.classNameStrategy ?? false;
+	const classNameMapper = classNameStrategy ? createClassNameMapper({
+		strategy: classNameStrategy,
+		prefix: api.selectorPrefix ?? ""
+	}) : null;
+	if (classNameMapper) {
+		const baseContextToClassName = api.contextToClassName;
+		api.contextToClassName = (name, value, contexts, escape = true, _prefix = "") => {
+			const raw = baseContextToClassName(name, value, contexts, false, "");
+			const mapped = classNameMapper.getOrCreate(raw);
+			if (!escape) return mapped;
+			return api.camelCaseToDash(api.escapeClassName(mapped));
+		};
+		const baseClassTokenToSelector = api.classTokenToSelector;
+		api.classTokenToSelector = (token) => baseClassTokenToSelector(classNameMapper.getOrCreate(token));
+	}
+	const sessionStart = await resolveSessionPayload(baseDir, config, "compile", "start");
+	await emitSession(api, sessionStart);
+	await emitSession(api, {
+		...sessionStart,
+		phase: "run"
+	});
+	const statsMode = compileConfig.stats ?? "quick";
+	const start = process.hrtime.bigint();
+	const fileResults = [];
+	for (const inputPath of inputPaths) {
+		if (!(await fs.stat(inputPath).catch(() => null))?.isFile()) continue;
+		const ext = path.extname(inputPath);
+		const source = await fs.readFile(inputPath, "utf8");
+		sourceCache.set(inputPath, source);
+		if (classNameMapper) (supportedExtensions.has(ext) ? collectBossClassTokensInSource(source, {
+			filename: inputPath,
+			api
+		}) : collectBossClassTokensInText(source, { api })).forEach((token) => classNameMapper.getOrCreate(token));
+		if (!supportedExtensions.has(ext)) continue;
+		const scan = scanPrepared(source, {
+			isTs: ext === ".ts" || ext === ".tsx",
+			isJsx: ext === ".jsx" || ext === ".tsx" || ext === ".js" || ext === ".mjs" || ext === ".cjs"
+		});
+		if (scan.definitions.length) {
+			const local = /* @__PURE__ */ new Map();
+			for (const definition of scan.definitions) {
+				local.set(definition.name, {
+					definition: definition.definition,
+					inlineable: definition.inlineable
+				});
+				preparedRegistry.set(definition.name, {
+					definition: definition.definition,
+					inlineable: definition.inlineable
+				});
+			}
+			preparedByFile.set(inputPath, local);
+		}
+		if (scan.usages.length) for (const usage of scan.usages) preparedUsages.push({
+			...usage,
+			file: inputPath
+		});
+	}
+	const preparedGlobal = /* @__PURE__ */ new Map();
+	for (const [name, entry] of preparedRegistry.entries()) if (entry.inlineable) preparedGlobal.set(name, entry.definition);
+	const preparedRuntime = /* @__PURE__ */ new Set();
+	for (const usage of preparedUsages) {
+		if (!compileConfig.spread && usage.hasSpread) {
+			preparedRuntime.add(usage.name);
+			continue;
+		}
+		if (preparedByFile.get(usage.file)?.get(usage.name)) continue;
+		if (preparedRegistry.get(usage.name)?.inlineable) continue;
+		preparedRuntime.add(usage.name);
+	}
+	const processFile = async (inputPath) => {
+		if (!(await fs.stat(inputPath).catch(() => null))?.isFile()) return;
+		const ext = path.extname(inputPath);
+		const relativePath = path.relative(root, inputPath);
+		const outputPath = prod ? inputPath : path.join(outputRoot, relativePath);
+		await fs.mkdir(path.dirname(outputPath), { recursive: true });
+		const source = sourceCache.get(inputPath) ?? await fs.readFile(inputPath, "utf8");
+		if (!supportedExtensions.has(ext)) {
+			const parseContent = rewriteClassNameTokensInText(source, { mapToken: classNameMapper ? () => void 0 : void 0 });
+			await api.trigger("onParse", {
+				content: parseContent,
+				path: inputPath
+			}, (plugin) => plugin.name === "classname");
+			if (!prod) if (classNameMapper) {
+				const rewritten = rewriteClassNameTokensInText(source, { mapToken: (token) => classNameMapper.get(token) });
+				await fs.writeFile(outputPath, rewritten, "utf8");
+			} else await fs.copyFile(inputPath, outputPath);
+			fileResults.push({
+				file: inputPath,
+				processed: false,
+				copied: !prod,
+				needsRuntime: false,
+				needsValueHelper: false,
+				replacedElements: 0
+			});
+			return;
+		}
+		const classNameSource = rewriteClassNameTokensInSource(source, {
+			filename: inputPath,
+			classNameProp: getClassNameProp(api.framework),
+			mapToken: classNameMapper ? () => void 0 : void 0
+		});
+		await api.trigger("onParse", {
+			content: classNameSource,
+			path: inputPath
+		}, (plugin) => plugin.name === "classname");
+		const transformed = await transformSource(source, {
+			api,
+			compile: compileConfig,
+			filename: inputPath,
+			preparedGlobal,
+			preparedLocal: new Map(Array.from(preparedByFile.get(inputPath)?.entries() ?? []).map(([key, value]) => [key, value.definition])),
+			preparedRuntime,
+			classNameMapper
+		});
+		fileResults.push({
+			file: inputPath,
+			processed: true,
+			copied: false,
+			needsRuntime: transformed.needsRuntime,
+			needsValueHelper: transformed.needsValueHelper,
+			replacedElements: transformed.replacedElements
+		});
+		await fs.writeFile(outputPath, transformed.code, "utf8");
+	};
+	if (classNameStrategy === "shortest" || classNameStrategy === "unicode") for (const inputPath of inputPaths) await processFile(inputPath);
+	else await Promise.all(inputPaths.map(processFile));
+	let cssBytes = 0;
+	let cssWritten = false;
+	let stylesheetPath = null;
+	if (!prod && api.css.text.trim()) {
+		const resolvedStylesheetPath = config.stylesheetPath ?? path.join(root, config.configDir ?? ".bo$$", "styles.css");
+		const outputs = (await resolveBoundaryOutputs(api, {
+			rootDir: root,
+			stylesheetPath: resolvedStylesheetPath,
+			boundaries: config.css?.boundaries
+		})).outputs.map((output) => {
+			const relative = path.relative(root, output.path);
+			return {
+				path: path.join(outputRoot, relative),
+				text: output.text
+			};
+		});
+		const globalOutputPath = path.resolve(path.join(outputRoot, path.relative(root, resolvedStylesheetPath)));
+		const outputSizes = /* @__PURE__ */ new Map();
+		for (const output of outputs) {
+			const minified = transform({
+				code: Buffer.from(output.text),
+				filename: output.path,
+				minify: true
+			});
+			await fs.mkdir(path.dirname(output.path), { recursive: true });
+			await fs.writeFile(output.path, minified.code.toString(), "utf8");
+			outputSizes.set(path.resolve(output.path), minified.code.length);
+		}
+		const globalOutput = outputs.find((output) => path.resolve(output.path) === globalOutputPath);
+		cssBytes = globalOutput ? outputSizes.get(path.resolve(globalOutput.path)) ?? 0 : 0;
+		cssWritten = true;
+		stylesheetPath = globalOutput?.path ?? globalOutputPath;
+	}
+	const durationMs = Number(process.hrtime.bigint() - start) / 1e6;
+	const runtimeFiles = fileResults.filter((result$1) => result$1.needsRuntime).map((result$1) => result$1.file);
+	const valueHelperFiles = fileResults.filter((result$1) => result$1.needsValueHelper).map((result$1) => result$1.file);
+	const filesProcessed = fileResults.filter((result$1) => result$1.processed).length;
+	const filesCopied = fileResults.filter((result$1) => result$1.copied).length;
+	const filesTotal = fileResults.length;
+	const filesSkipped = filesTotal - filesProcessed - filesCopied;
+	const elementsReplaced = fileResults.reduce((total, result$1) => total + result$1.replacedElements, 0);
+	const result = {
+		statsMode,
+		stats: {
+			outputMode: prod ? "prod" : "temp",
+			outputDir: outputRoot,
+			runtimeFree: runtimeFiles.length === 0,
+			runtimeFiles: runtimeFiles.map((file) => path.relative(root, file)),
+			valueHelperFiles: valueHelperFiles.map((file) => path.relative(root, file)),
+			filesProcessed,
+			filesCopied,
+			filesSkipped,
+			filesTotal,
+			elementsReplaced,
+			durationMs,
+			cssBytes,
+			cssWritten,
+			stylesheetPath
+		}
+	};
+	await emitSession(api, await resolveSessionPayload(baseDir, config, "compile", "stop"));
+	return result;
+}
+
+//#endregion
+export { compileProject };