@bamboocss/vite 1.45.4 → 1.46.0

package/dist/chunk.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/class-name.cjs

@@ -0,0 +1,17 @@
+//#region src/class-name.ts
+/**
+* A class name with its CSS escapes removed, which is the only spelling the compiler and
+* stylesheet inventory both agree on.
+*
+* This stays in the eager graph because the output lifecycle uses it for a synchronous safety
+* check. The PostCSS parser which consumes the same spelling belongs to the lazy CSS-output
+* boundary instead.
+*/
+const bare = (className) => className.replaceAll("\\", "");
+//#endregion
+Object.defineProperty(exports, "bare", {
+	enumerable: true,
+	get: function() {
+		return bare;
+	}
+});

package/dist/class-name.mjs

@@ -0,0 +1,12 @@
+//#region src/class-name.ts
+/**
+* A class name with its CSS escapes removed, which is the only spelling the compiler and
+* stylesheet inventory both agree on.
+*
+* This stays in the eager graph because the output lifecycle uses it for a synchronous safety
+* check. The PostCSS parser which consumes the same spelling belongs to the lazy CSS-output
+* boundary instead.
+*/
+const bare = (className) => className.replaceAll("\\", "");
+//#endregion
+export { bare as t };

package/dist/config-module.cjs

@@ -0,0 +1,9 @@
+var _bamboocss_config = require("@bamboocss/config");
+Object.keys(_bamboocss_config).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _bamboocss_config[k];
+		}
+	});
+});

package/dist/config-module.mjs

@@ -0,0 +1,2 @@
+export * from "@bamboocss/config";
+export {};

package/dist/css-output-module.cjs

