@styleframe/plugin 2.4.1 → 3.0.0

package/dist/plugin-WmJKFcn_.js

@@ -0,0 +1,595 @@
+import path from "node:path";
+import { consola } from "consola";
+import { transform } from "esbuild";
+import { createUnplugin } from "unplugin";
+import { glob } from "tinyglobby";
+import { loadExtensionModule, loadModule } from "@styleframe/loader";
+import fs from "node:fs";
+import os from "node:os";
+import { transpile } from "@styleframe/transpiler";
+import { getLicenseKeyFromEnv, validateInstanceLicense } from "@styleframe/license";
+import fs$1 from "node:fs/promises";
+import { createScanner } from "@styleframe/scanner";
+
+//#region src/plugin/constants.ts
+const DEFAULT_ENTRY = "./styleframe.config.ts";
+const DEFAULT_OPTIONS = {
+	entry: DEFAULT_ENTRY,
+	silent: false
+};
+const PLUGIN_NAME = "styleframe";
+const IMPORT_V_PREFIX = "virtual:";
+const ROLLUP_V_PREFIX = "\0";
+const VIRTUAL_CSS_MODULE_ID = `${IMPORT_V_PREFIX}${PLUGIN_NAME}.css`;
+const RESOLVED_VIRTUAL_CSS_MODULE_ID = `${ROLLUP_V_PREFIX}${VIRTUAL_CSS_MODULE_ID}`;
+const VIRTUAL_TS_MODULE_ID = `${IMPORT_V_PREFIX}${PLUGIN_NAME}`;
+const RESOLVED_VIRTUAL_TS_MODULE_ID = `${ROLLUP_V_PREFIX}${VIRTUAL_TS_MODULE_ID}`;
+const RESOLVED_VIRTUAL_EXTENSION_ID = `${ROLLUP_V_PREFIX}${IMPORT_V_PREFIX}${PLUGIN_NAME}:extension`;
+const RESOLVED_VIRTUAL_CONSUMER_ID = `${ROLLUP_V_PREFIX}${IMPORT_V_PREFIX}${PLUGIN_NAME}:consumer`;
+const DEFAULT_IGNORE_PATTERNS = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/.next/**",
+	"**/.nuxt/**",
+	"**/coverage/**"
+];
+
+//#endregion
+//#region src/plugin/state.ts
+/**
+* Create a new plugin state instance
+*/
+function createPluginState(configPath) {
+	return {
+		globalInstance: null,
+		configFile: {
+			path: configPath,
+			loadOrder: -1,
+			exports: /* @__PURE__ */ new Map(),
+			lastModified: 0
+		},
+		files: /* @__PURE__ */ new Map(),
+		loadingFiles: /* @__PURE__ */ new Set(),
+		initialized: false
+	};
+}
+/**
+* Find if an export name is already used by another file.
+* Returns the source file path if collision found, null otherwise.
+*/
+function findExportCollision(state, exportName, excludeFile) {
+	if (state.configFile && state.configFile.path !== excludeFile && state.configFile.exports.has(exportName)) return state.configFile.path;
+	for (const [filePath, fileInfo] of state.files) {
+		if (filePath === excludeFile) continue;
+		if (fileInfo.exports.has(exportName)) return filePath;
+	}
+	return null;
+}
+/**
+* Reset all state (used when config changes)
+*/
+function resetState(state) {
+	state.globalInstance = null;
+	if (state.configFile) {
+		state.configFile.exports.clear();
+		state.configFile.lastModified = 0;
+	}
+	state.files.clear();
+	state.loadingFiles.clear();
+	state.initialized = false;
+}
+
+//#endregion
+//#region src/plugin/discovery.ts
+/**
+* Discover all *.styleframe.ts files in the project
+*/
+async function discoverStyleframeFiles(options) {
+	return await glob(options.include.length > 0 ? options.include : ["**/*.styleframe.ts"], {
+		cwd: options.cwd,
+		absolute: true,
+		ignore: [...DEFAULT_IGNORE_PATTERNS, ...options.exclude]
+	});
+}
+/**
+* Sort files by the specified load order strategy
+*/
+function sortByLoadOrder(files, strategy) {
+	const sorted = [...files];
+	switch (strategy) {
+		case "alphabetical": return sorted.sort((a, b) => a.localeCompare(b));
+		case "depth-first": return sorted.sort((a, b) => {
+			const depthA = a.split(path.sep).length;
+			const depthB = b.split(path.sep).length;
+			if (depthA !== depthB) return depthA - depthB;
+			return a.localeCompare(b);
+		});
+		default: {
+			const _exhaustive = strategy;
+			throw new Error(`Unknown load order strategy: ${_exhaustive}`);
+		}
+	}
+}
+
+//#endregion
+//#region src/plugin/errors.ts
+/**
+* Base error class for Styleframe plugin errors
+*/
+var StyleframePluginError = class extends Error {
+	constructor(message) {
+		super(`[styleframe] ${message}`);
+		this.name = "StyleframePluginError";
+	}
+};
+/**
+* Thrown when two different files export the same name
+*/
+var ExportCollisionError = class extends StyleframePluginError {
+	constructor(exportName, source1, source2) {
+		super(`Export collision: "${exportName}" is exported from both:\n  - ${source1}\n  - ${source2}\n\nRename one of the exports to resolve this collision.`);
+		this.name = "ExportCollisionError";
+	}
+};
+/**
+* Thrown when trying to use the global instance before it's initialized
+*/
+var GlobalInstanceNotInitializedError = class extends StyleframePluginError {
+	constructor() {
+		super("Global instance not initialized. Make sure styleframe.config.ts is loaded before *.styleframe.ts files.");
+		this.name = "GlobalInstanceNotInitializedError";
+	}
+};
+/**
+* Thrown when a circular dependency is detected
+*/
+var CircularDependencyError = class extends StyleframePluginError {
+	constructor(filePath, chain) {
+		super(`Circular dependency detected:\n  ${chain.join(" -> ")} -> ${filePath}`);
+		this.name = "CircularDependencyError";
+	}
+};
+
+//#endregion
+//#region src/plugin/global-loader.ts
+const GLOBAL_INSTANCE_KEY = "__STYLEFRAME_GLOBAL_INSTANCE__";
+let extensionShimPath = null;
+/**
+* Get or create the extension shim file.
+* The shim reads the global instance from globalThis and exports it.
+*/
+function getExtensionShimPath() {
+	if (extensionShimPath && fs.existsSync(extensionShimPath)) return extensionShimPath;
+	const shimContent = `
+export function styleframe() {
+	const instance = globalThis["${GLOBAL_INSTANCE_KEY}"];
+	if (!instance) {
+		throw new Error('[styleframe] Global instance not available during loading');
+	}
+	return instance;
+}
+
+export default { styleframe };
+`;
+	const tempDir = os.tmpdir();
+	extensionShimPath = path.join(tempDir, `styleframe-shim-${process.pid}.mjs`);
+	fs.writeFileSync(extensionShimPath, shimContent);
+	return extensionShimPath;
+}
+/**
+* Check exports for collisions and throw if found.
+*/
+function checkExportCollisions(state, exports, filePath) {
+	for (const [name] of exports) {
+		const collision = findExportCollision(state, name, filePath);
+		if (collision) throw new ExportCollisionError(name, collision, filePath);
+	}
+}
+/**
+* Load the config file and initialize the global instance
+*/
+async function loadConfigFile(state) {
+	if (!state.configFile) throw new Error("[styleframe] Config file not set");
+	const configPath = state.configFile.path;
+	const { instance, exports } = await loadModule(configPath);
+	checkExportCollisions(state, exports, configPath);
+	state.globalInstance = instance;
+	state.configFile.exports = exports;
+	state.configFile.lastModified = Date.now();
+	return instance;
+}
+/**
+* Load a single *.styleframe.ts file using the global instance
+*/
+async function loadStyleframeFile(state, filePath, loadOrder) {
+	if (!state.globalInstance) throw new GlobalInstanceNotInitializedError();
+	if (state.loadingFiles.has(filePath)) throw new CircularDependencyError(filePath, [...state.loadingFiles]);
+	state.loadingFiles.add(filePath);
+	try {
+		globalThis[GLOBAL_INSTANCE_KEY] = state.globalInstance;
+		const { exports } = await loadExtensionModule(filePath, { alias: { "virtual:styleframe": getExtensionShimPath() } });
+		checkExportCollisions(state, exports, filePath);
+		state.files.set(filePath, {
+			path: filePath,
+			loadOrder,
+			exports,
+			lastModified: Date.now()
+		});
+	} finally {
+		state.loadingFiles.delete(filePath);
+		delete globalThis[GLOBAL_INSTANCE_KEY];
+	}
+}
+/**
+* Load all styleframe files in order
+*/
+async function loadAllStyleframeFiles(state, files) {
+	for (let i = 0; i < files.length; i++) {
+		const file = files[i];
+		if (file) await loadStyleframeFile(state, file, i);
+	}
+}
+/**
+* Reload the config and all styleframe files
+*/
+async function reloadAll(state, files) {
+	resetState(state);
+	await loadConfigFile(state);
+	await loadAllStyleframeFiles(state, files);
+}
+
+//#endregion
+//#region src/plugin/generate/extension-module.ts
+/**
+* Generate the extension module content.
+* This is what *.styleframe.ts files receive when they import from 'virtual:styleframe'.
+* It imports the config directly and returns the same instance.
+*/
+function generateExtensionModule(configPath) {
+	return `
+import config from '${configPath.replace(/\\/g, "/")}';
+
+export function styleframe() {
+	return config;
+}
+
+export default config;
+`;
+}
+
+//#endregion
+//#region src/plugin/generate/consumer-module.ts
+/**
+* Generate the consumer module content using the transpiler.
+* Uses the TypeScript transpiler to generate proper recipe exports with serialized runtime data.
+*/
+async function generateConsumerModule(state) {
+	if (!state.globalInstance) return `// Styleframe not initialized`;
+	return (await transpile(state.globalInstance, { type: "ts" })).files.find((f) => f.name === "index.ts")?.content ?? "";
+}
+
+//#endregion
+//#region src/plugin/generate/global-css.ts
+/**
+* Generate global CSS from the global instance.
+*/
+async function generateGlobalCSS(state, isBuild, options) {
+	if (!state.globalInstance) return { code: "/* Styleframe not initialized */" };
+	await validateInstanceLicense(state.globalInstance, {
+		licenseKey: getLicenseKeyFromEnv() || "",
+		environment: process.env.NODE_ENV || "development",
+		isBuild
+	});
+	const css = (await transpile(state.globalInstance, { type: "css" })).files.map((f) => f.content).join("\n");
+	if (!options.silent) consola.success(`[styleframe] Built global CSS successfully.`);
+	return { code: css };
+}
+
+//#endregion
+//#region src/plugin/generate/dts.ts
+const DEFAULT_OUT_DIR = ".styleframe";
+/**
+* Generates type declarations for virtual:styleframe module.
+* Uses the transpiler's dts mode to generate the types.
+*/
+async function generateTypeDeclarations(state, cwd, options = {}, silent = false) {
+	if (!state.globalInstance) return;
+	const outDir = path.resolve(cwd, options.outDir ?? DEFAULT_OUT_DIR);
+	await fs$1.mkdir(outDir, { recursive: true });
+	const content = (await transpile(state.globalInstance, { type: "dts" })).files.find((f) => f.name === "index.d.ts")?.content ?? "";
+	const outputPath = path.join(outDir, "styleframe.d.ts");
+	await fs$1.writeFile(outputPath, content);
+	if (!silent) consola.success(`[styleframe] Generated type declarations.`);
+}
+
+//#endregion
+//#region src/plugin/scanner.ts
+/**
+* Create a plugin scanner instance.
+*
+* @param contentPatterns Glob patterns for content files to scan
+* @param cwd Working directory for glob resolution
+* @returns Plugin scanner state
+*/
+function createPluginScanner(contentPatterns, cwd) {
+	return {
+		scanner: createScanner({
+			content: contentPatterns,
+			cwd
+		}),
+		scannedFiles: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* Full scan: scan all content files and register detected utilities.
+*
+* Used at build start and after reloadAll.
+*
+* @param pluginState The plugin global state
+* @param scannerState The scanner state
+* @param options Options for logging
+* @returns Number of newly registered utility values
+*/
+async function scanAndRegister(pluginState, scannerState, options) {
+	if (!pluginState.globalInstance) return 0;
+	const result = await scannerState.scanner.scan();
+	scannerState.scannedFiles.clear();
+	for (const filePath of result.files.keys()) scannerState.scannedFiles.add(filePath);
+	const matches = scannerState.scanner.match(result.allParsed, pluginState.globalInstance.root);
+	const registered = registerMatchedUtilities(pluginState, matches);
+	if (!options?.silent) {
+		const unmatched = matches.filter((m) => m.factory === null);
+		if (unmatched.length > 0) {
+			const names = [...new Set(unmatched.map((m) => m.parsed.raw))];
+			consola.warn(`[styleframe] Scanner found ${unmatched.length} utility class(es) without a matching factory: ${names.join(", ")}`);
+		}
+		if (registered > 0) consola.info(`[styleframe] Scanner registered ${registered} utility value(s) from ${result.files.size} content file(s).`);
+	}
+	return registered;
+}
+/**
+* Incremental scan: scan a single file and register any new utilities.
+*
+* Used for HMR when a content file changes.
+*
+* @param pluginState The plugin global state
+* @param scannerState The scanner state
+* @param filePath The changed file path
+* @returns true if new values were registered (CSS needs invalidation)
+*/
+async function scanFileAndRegister(pluginState, scannerState, filePath) {
+	if (!pluginState.globalInstance) return false;
+	scannerState.scanner.invalidate(filePath);
+	const fileResult = await scannerState.scanner.scanFile(filePath);
+	return registerMatchedUtilities(pluginState, scannerState.scanner.match(fileResult.parsed, pluginState.globalInstance.root)) > 0;
+}
+/**
+* Check if a file is a tracked content file.
+*/
+function isContentFile(scannerState, filePath) {
+	return scannerState?.scannedFiles.has(filePath) ?? false;
+}
+/**
+* Register utility values detected by the scanner that don't yet exist on the root.
+*
+* For non-arbitrary values, uses the factory's autogenerate function (treating the
+* value key as a token reference). For arbitrary values, registers with the literal
+* CSS value directly.
+*
+* @param pluginState The plugin global state
+* @param matches Scanner match results
+* @returns Number of newly registered values
+*/
+function registerMatchedUtilities(pluginState, matches) {
+	const unregistered = matches.filter((m) => m.factory !== null && !m.exists);
+	if (unregistered.length === 0) return 0;
+	const groups = /* @__PURE__ */ new Map();
+	for (const match of unregistered) {
+		const factory = match.factory;
+		const key = `${factory.name}:${match.parsed.value}`;
+		const existing = groups.get(key);
+		if (!existing) groups.set(key, {
+			factory,
+			parsed: match.parsed,
+			modifiers: [...match.modifierFactories]
+		});
+		else for (const mod of match.modifierFactories) {
+			const modKey = mod.key.join(",");
+			if (!existing.modifiers.some((m) => m.key.join(",") === modKey)) existing.modifiers.push(mod);
+		}
+	}
+	let count = 0;
+	for (const { factory, parsed, modifiers } of groups.values()) {
+		const modifierArgs = modifiers.length > 0 ? modifiers : void 0;
+		if (parsed.isArbitrary && parsed.arbitraryValue !== void 0) factory.create({ [parsed.value]: parsed.arbitraryValue }, modifierArgs);
+		else {
+			const autoGenerated = factory.autogenerate(`@${parsed.value}`);
+			factory.create(autoGenerated, modifierArgs);
+		}
+		count++;
+	}
+	return count;
+}
+
+//#endregion
+//#region src/plugin/index.ts
+const STYLEFRAME_SOURCE_REGEX = /\.styleframe\.ts$/;
+function isStyleframeSourceFile(id) {
+	return STYLEFRAME_SOURCE_REGEX.test(id);
+}
+const unpluginFactory = (options = DEFAULT_OPTIONS) => {
+	const cwd = process.cwd();
+	const entry = options.entry ?? DEFAULT_ENTRY;
+	const configPath = path.isAbsolute(entry) ? entry : path.resolve(cwd, entry);
+	const state = createPluginState(configPath);
+	let isBuildCommand = false;
+	let scannerState = null;
+	let typeGenTimeout = null;
+	const scheduleTypeGeneration = () => {
+		if (options.dts?.enabled === false) return;
+		if (typeGenTimeout) clearTimeout(typeGenTimeout);
+		typeGenTimeout = setTimeout(async () => {
+			try {
+				await generateTypeDeclarations(state, cwd, options.dts, options.silent);
+			} catch (error) {
+				consola.error(`[styleframe] Type generation failed:`, error);
+			}
+		}, 100);
+	};
+	return {
+		name: PLUGIN_NAME,
+		enforce: "pre",
+		async buildStart() {
+			isBuildCommand = process.argv.includes("build");
+			if (!options.silent) {
+				console.log("");
+				consola.info(`[styleframe] Initializing...`);
+			}
+			try {
+				await loadConfigFile(state);
+				const sortedFiles = sortByLoadOrder((await discoverStyleframeFiles({
+					cwd,
+					include: options.include ?? [],
+					exclude: options.exclude ?? []
+				})).filter((f) => f !== configPath), options.loadOrder ?? "alphabetical");
+				await loadAllStyleframeFiles(state, sortedFiles);
+				if (options.content?.length) {
+					scannerState = createPluginScanner(options.content, cwd);
+					await scanAndRegister(state, scannerState, { silent: options.silent });
+				}
+				this.addWatchFile(configPath);
+				for (const file of sortedFiles) this.addWatchFile(file);
+				if (scannerState) for (const file of scannerState.scannedFiles) this.addWatchFile(file);
+				state.initialized = true;
+				if (options.dts?.enabled !== false) await generateTypeDeclarations(state, cwd, options.dts, options.silent);
+				if (!options.silent) {
+					consola.success(`[styleframe] Initialized with ${sortedFiles.length} styleframe file(s).`);
+					console.log("");
+				}
+			} catch (error) {
+				consola.error(`[styleframe] Initialization failed:`, error);
+				throw error;
+			}
+		},
+		resolveId(id, importer) {
+			if (id === VIRTUAL_TS_MODULE_ID) {
+				if (importer && isStyleframeSourceFile(importer)) return RESOLVED_VIRTUAL_EXTENSION_ID;
+				return RESOLVED_VIRTUAL_CONSUMER_ID;
+			}
+			if (id === VIRTUAL_CSS_MODULE_ID) return RESOLVED_VIRTUAL_CSS_MODULE_ID;
+			return null;
+		},
+		async load(id) {
+			if (id === RESOLVED_VIRTUAL_EXTENSION_ID) return { code: generateExtensionModule(configPath) };
+			if (id === RESOLVED_VIRTUAL_CONSUMER_ID) return { code: await generateConsumerModule(state) };
+			if (id === RESOLVED_VIRTUAL_CSS_MODULE_ID) return generateGlobalCSS(state, isBuildCommand, options);
+			return null;
+		},
+		vite: {
+			async transform(code, id) {
+				if (id === RESOLVED_VIRTUAL_TS_MODULE_ID || id === RESOLVED_VIRTUAL_EXTENSION_ID || id === RESOLVED_VIRTUAL_CONSUMER_ID) {
+					const result = await transform(code, {
+						loader: "ts",
+						format: "esm",
+						target: "esnext"
+					});
+					return {
+						code: result.code,
+						map: result.map || null
+					};
+				}
+				return null;
+			},
+			configureServer(server) {
+				server.watcher.on("add", async (file) => {
+					if (isStyleframeSourceFile(file) && file !== configPath && !state.files.has(file)) try {
+						const loadOrder = state.files.size;
+						await loadStyleframeFile(state, file, loadOrder);
+						if (!options.silent) consola.info(`[styleframe] Discovered new file: ${path.relative(cwd, file)}`);
+						if (scannerState) await scanAndRegister(state, scannerState, { silent: options.silent });
+						const consumerMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_CONSUMER_ID);
+						const cssMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_CSS_MODULE_ID);
+						if (consumerMod) server.moduleGraph.invalidateModule(consumerMod);
+						if (cssMod) server.moduleGraph.invalidateModule(cssMod);
+						scheduleTypeGeneration();
+						server.ws.send({ type: "full-reload" });
+					} catch (error) {
+						consola.error(`[styleframe] Failed to load new file: ${file}`, error);
+					}
+				});
+				server.watcher.on("unlink", async (file) => {
+					if (state.files.has(file)) {
+						if (!options.silent) consola.info(`[styleframe] File removed: ${path.relative(cwd, file)}`);
+						try {
+							await reloadAll(state, [...state.files.entries()].filter(([filePath]) => filePath !== file).sort(([, a], [, b]) => a.loadOrder - b.loadOrder).map(([filePath]) => filePath));
+							if (scannerState) await scanAndRegister(state, scannerState, { silent: options.silent });
+							const consumerMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_CONSUMER_ID);
+							const cssMod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_CSS_MODULE_ID);
+							if (consumerMod) server.moduleGraph.invalidateModule(consumerMod);
+							if (cssMod) server.moduleGraph.invalidateModule(cssMod);
+							scheduleTypeGeneration();
+							server.ws.send({ type: "full-reload" });
+						} catch (error) {
+							consola.error(`[styleframe] Failed to reload after file removal: ${file}`, error);
+						}
+					}
+				});
+			},
+			async handleHotUpdate(ctx) {
+				const getModuleById = async (id) => {
+					return ctx.server?.moduleGraph.getModuleById(id) ?? await ctx.server?.moduleGraph.getModuleByUrl(id);
+				};
+				if (ctx.file === configPath) {
+					if (!options.silent) consola.info(`[styleframe] Config changed, reloading...`);
+					try {
+						await reloadAll(state, [...state.files.keys()]);
+						if (scannerState) await scanAndRegister(state, scannerState, { silent: options.silent });
+						const modulesToInvalidate = [
+							await getModuleById(RESOLVED_VIRTUAL_CSS_MODULE_ID),
+							await getModuleById(RESOLVED_VIRTUAL_EXTENSION_ID),
+							await getModuleById(RESOLVED_VIRTUAL_CONSUMER_ID)
+						].filter(Boolean);
+						scheduleTypeGeneration();
+						if (modulesToInvalidate.length > 0) return modulesToInvalidate;
+					} catch (error) {
+						consola.error(`[styleframe] Reload failed:`, error);
+					}
+					return ctx.modules;
+				}
+				if (state.files.has(ctx.file)) {
+					if (!options.silent) consola.info(`[styleframe] File changed: ${path.relative(cwd, ctx.file)}`);
+					try {
+						await reloadAll(state, [...state.files.keys()]);
+						if (scannerState) await scanAndRegister(state, scannerState, { silent: options.silent });
+						const modulesToInvalidate = [await getModuleById(RESOLVED_VIRTUAL_CSS_MODULE_ID), await getModuleById(RESOLVED_VIRTUAL_CONSUMER_ID)].filter(Boolean);
+						scheduleTypeGeneration();
+						if (modulesToInvalidate.length > 0) return modulesToInvalidate;
+					} catch (error) {
+						consola.error(`[styleframe] Failed to reload: ${ctx.file}`, error);
+					}
+					return ctx.modules;
+				}
+				if (isContentFile(scannerState, ctx.file)) {
+					try {
+						if (await scanFileAndRegister(state, scannerState, ctx.file)) {
+							const cssModule = await getModuleById(RESOLVED_VIRTUAL_CSS_MODULE_ID);
+							if (cssModule) return [cssModule, ...ctx.modules];
+						}
+					} catch (error) {
+						consola.error(`[styleframe] Failed to scan content file: ${ctx.file}`, error);
+					}
+					return ctx.modules;
+				}
+				return ctx.modules;
+			}
+		}
+	};
+};
+const unplugin = /* @__PURE__ */ createUnplugin(unpluginFactory);
+var plugin_default = unplugin;
+
+//#endregion
+export { plugin_default, unplugin, unpluginFactory };
+//# sourceMappingURL=plugin-WmJKFcn_.js.map