@menapo/vicss 0.0.0-stage → 1.0.0

package/dist/snapshot-BQb8ZmSV.js

@@ -0,0 +1,149 @@
+import { _ as BUILT_IN_UTILITIES, _t as VicssError, dt as isScaleName, ut as isPlainObject, y as resolveSystem } from "./print-Ds6fkgio.js";
+//#region src/core/snapshot.ts
+/**
+* The lint snapshot, `vicss.lint.json`: what the lint rules (src/lint) need
+* of the design system. Lint rules run synchronously, in Oxlint or ESLint,
+* so they cannot load `vicss.config.ts`, its presets and its DTCG files; the
+* plugin and `vicss types` write this file next to `vicss.d.ts` instead,
+* and the rules resolve the system from it with the compiler's own code.
+*
+* It holds the config as it merged, as data: tokens, semantic tokens, text
+* styles, conditions, dark mode, strictness, palettes, `privateAccess`, the
+* custom property prefix and the import sources. A utility's transform is
+* code, so a utility is its name and the scale or flag its value takes.
+* Private tokens are listed by path, read from `ResolvedToken.private`, in
+* place of the `tokenVisibility` patterns they came from; the project root
+* is recorded relative to the file, so `privateAccess` globs match the
+* linted files as they match the build's modules. What no module's style
+* reads (global CSS, keyframes, font faces, the reset, include and
+* exclude) is left out. Key order is the config's own, which decides the
+* ranks of its conditions, so one config always writes the same bytes.
+*/
+/** The file's name; it sits next to `vicss.d.ts`. */
+const SNAPSHOT_FILE = "vicss.lint.json";
+/**
+* Config keys no module's style reads; utilities travel on their own, and
+* `tokenVisibility` as the private tokens it resolved to.
+*/
+const LEFT_OUT = /* @__PURE__ */ new Set([
+	"presets",
+	"utilities",
+	"tokenVisibility",
+	"globalCss",
+	"keyframes",
+	"fontFaces",
+	"reset",
+	"include",
+	"exclude"
+]);
+const BUILT_INS = new Set(Object.values(BUILT_IN_UTILITIES));
+function createSnapshot(system, options = {}) {
+	const config = {};
+	for (const [key, value] of Object.entries(system.config)) if (!LEFT_OUT.has(key) && value !== void 0) config[key] = value;
+	const utilities = {};
+	for (const [name, def] of system.utilities) {
+		if (BUILT_INS.has(def)) continue;
+		utilities[name] = {
+			...def.scale ? { scale: def.scale } : {},
+			...def.boolean ? { boolean: true } : {}
+		};
+	}
+	const privateTokens = {};
+	for (const [scale, table] of system.tokens) {
+		const paths = [...table.values()].filter((t) => t.private === true).map((t) => t.path);
+		if (paths.length > 0) privateTokens[scale] = paths.sort();
+	}
+	return JSON.parse(JSON.stringify({
+		format: 1,
+		...options.root !== void 0 ? { root: options.root } : {},
+		config,
+		utilities,
+		private: privateTokens
+	}));
+}
+/**
+* The file's text: indented, so a committed snapshot diffs by token, and
+* printed as the formatter prints JSON (objects expanded, a list of values
+* on one line when it fits in 100 columns), so `vp fmt` and the plugin
+* never rewrite each other's file.
+*/
+function snapshotText(system, options = {}) {
+	return `${printJson(createSnapshot(system, options), "", "", "")}\n`;
+}
+const WIDTH = 100;
+/** `value` on a line that starts with `indent` and `head` and ends with `tail`. */
+function printJson(value, indent, head, tail) {
+	if (Array.isArray(value)) {
+		if (value.length === 0) return `${head}[]${tail}`;
+		const flat = value.every((item) => typeof item !== "object" || item === null);
+		const line = `${head}[${value.map((item) => JSON.stringify(item)).join(", ")}]${tail}`;
+		if (flat && indent.length + line.length <= WIDTH) return line;
+		const inner = `${indent}  `;
+		return `${head}[\n${value.map((item, i) => inner + printJson(item, inner, "", i < value.length - 1 ? "," : "")).join("\n")}\n${indent}]${tail}`;
+	}
+	if (typeof value === "object" && value !== null) {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return `${head}{}${tail}`;
+		const inner = `${indent}  `;
+		return `${head}{\n${entries.map(([key, item], i) => inner + printJson(item, inner, `${JSON.stringify(key)}: `, i < entries.length - 1 ? "," : "")).join("\n")}\n${indent}}${tail}`;
+	}
+	return `${head}${JSON.stringify(value)}${tail}`;
+}
+/**
+* Resolves the system a snapshot describes. A config utility becomes one
+* whose transform sets nothing, so its value is checked against its scale
+* and its output is not checked: the build does that. Throws a VicssError
+* `SNAPSHOT` for a file of another format or one that does not resolve.
+*/
+function readSnapshot(data) {
+	if (!isPlainObject(data) || typeof data.format !== "number") throw snapshotError("is not a vicss lint snapshot");
+	if (data.format !== 1) throw snapshotError(`has format ${data.format}, and this version of vicss reads format 1`);
+	if (!isPlainObject(data.config) || !isPlainObject(data.utilities)) throw snapshotError("is not a vicss lint snapshot");
+	const utilities = {};
+	for (const [name, def] of Object.entries(data.utilities)) {
+		const { scale, boolean } = isPlainObject(def) ? def : {};
+		utilities[name] = {
+			...scale ? { scale } : {},
+			...boolean ? { boolean } : {},
+			transform: () => ({})
+		};
+	}
+	let system;
+	try {
+		system = resolveSystem({
+			...data.config,
+			utilities
+		});
+	} catch (error) {
+		if (!(error instanceof VicssError)) throw error;
+		throw snapshotError(`does not resolve: ${error.message}`);
+	}
+	const tokens = new Map(system.tokens);
+	for (const [scale, paths] of Object.entries(isPlainObject(data.private) ? data.private : {})) {
+		if (!isScaleName(scale) || !Array.isArray(paths)) continue;
+		const table = system.tokens.get(scale);
+		if (!table) continue;
+		const marked = new Map(table);
+		for (const path of paths) {
+			const token = typeof path === "string" ? table.get(path) : void 0;
+			if (token && !token.palette) marked.set(path, {
+				...token,
+				private: true
+			});
+		}
+		tokens.set(scale, marked);
+	}
+	return {
+		system: {
+			...system,
+			tokens
+		},
+		importSources: system.config.importSources ?? [],
+		...typeof data.root === "string" ? { root: data.root } : {}
+	};
+}
+function snapshotError(problem) {
+	return new VicssError("SNAPSHOT", `${SNAPSHOT_FILE} ${problem}`, { hint: "Write it again for this version of vicss: start the dev server, or run `vicss types`." });
+}
+//#endregion
+export { readSnapshot as n, snapshotText as r, SNAPSHOT_FILE as t };