@menapo/vicss 0.0.0-stage → 1.0.0

package/dist/config-loader-DzP68Snn.js

@@ -0,0 +1,162 @@
+import { l as printBase, st as configError, ut as isPlainObject, y as resolveSystem } from "./print-Ds6fkgio.js";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { pathToFileURL } from "node:url";
+//#region src/config/files.ts
+/** Where the plugin installs its recorder (an `AsyncLocalStorage<ConfigLoad>`). */
+const READS = Symbol.for("@menapo/vicss/config-load");
+/** Non-enumerable on a `dtcg()` result: the absolute paths it read. */
+const FILES = Symbol.for("@menapo/vicss/config-files");
+/** Non-enumerable on a `dtcg()` result: a fresh result if a file changed since, else undefined. */
+const RELOAD = Symbol.for("@menapo/vicss/config-reload");
+/**
+* The files recorded on a config object and its presets, depth first. A
+* `dtcg()` result spread into a config loses them; one in `presets` keeps
+* them.
+*/
+function filesOf(config, seen = /* @__PURE__ */ new Set()) {
+	if (typeof config !== "object" || config === null || seen.has(config)) return [];
+	seen.add(config);
+	const own = config[FILES];
+	const files = Array.isArray(own) ? own.filter((f) => typeof f === "string") : [];
+	const presets = config.presets;
+	if (Array.isArray(presets)) for (const preset of presets) files.push(...filesOf(preset, seen));
+	return [...new Set(files)];
+}
+/**
+* `config` with every `dtcg()` result in its presets whose files changed
+* since it ran replaced by a fresh one. Objects on the way to a replaced one
+* are copied, and everything else is kept by identity, so the caller's
+* objects are never changed. Throws what `dtcg()` throws.
+*/
+function refreshed(config, seen = /* @__PURE__ */ new Map()) {
+	if (typeof config !== "object" || config === null) return config;
+	if (seen.has(config)) return seen.get(config);
+	seen.set(config, config);
+	const reload = config[RELOAD];
+	let out = (typeof reload === "function" ? reload() : void 0) ?? config;
+	const presets = out.presets;
+	if (Array.isArray(presets)) {
+		const next = presets.map((preset) => refreshed(preset, seen));
+		if (next.some((preset, i) => preset !== presets[i])) {
+			out = Object.create(Object.getPrototypeOf(out), Object.getOwnPropertyDescriptors(out));
+			Object.defineProperty(out, "presets", {
+				value: next,
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+		}
+	}
+	seen.set(config, out);
+	return out;
+}
+//#endregion
+//#region src/vite/config-loader.ts
+/**
+* Loads `vicss.config.ts` (PLAN §5.3) with Vite's `runnerImport`, so a config
+* can import presets, token JSON and TypeScript the way app code does,
+* without a second bundler. Vite is imported when a load needs it: a scan
+* worker (D17) that Node can import the config for does without it.
+*/
+const CONFIG_FILES = [
+	"vicss.config.ts",
+	"vicss.config.mts",
+	"vicss.config.js",
+	"vicss.config.mjs"
+];
+/**
+* One recorder for every copy of the plugin in the process: `dtcg()` reports
+* to whichever is installed (config/files.ts), and the store tells loads
+* running at the same time apart.
+*/
+function recorder() {
+	const global = globalThis;
+	return global[READS] ??= new AsyncLocalStorage();
+}
+/**
+* `option` is a path relative to `root`, a config object, or undefined for the
+* first `vicss.config.*` in `root`. Throws VicssError for an invalid config.
+* `reads` receives the files the config read, also when loading it fails, so
+* a caller can watch a token file that is missing or broken.
+*/
+async function loadSystem(root, option, log, reads = /* @__PURE__ */ new Set(), options = {}) {
+	if (typeof option === "object") {
+		const config = recorder().run({ reads }, () => refreshed(option));
+		const files = filesOf(config).map(normalizePath);
+		return {
+			system: checked(config),
+			config,
+			file: void 0,
+			watch: files
+		};
+	}
+	let file;
+	if (typeof option === "string") {
+		file = path.resolve(root, option);
+		if (!existsSync(file)) throw configError("config", `${option} does not exist in ${root}`);
+	} else {
+		file = CONFIG_FILES.map((name) => path.join(root, name)).find((f) => existsSync(f));
+		if (!file) {
+			log(`vicss: no ${CONFIG_FILES.join(", ")} in ${root}; using an empty config`);
+			return {
+				system: resolveSystem({}),
+				config: {},
+				file: void 0,
+				watch: []
+			};
+		}
+	}
+	file = normalizePath(file);
+	const entry = file;
+	const load = {
+		reads,
+		dir: path.dirname(entry)
+	};
+	const { module, dependencies } = await recorder().run(load, async () => {
+		if (options.native) return {
+			module: await import(pathToFileURL(entry).href),
+			dependencies: []
+		};
+		const { runnerImport } = await import("vite");
+		return runnerImport(entry, {
+			root,
+			logLevel: "error"
+		});
+	});
+	if (!isPlainObject(module.default)) throw configError("config", `${path.basename(file)} must export a config object as default`);
+	const config = recorder().run(load, () => refreshed(module.default));
+	const read = [...reads, ...filesOf(config)].map(normalizePath);
+	return {
+		system: checked(config),
+		config,
+		file,
+		watch: [.../* @__PURE__ */ new Set([
+			file,
+			...dependencies.map(normalizePath),
+			...read
+		])]
+	};
+}
+/** Vite's `normalizePath`: forward slashes on Windows, and no `..`. */
+function normalizePath(file) {
+	return path.posix.normalize(process.platform === "win32" ? file.replaceAll("\\", "/") : file);
+}
+/**
+* Resolves the config and prints its own CSS once: `globalCss` and keyframe
+* values are checked only when they print, and an error found here is a
+* config error, reported at startup or keeping the last good config in dev,
+* rather than a failure of the first stylesheet that prints them.
+*/
+function checked(config) {
+	const system = resolveSystem(config);
+	printBase({
+		system,
+		tokens: false,
+		warn: () => {}
+	});
+	return system;
+}
+//#endregion
+export { loadSystem as n, CONFIG_FILES as t };

package/dist/config-loader-pLzP9par.js

@@ -0,0 +1 @@
+export { n as loadSystem } from "./config-loader-DzP68Snn.js";