@@ -0,0 +1,218 @@
+const require_chunk = require("./chunk.cjs");
+const require_class_name = require("./class-name.cjs");
+let _bamboocss_shared = require("@bamboocss/shared");
+let _ampproject_remapping = require("@ampproject/remapping");
+_ampproject_remapping = require_chunk.__toESM(_ampproject_remapping);
+let magic_string = require("magic-string");
+magic_string = require_chunk.__toESM(magic_string);
+let postcss = require("postcss");
+postcss = require_chunk.__toESM(postcss);
+let postcss_selector_parser = require("postcss-selector-parser");
+postcss_selector_parser = require_chunk.__toESM(postcss_selector_parser);
+//#region src/prune-static-css.ts
+/** The generated declaration that identifies a Bamboo stylesheet after minification. */
+const SENTINEL = "--made-with-bamboo";
+/**
+* Remove source-graph atoms no transformed module can emit.
+*
+* `prunableClasses` contains only atoms extracted from the source graph. Explicit `staticCss`
+* additions are absent and survive as a safelist; graph atoms are governed by the transformed
+* module reachability set, regardless of whether they originated in `css()` or a recipe.
+*/
+const pruneStaticCss = (css, session, { environment, prune = true, requiredClasses } = {}) => {
+	if (!css.includes(SENTINEL)) return css;
+	const root = postcss.default.parse(css);
+	const prunable = new Set([...session.prunableClasses].map(require_class_name.bare));
+	const used = new Set([...session.usedClasses].map(require_class_name.bare));
+	const isUtilityRule = (rule) => {
+		let parent = rule.parent;
+		while (parent) {
+			if (parent.type === "atrule") {
+				const atRule = parent;
+				if (atRule.name === "layer" && atRule.params === session.utilityLayer) return true;
+			}
+			parent = parent.parent;
+		}
+		return false;
+	};
+	if (prune) root.walkRules((rule) => {
+		if (!isUtilityRule(rule)) return;
+		let removedAny = false;
+		let selector;
+		try {
+			selector = (0, postcss_selector_parser.default)((selectors) => {
+				selectors.each((candidate) => {
+					const classes = /* @__PURE__ */ new Set();
+					candidate.walkClasses((classNode) => {
+						classes.add(require_class_name.bare(classNode.toString().slice(1)));
+					});
+					if (classes.size !== 1) return;
+					const [className] = classes;
+					if (!className || !prunable.has(className) || used.has(className)) return;
+					candidate.remove();
+					removedAny = true;
+					session.prunedClasses.add(className);
+				});
+			}).processSync(rule.selector);
+		} catch {
+			return;
+		}
+		if (!removedAny) return;
+		if (!selector.trim()) {
+			rule.remove();
+			return;
+		}
+		rule.selector = selector;
+	});
+	let removed = true;
+	while (removed) {
+		removed = false;
+		root.walkAtRules((rule) => {
+			if (rule.nodes?.length !== 0) return;
+			rule.remove();
+			removed = true;
+		});
+	}
+	const present = /* @__PURE__ */ new Set();
+	root.walkRules((rule) => {
+		if (!isUtilityRule(rule)) return;
+		try {
+			(0, postcss_selector_parser.default)((selectors) => {
+				selectors.walkClasses((classNode) => {
+					present.add(require_class_name.bare(classNode.toString().slice(1)));
+				});
+			}).processSync(rule.selector);
+		} catch {}
+	});
+	const required = requiredClasses ?? new Set([...session.usedClasses].filter((className) => prunable.has(require_class_name.bare(className))));
+	const orphaned = [];
+	for (const className of required) {
+		if (/\s/.test(className)) {
+			orphaned.push(className);
+			continue;
+		}
+		if (present.has(require_class_name.bare(className))) continue;
+		orphaned.push(className);
+	}
+	if (orphaned.length) {
+		const describe = (className) => {
+			if (/\s/.test(className)) return `  ${className}\n      (malformed key: a class name cannot contain whitespace)`;
+			const normalized = require_class_name.bare(className);
+			const extracted = prunable.has(normalized) ? "in the extracted atoms" : "NOT extracted";
+			const near = [...present].filter((candidate) => candidate !== className && candidate.replaceAll("\\", "") === normalized);
+			return `  ${className}\n      (${extracted}; no rule in the sheet` + (near.length ? `; a rule exists under ${near.map((n) => JSON.stringify(n)).join(", ")}` : "") + `)`;
+		};
+		const environmentDescription = environment ? ` for the ${JSON.stringify(environment)} environment` : "";
+		throw new Error(`bamboocss: ${orphaned.length} compiled class(es) still named by live output have no rule in the candidate stylesheet${environmentDescription}. Elements carrying them would render unstyled.\n\n${(0, _bamboocss_shared.truncateList)(orphaned.map(describe), {
+			unit: "class",
+			separator: "\n"
+		})}\n\nThe current source generation no longer provides every rule required by the JavaScript outputs still on disk. Bamboo refused to replace the prior stylesheet. Finish rebuilding every output which retains an older generation, then rebuild the stylesheet. If every output is already current, report this as a compiler bug with the block above.`);
+	}
+	return root.toString();
+};
+//#endregion
+//#region src/css-output-module.ts
+const INLINE_SOURCE_MAP = /\n?\/\/# sourceMappingURL=data:application\/json[^\n]*$/;
+/** Rewrite one generated chunk without invalidating all mappings after the changed string. */
+const replaceChunkReference = (chunk, bundle, previous, next, sourcemap) => {
+	if (!chunk.code.includes(previous)) return;
+	const magic = new magic_string.default(chunk.code);
+	let index = chunk.code.indexOf(previous);
+	while (index !== -1) {
+		magic.overwrite(index, index + previous.length, next);
+		index = chunk.code.indexOf(previous, index + previous.length);
+	}
+	chunk.code = magic.toString();
+	if (!chunk.map) return;
+	const file = chunk.map.file;
+	const debugId = chunk.map.debugId;
+	const combined = (0, _ampproject_remapping.default)([magic.generateMap({
+		source: chunk.fileName,
+		hires: "boundary"
+	}), chunk.map], () => null);
+	if (file) combined.file = file;
+	if (debugId) combined.debugId = debugId;
+	const rollupMap = combined;
+	rollupMap.toUrl = () => `data:application/json;charset=utf-8;base64,${Buffer.from(combined.toString()).toString("base64")}`;
+	chunk.map = rollupMap;
+	if (sourcemap === "inline") {
+		chunk.code = chunk.code.replace(INLINE_SOURCE_MAP, "");
+		chunk.code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${Buffer.from(combined.toString()).toString("base64")}`;
+		return;
+	}
+	const mapAsset = bundle[`${chunk.fileName}.map`];
+	if (mapAsset?.type === "asset") mapAsset.source = combined.toString();
+};
+/** Replace an emitted filename wherever Vite or Rollup has already recorded it. */
+const replaceAssetReferences = (bundle, previous, next, sourcemap) => {
+	const replace = (value) => value.replaceAll(previous, next);
+	for (const output of Object.values(bundle)) {
+		if (output.type === "asset") {
+			if (typeof output.source === "string") output.source = replace(output.source);
+			continue;
+		}
+		replaceChunkReference(output, bundle, previous, next, sourcemap);
+		const referencedFiles = output.referencedFiles;
+		if (referencedFiles) output.referencedFiles = referencedFiles.map(replace);
+		const importedCss = output.viteMetadata?.importedCss;
+		if (importedCss?.delete(previous)) importedCss.add(next);
+	}
+};
+/**
+* Could this bundle entry be the generated stylesheet?
+*
+* The filename is checked before the bytes because the alternative decodes every asset in the
+* bundle to a UTF-8 string in order to search it — fonts, images and sourcemaps included. On an
+* app with a large asset graph that is seconds of decode and a lot of garbage, twice over, to
+* answer a question the extension already answers. The marker is a CSS custom property, so it
+* cannot occur anywhere but CSS.
+*/
+const isCssAsset = (output) => output.type === "asset" && output.fileName.endsWith(".css");
+/** Decode a generated Bamboo stylesheet, or decline any other bundle entry. */
+const generatedCssSource = (output) => {
+	if (!isCssAsset(output)) return void 0;
+	const source = typeof output.source === "string" ? output.source : Buffer.from(output.source).toString();
+	return source.includes("--made-with-bamboo") ? source : void 0;
+};
+/** Whether this bundle replaces a previously generated Bamboo stylesheet. */
+const containsGeneratedCssAsset = (bundle) => Object.values(bundle).some((output) => generatedCssSource(output) !== void 0);
+/**
+* Prune compiler-owned CSS, then give any sheet whose bytes changed a hash of those bytes.
+*
+* Rollup has already expanded `[hash]` when `generateBundle` runs. Mutating only `source`
+* would therefore leave two different reachable subsets under one CDN key. The extra final
+* hash is not cosmetic: it makes late graph reachability cache-safe.
+*
+* Renaming is therefore not a choice this takes. Pruned bytes under the unpruned sheet's name
+* is the one outcome that must never be reachable, and a sheet nothing was removed from keeps
+* its name because its bytes are unchanged — so "rename" is a consequence of "the bytes moved",
+* not a second option. `prune` is the only knob.
+*/
+const optimizeStaticCssAssets = (bundle, session, options = {}) => {
+	const { environment, prune = true, requiredClasses, sourcemap = session.sourcemap } = options;
+	/** Assets in this bundle that carry the generated stylesheet, pruned or not. */
+	let sheets = 0;
+	for (const output of Object.values(bundle)) {
+		const source = generatedCssSource(output);
+		if (source === void 0) continue;
+		sheets++;
+		const optimized = pruneStaticCss(source, session, {
+			environment,
+			prune,
+			requiredClasses
+		});
+		if (!prune) continue;
+		output.source = optimized;
+		if (optimized === source) continue;
+		const nextName = output.fileName.replace(/\.css$/, `.b-${(0, _bamboocss_shared.toHash)(optimized)}.css`);
+		if (bundle[nextName] && bundle[nextName] !== output) throw new Error(`bamboocss: final CSS asset name collision at ${JSON.stringify(nextName)}.`);
+		const previous = output.fileName;
+		output.fileName = nextName;
+		replaceAssetReferences(bundle, previous, nextName, sourcemap);
+	}
+	return { sheets };
+};
+//#endregion
+exports.containsGeneratedCssAsset = containsGeneratedCssAsset;
+exports.optimizeStaticCssAssets = optimizeStaticCssAssets;
+exports.pruneStaticCss = pruneStaticCss;

package/dist/css-output-module.mjs

@@ -0,0 +1,211 @@
+import { t as bare } from "./class-name.mjs";
+import { toHash, truncateList } from "@bamboocss/shared";
+import remapping from "@ampproject/remapping";
+import MagicString from "magic-string";
+import postcss from "postcss";
+import selectorParser from "postcss-selector-parser";
+//#region src/prune-static-css.ts
+/** The generated declaration that identifies a Bamboo stylesheet after minification. */
+const SENTINEL = "--made-with-bamboo";
+/**
+* Remove source-graph atoms no transformed module can emit.
+*
+* `prunableClasses` contains only atoms extracted from the source graph. Explicit `staticCss`
+* additions are absent and survive as a safelist; graph atoms are governed by the transformed
+* module reachability set, regardless of whether they originated in `css()` or a recipe.
+*/
+const pruneStaticCss = (css, session, { environment, prune = true, requiredClasses } = {}) => {
+	if (!css.includes(SENTINEL)) return css;
+	const root = postcss.parse(css);
+	const prunable = new Set([...session.prunableClasses].map(bare));
+	const used = new Set([...session.usedClasses].map(bare));
+	const isUtilityRule = (rule) => {
+		let parent = rule.parent;
+		while (parent) {
+			if (parent.type === "atrule") {
+				const atRule = parent;
+				if (atRule.name === "layer" && atRule.params === session.utilityLayer) return true;
+			}
+			parent = parent.parent;
+		}
+		return false;
+	};
+	if (prune) root.walkRules((rule) => {
+		if (!isUtilityRule(rule)) return;
+		let removedAny = false;
+		let selector;
+		try {
+			selector = selectorParser((selectors) => {
+				selectors.each((candidate) => {
+					const classes = /* @__PURE__ */ new Set();
+					candidate.walkClasses((classNode) => {
+						classes.add(bare(classNode.toString().slice(1)));
+					});
+					if (classes.size !== 1) return;
+					const [className] = classes;
+					if (!className || !prunable.has(className) || used.has(className)) return;
+					candidate.remove();
+					removedAny = true;
+					session.prunedClasses.add(className);
+				});
+			}).processSync(rule.selector);
+		} catch {
+			return;
+		}
+		if (!removedAny) return;
+		if (!selector.trim()) {
+			rule.remove();
+			return;
+		}
+		rule.selector = selector;
+	});
+	let removed = true;
+	while (removed) {
+		removed = false;
+		root.walkAtRules((rule) => {
+			if (rule.nodes?.length !== 0) return;
+			rule.remove();
+			removed = true;
+		});
+	}
+	const present = /* @__PURE__ */ new Set();
+	root.walkRules((rule) => {
+		if (!isUtilityRule(rule)) return;
+		try {
+			selectorParser((selectors) => {
+				selectors.walkClasses((classNode) => {
+					present.add(bare(classNode.toString().slice(1)));
+				});
+			}).processSync(rule.selector);
+		} catch {}
+	});
+	const required = requiredClasses ?? new Set([...session.usedClasses].filter((className) => prunable.has(bare(className))));
+	const orphaned = [];
+	for (const className of required) {
+		if (/\s/.test(className)) {
+			orphaned.push(className);
+			continue;
+		}
+		if (present.has(bare(className))) continue;
+		orphaned.push(className);
+	}
+	if (orphaned.length) {
+		const describe = (className) => {
+			if (/\s/.test(className)) return `  ${className}\n      (malformed key: a class name cannot contain whitespace)`;
+			const normalized = bare(className);
+			const extracted = prunable.has(normalized) ? "in the extracted atoms" : "NOT extracted";
+			const near = [...present].filter((candidate) => candidate !== className && candidate.replaceAll("\\", "") === normalized);
+			return `  ${className}\n      (${extracted}; no rule in the sheet` + (near.length ? `; a rule exists under ${near.map((n) => JSON.stringify(n)).join(", ")}` : "") + `)`;
+		};
+		const environmentDescription = environment ? ` for the ${JSON.stringify(environment)} environment` : "";
+		throw new Error(`bamboocss: ${orphaned.length} compiled class(es) still named by live output have no rule in the candidate stylesheet${environmentDescription}. Elements carrying them would render unstyled.\n\n${truncateList(orphaned.map(describe), {
+			unit: "class",
+			separator: "\n"
+		})}\n\nThe current source generation no longer provides every rule required by the JavaScript outputs still on disk. Bamboo refused to replace the prior stylesheet. Finish rebuilding every output which retains an older generation, then rebuild the stylesheet. If every output is already current, report this as a compiler bug with the block above.`);
+	}
+	return root.toString();
+};
+//#endregion
+//#region src/css-output-module.ts
+const INLINE_SOURCE_MAP = /\n?\/\/# sourceMappingURL=data:application\/json[^\n]*$/;
+/** Rewrite one generated chunk without invalidating all mappings after the changed string. */
+const replaceChunkReference = (chunk, bundle, previous, next, sourcemap) => {
+	if (!chunk.code.includes(previous)) return;
+	const magic = new MagicString(chunk.code);
+	let index = chunk.code.indexOf(previous);
+	while (index !== -1) {
+		magic.overwrite(index, index + previous.length, next);
+		index = chunk.code.indexOf(previous, index + previous.length);
+	}
+	chunk.code = magic.toString();
+	if (!chunk.map) return;
+	const file = chunk.map.file;
+	const debugId = chunk.map.debugId;
+	const combined = remapping([magic.generateMap({
+		source: chunk.fileName,
+		hires: "boundary"
+	}), chunk.map], () => null);
+	if (file) combined.file = file;
+	if (debugId) combined.debugId = debugId;
+	const rollupMap = combined;
+	rollupMap.toUrl = () => `data:application/json;charset=utf-8;base64,${Buffer.from(combined.toString()).toString("base64")}`;
+	chunk.map = rollupMap;
+	if (sourcemap === "inline") {
+		chunk.code = chunk.code.replace(INLINE_SOURCE_MAP, "");
+		chunk.code += `\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,${Buffer.from(combined.toString()).toString("base64")}`;
+		return;
+	}
+	const mapAsset = bundle[`${chunk.fileName}.map`];
+	if (mapAsset?.type === "asset") mapAsset.source = combined.toString();
+};
+/** Replace an emitted filename wherever Vite or Rollup has already recorded it. */
+const replaceAssetReferences = (bundle, previous, next, sourcemap) => {
+	const replace = (value) => value.replaceAll(previous, next);
+	for (const output of Object.values(bundle)) {
+		if (output.type === "asset") {
+			if (typeof output.source === "string") output.source = replace(output.source);
+			continue;
+		}
+		replaceChunkReference(output, bundle, previous, next, sourcemap);
+		const referencedFiles = output.referencedFiles;
+		if (referencedFiles) output.referencedFiles = referencedFiles.map(replace);
+		const importedCss = output.viteMetadata?.importedCss;
+		if (importedCss?.delete(previous)) importedCss.add(next);
+	}
+};
+/**
+* Could this bundle entry be the generated stylesheet?
+*
+* The filename is checked before the bytes because the alternative decodes every asset in the
+* bundle to a UTF-8 string in order to search it — fonts, images and sourcemaps included. On an
+* app with a large asset graph that is seconds of decode and a lot of garbage, twice over, to
+* answer a question the extension already answers. The marker is a CSS custom property, so it
+* cannot occur anywhere but CSS.
+*/
+const isCssAsset = (output) => output.type === "asset" && output.fileName.endsWith(".css");
+/** Decode a generated Bamboo stylesheet, or decline any other bundle entry. */
+const generatedCssSource = (output) => {
+	if (!isCssAsset(output)) return void 0;
+	const source = typeof output.source === "string" ? output.source : Buffer.from(output.source).toString();
+	return source.includes("--made-with-bamboo") ? source : void 0;
+};
+/** Whether this bundle replaces a previously generated Bamboo stylesheet. */
+const containsGeneratedCssAsset = (bundle) => Object.values(bundle).some((output) => generatedCssSource(output) !== void 0);
+/**
+* Prune compiler-owned CSS, then give any sheet whose bytes changed a hash of those bytes.
+*
+* Rollup has already expanded `[hash]` when `generateBundle` runs. Mutating only `source`
+* would therefore leave two different reachable subsets under one CDN key. The extra final
+* hash is not cosmetic: it makes late graph reachability cache-safe.
+*
+* Renaming is therefore not a choice this takes. Pruned bytes under the unpruned sheet's name
+* is the one outcome that must never be reachable, and a sheet nothing was removed from keeps
+* its name because its bytes are unchanged — so "rename" is a consequence of "the bytes moved",
+* not a second option. `prune` is the only knob.
+*/
+const optimizeStaticCssAssets = (bundle, session, options = {}) => {
+	const { environment, prune = true, requiredClasses, sourcemap = session.sourcemap } = options;
+	/** Assets in this bundle that carry the generated stylesheet, pruned or not. */
+	let sheets = 0;
+	for (const output of Object.values(bundle)) {
+		const source = generatedCssSource(output);
+		if (source === void 0) continue;
+		sheets++;
+		const optimized = pruneStaticCss(source, session, {
+			environment,
+			prune,
+			requiredClasses
+		});
+		if (!prune) continue;
+		output.source = optimized;
+		if (optimized === source) continue;
+		const nextName = output.fileName.replace(/\.css$/, `.b-${toHash(optimized)}.css`);
+		if (bundle[nextName] && bundle[nextName] !== output) throw new Error(`bamboocss: final CSS asset name collision at ${JSON.stringify(nextName)}.`);
+		const previous = output.fileName;
+		output.fileName = nextName;
+		replaceAssetReferences(bundle, previous, nextName, sourcemap);
+	}
+	return { sheets };
+};
+//#endregion
+export { containsGeneratedCssAsset, optimizeStaticCssAssets, pruneStaticCss };